fix(isc): NodeAdapter correctness + 15 specs + run_stage_only extraction

NodeAdapter fixes:
- Boundaries are Aliases referencing Stdlib symbols (not separate classes)
- CaptureRef (not Capture) for ref(N) items
- CaptureGroup wraps converted inner item
- Run rules use Node::Item::Stage for stage references

DocumentBuilder fix:
- run_stage_only: extract stage name from Parslet tree inner hash
  (was passing the outer hash, producing raw inspection string)

15 new NodeAdapter specs covering: metadata, tests, stages, parallel
blocks, sub rules, aliases, captures, any(), boundaries, constraints,
run directives, and end-to-end transliteration.

Author: ronaldtse

lib/interscript/isc/document_builder.rb

@@ -218,7 +218,7 @@ def extract_stage_items(n)
         when n[:compose]   then [{ kind: :compose }]
         when n[:case]      then [{ kind: :string_case, op: n[:case].to_s }]
         when n[:dep]       then [{ kind: :run, dependency: ident(n[:dep]), stage: ident(n[:stage]) }]
-        when n[:run_stage_only] then [{ kind: :run, dependency: nil, stage: ident(n[:run_stage_only]) }]
+        when n[:run_stage_only] then [{ kind: :run, dependency: nil, stage: ident(n[:run_stage_only][:stage]) }]
         when n[:bare_rule] then [{ kind: :bare_rule, rule: extract_rule(n[:bare_rule]) }]
         when n[:comment]   then []
         when n[:noop]      then []

lib/interscript/isc/node_adapter.rb

@@ -106,13 +106,11 @@ def build_rule(rule_def)
       end
 
       def build_run_rule(item)
-        dep = item[:dependency]
-        stage = item[:stage]
-        Interscript::Node::Rule::Run.new(
-          Interscript::Node::Rule::Run::Map.new(
-            (dep ? "#{dep}:" : "") + stage.to_s,
-          ),
+        stage_ref = Interscript::Node::Item::Stage.new(
+          item[:stage].to_sym,
+          map: item[:dependency]&.to_sym,
         )
+        Interscript::Node::Rule::Run.new(stage_ref)
       end
 
       def convert_item(item)
@@ -126,13 +124,13 @@ def convert_item(item)
         when Items::AliasRef
           Interscript::Node::Item::Alias.new(item.name.to_sym)
         when Items::Capture
-          Interscript::Node::Item::Capture.new(item.index)
+          Interscript::Node::Item::CaptureRef.new(item.index)
         when Items::Function
           item.name.to_sym
         when Items::Concat
           convert_concat(item)
         when Items::CaptureGroup
-          convert_item(item.inner)
+          Interscript::Node::Item::CaptureGroup.new(convert_item(item.inner))
         when Items::Maybe
           Interscript::Node::Item::Maybe.new(convert_item(item.inner))
         when Items::Some
@@ -149,20 +147,9 @@ def convert_item(item)
       end
 
       def convert_primitive(item)
-        case item.name
-        when "boundary"
-          Interscript::Node::Item::BeginBoundary.new
-        when "line_start"
-          Interscript::Node::Item::StartBoundary.new
-        when "line_end"
-          Interscript::Node::Item::EndBoundary.new
-        when "word_boundary"
-          Interscript::Node::Item::WordBoundary.new
-        when "space"
-          Interscript::Node::Item::String.new(" ")
-        when "non_boundary"
-          Interscript::Node::Item::NonBoundary.new
-        end
+        # In the Ruby runtime, zero-width primitives are represented as
+        # Alias nodes referencing Stdlib symbols. See Stdlib::ALIASES.
+        Interscript::Node::Item::Alias.new(item.name.to_sym)
       end
 
       def convert_concat(concat)

spec/interscript/isc/node_adapter_spec.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require "interscript"
+require "interscript/isc"
+
+RSpec.describe Interscript::Isc::NodeAdapter do
+  let(:parser) { Interscript::Isc::Parser.new }
+
+  def parse_and_adapt(src)
+    tree = parser.parse(src, filename: "test.isc")
+    doc = Interscript::Isc::DocumentBuilder.build(tree, filename: "test.isc")
+    described_class.to_interscript_node(doc)
+  end
+
+  describe ".to_interscript_node" do
+    it "produces a Node::Document" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata {
+            authority_id test
+            name "Test"
+          }
+          stage main {
+            sub "a" "b"
+          }
+        }
+      ISC
+      expect(node).to be_a(Interscript::Node::Document)
+    end
+
+    it "extracts metadata" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata {
+            authority_id alalc
+            id 1997
+            name "Test Map"
+          }
+          stage main { }
+        }
+      ISC
+      expect(node.metadata.data[:authority_id]).to eq("alalc")
+      expect(node.metadata.data[:id]).to eq("1997")
+      expect(node.metadata.data[:name]).to eq("Test Map")
+    end
+
+    it "extracts tests" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          tests {
+            "hello" -> "world"
+          }
+          stage main { }
+        }
+      ISC
+      expect(node.tests).to be_a(Interscript::Node::Tests)
+      expect(node.tests.data.size).to eq(1)
+      expect(node.tests.data[0][0]).to eq("hello")
+      expect(node.tests.data[0][1]).to eq("world")
+    end
+
+    it "builds a main stage" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          stage main {
+            sub "a" "b"
+          }
+        }
+      ISC
+      expect(node.stages).to have_key(:main)
+      expect(node.stages[:main]).to be_a(Interscript::Node::Stage)
+    end
+
+    it "converts parallel blocks" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          stage main {
+            parallel {
+              sub "a" "b"
+              sub "c" "d"
+            }
+          }
+        }
+      ISC
+      stage = node.stages[:main]
+      parallel = stage.children.find { |c| c.is_a?(Interscript::Node::Group::Parallel) }
+      expect(parallel).not_to be_nil
+      expect(parallel.children.size).to eq(2)
+    end
+
+    it "converts sub rules with from/to" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          stage main {
+            sub "x" "y"
+          }
+        }
+      ISC
+      rule = node.stages[:main].children.first
+      expect(rule).to be_a(Interscript::Node::Rule::Sub)
+      expect(rule.from).to be_a(Interscript::Node::Item::String)
+      expect(rule.to).to be_a(Interscript::Node::Item::String)
+    end
+
+    it "converts block-form sub rules" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          stage main {
+            sub {
+              from "a" + "b"
+              to "c"
+            }
+          }
+        }
+      ISC
+      rule = node.stages[:main].children.first
+      expect(rule.from).to be_a(Interscript::Node::Item::String)
+      expect(rule.to).to be_a(Interscript::Node::Item::String)
+    end
+
+    it "converts aliases" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          aliases {
+            my_alias = "abc"
+          }
+          stage main {
+            sub my_alias "x"
+          }
+        }
+      ISC
+      expect(node.aliases).to have_key(:my_alias)
+      rule = node.stages[:main].children.first
+      expect(rule.from).to be_a(Interscript::Node::Item::Alias)
+    end
+
+    it "converts capture and ref" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          stage main {
+            sub capture("x") ref(1)
+          }
+        }
+      ISC
+      rule = node.stages[:main].children.first
+      expect(rule.from).to be_a(Interscript::Node::Item::CaptureGroup)
+      expect(rule.to).to be_a(Interscript::Node::Item::CaptureRef)
+    end
+
+    it "converts any() constructor" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          stage main {
+            sub any("abc") "x"
+          }
+        }
+      ISC
+      rule = node.stages[:main].children.first
+      expect(rule.from).to be_a(Interscript::Node::Item::Any)
+    end
+
+    it "converts boundary primitives" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          stage main {
+            sub boundary "X"
+          }
+        }
+      ISC
+      rule = node.stages[:main].children.first
+      expect(rule.from).to be_a(Interscript::Node::Item::Alias)
+    end
+
+    it "converts constraints" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          stage main {
+            sub "a" "b"
+              before "c"
+              after "d"
+          }
+        }
+      ISC
+      rule = node.stages[:main].children.first
+      expect(rule.before).to be_a(Interscript::Node::Item::String)
+      expect(rule.after).to be_a(Interscript::Node::Item::String)
+    end
+
+    it "converts run directive" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          stage main {
+            run map.dep.stage.main
+          }
+        }
+      ISC
+      run_rule = node.stages[:main].children.first
+      expect(run_rule).to be_a(Interscript::Node::Rule::Run)
+    end
+  end
+
+  describe "transliteration integration" do
+    it "produces correct transliteration through the Node pipeline" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          stage main {
+            parallel {
+              sub "a" "b"
+              sub "c" "d"
+            }
+          }
+        }
+      ISC
+      interp = Interscript::Interpreter.new
+      interp.compile(node)
+      result = interp.call("acd")
+      expect(result).to eq("bdd")
+    end
+
+    it "handles multi-stage pipelines" do
+      node = parse_and_adapt(<<~ISC)
+        system "TEST:eng-Latn:Latn:2026" {
+          metadata { name "T" }
+          stage first {
+            sub "a" "b"
+          }
+          stage main {
+            run stage.first
+            sub "b" "c"
+          }
+        }
+      ISC
+      interp = Interscript::Interpreter.new
+      interp.compile(node)
+      result = interp.call("a")
+      expect(result).to eq("c")
+    end
+  end
+end