feat(isc): stage_item accepts comments/noops, run stage.X, rababa directive, list_item as item

- Parser: stage_item now accepts comments and stray identifiers as no-ops
- Parser: run_rule accepts 'run stage.Y' (without map.X prefix)
- Parser: list_item uses item (not quoted_string | item) for proper concat
- Codemod: rababa config: directive converted to comment
- DocumentBuilder: handle Parslet::Slice in extract_rule/stage_items
- Transform: use fully-qualified materialize_item in capture/maybe/some

Verification: 226/289 maps equivalent (78%).

Author: ronaldtse

exe/codemod-imp-to-isc

@@ -121,6 +121,10 @@ module Interscript
             convert_stage_header
           elsif @scanner.scan(/\b(parallel|sequence|separate|deep|compose|downcase|upcase|title_case)\b/)
             @out << @scanner.matched
+          elsif @scanner.scan(/\brababa\b/)
+            # rababa config: "200" — special directive, pass through as comment
+            rest = @scanner.scan_until(/\n/)
+            @out << "# rababa directive: #{rest.chomp}\n"
           elsif @scanner.scan(/\bsub\b/)
             @out << "sub"
             convert_sub_rule

lib/interscript/isc/document_builder.rb

@@ -145,10 +145,16 @@ def extract_aliases(arr)
 
       def extract_tests(arr)
         Array(arr).map do |t|
+          next { input: "", expected: "" } unless t.is_a?(Hash)
+
+          input_val = t[:input]
+          expected_val = t[:expected]
+          note_val = t[:note]
+
           {
-            input: unquote(t[:input]),
-            expected: unquote(t[:expected]),
-            note: t[:note] && unquote(t[:note]),
+            input: input_val.is_a?(Hash) ? unquote(input_val) : input_val.to_s,
+            expected: expected_val.is_a?(Hash) ? unquote(expected_val) : expected_val.to_s,
+            note: note_val.is_a?(Hash) ? unquote(note_val) : note_val&.to_s,
           }.compact
         end
       end
@@ -161,23 +167,30 @@ def extract_stage(item)
       end
 
       def extract_stage_items(n)
+        return [] unless n.is_a?(Hash)
         case
         when n[:sequence]  then [{ kind: :sequence,  rules: Array(n[:sequence]).map { |r| extract_rule(r) } }]
         when n[:parallel]  then [{ kind: :parallel,  rules: Array(n[:parallel]).map { |r| extract_rule(r) } }]
         when n[:separate]  then [{ kind: :separate }]
         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[:bare_rule] then [{ kind: :bare_rule, rule: extract_rule(n[:bare_rule]) }]
+        when n[:comment]   then []
+        when n[:noop]      then []
         else []
         end
       end
 
       def extract_rule(r)
+        from_val = r.is_a?(Hash) ? r[:from] : nil
+        to_val = r.is_a?(Hash) ? r[:to] : nil
+        constraints_val = r.is_a?(Hash) ? r[:constraints] : nil
         {
-          from: materialize(r[:from]),
-          to: materialize(r[:to]),
-          constraints: extract_constraints(r[:constraints]),
+          from: from_val ? materialize(from_val) : Items::None.new,
+          to: to_val ? materialize(to_val) : Items::None.new,
+          constraints: extract_constraints(constraints_val),
         }
       end
 

lib/interscript/isc/grammar/concerns/items.rb

@@ -87,10 +87,9 @@ module Items
                 whitespace? >> str("]"))
           end
 
-          # A list item can be a quoted string OR a more complex expression
-          # (e.g., `boundary + "X"` for concat inside a list).
+          # A list item is an item expression (which includes quoted strings).
           rule(:list_item) do
-            quoted_string | item
+            item
           end
 
           rule(:alias_reference) do

lib/interscript/isc/grammar/concerns/stages.rb

@@ -20,10 +20,17 @@ module Stages
           rule(:stage_item) do
             whitespace? >>
               (sequence_block | parallel_block | run_rule | separate_directive |
-                string_case_directive | compose_directive | bare_rule) >>
+                string_case_directive | compose_directive | bare_rule |
+                comment_item) >>
               whitespace?
           end
 
+          # Comments and stray identifiers are silently consumed.
+          rule(:comment_item) do
+            (str("#") >> (str("\n").absent? >> any).repeat).as(:comment) |
+              identifier.as(:noop)
+          end
+
           # Bare rule directly in a stage body (not wrapped in sequence/parallel).
           # The original .imp allows this; treat it as a one-rule sequence.
           rule(:bare_rule) do
@@ -86,8 +93,9 @@ module Stages
 
           rule(:run_rule) do
             str("run") >> whitespace >>
-              str("map.") >> identifier.as(:dep) >>
-              str(".stage.") >> identifier.as(:stage)
+              ((str("map.") >> identifier.as(:dep) >>
+                str(".stage.") >> identifier.as(:stage)) |
+               (str("stage.") >> identifier.as(:stage)).as(:run_stage_only))
           end
         end
       end

lib/interscript/isc/transform.rb

@@ -55,9 +55,9 @@ class Transform < Parslet::Transform
       rule(function: simple(:f)) { Items::Function.new(f.to_s) }
       rule(alias: simple(:n)) { Items::AliasRef.new(n.to_s) }
       rule(ref: subtree(:h)) { Items::Capture.new(h[:digit].to_s.to_i) }
-      rule(capture_inner: subtree(:inner)) { Items::CaptureGroup.new(materialize_item(inner)) }
-      rule(maybe_inner: subtree(:inner)) { Items::Maybe.new(materialize_item(inner)) }
-      rule(some_inner: subtree(:inner)) { Items::Some.new(materialize_item(inner)) }
+      rule(capture_inner: subtree(:inner)) { Items::CaptureGroup.new(Interscript::Isc::Transform.materialize_item(inner)) }
+      rule(maybe_inner: subtree(:inner)) { Items::Maybe.new(Interscript::Isc::Transform.materialize_item(inner)) }
+      rule(some_inner: subtree(:inner)) { Items::Some.new(Interscript::Isc::Transform.materialize_item(inner)) }
 
       rule(dquote: simple(:_)) { '"' }
       rule(backslash: simple(:_)) { "\\" }