feat(isc): rababa funcall directive — grammar, kwargs, node adapter

The rababa directive (rababa config: "key") parses as a Funcall node
with string kwargs instead of a passthrough comment; the codemod
emits it directly. Grammar gains a general kwarg_list. Also fixes the
Isc autoload constant (was ISC). Without this the var-ara map does not
parse — caught by the maps CI parse-all job.

Author: ronaldtse

lib/interscript.rb

@@ -11,7 +11,7 @@ module Interscript
   autoload :DSL, "interscript/dsl"
   autoload :Node, "interscript/node"
   autoload :Detector, "interscript/detector"
-  autoload :ISC, "interscript/isc"
+  autoload :Isc, "interscript/isc"
 
   # An error caused by a lack of some map
   class MapNotFoundError < StandardError; end

lib/interscript/isc/codemod.rb

@@ -119,12 +119,8 @@ def convert_body
           elsif @scanner.scan(/stage\b/)
             @out << "stage"
             convert_stage_header
-          elsif @scanner.scan(/\b(parallel|sequence|separate|deep|compose|decompose|downcase|upcase|title_case)\b/)
+          elsif @scanner.scan(/\b(parallel|sequence|separate|deep|compose|decompose|downcase|upcase|title_case|rababa)\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

@@ -133,6 +133,23 @@ def ident(fragment)
         @transform.apply(fragment).to_s
       end
 
+      # Extract `name: "value"` pairs from a parslet kwarg tree into a
+      # string-keyed Hash. The tree is `{kwarg: [{kwarg_name:, kwarg_value:}, ...]}`
+      # or a single `{kwarg_name:, kwarg_value:}` for one kwarg.
+      def extract_kwargs(fragment)
+        return {} if fragment.nil?
+        raw = fragment.is_a?(Hash) ? fragment[:kwarg] : fragment
+        kwargs = case raw
+                 when Hash  then [raw]
+                 when Array then raw.select { |k| k.is_a?(Hash) }
+                 else []
+                 end
+        kwargs.each_with_object({}) do |kw, h|
+          next unless kw.is_a?(Hash)
+          h[ident(kw[:kwarg_name])] = unquote(kw[:kwarg_value])
+        end
+      end
+
       def derive_urn(code)
         "urn:iso:24229:system:#{code.downcase}"
       end
@@ -240,6 +257,7 @@ def extract_stage_items(n)
         when n[:separate]  then [{ kind: :separate, separator: n[:separator] ? materialize(n[:separator]) : nil }]
         when n[:compose]   then [{ kind: :compose }]
         when n[:case]      then [{ kind: :string_case, op: n[:case].to_s }]
+        when n[:funcall_name] then [{ kind: :funcall, name: n[:funcall_name].to_s, kwargs: extract_kwargs(n[:funcall_kwargs]) }]
         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][:stage]) }]
         when n[:bare_rule] then [{ kind: :bare_rule, rule: extract_rule(n[:bare_rule]) }]

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

@@ -20,8 +20,8 @@ module Stages
           rule(:stage_item) do
             whitespace? >>
               (sequence_block | parallel_block | run_rule | separate_directive |
-                string_case_directive | compose_directive | bare_rule |
-                comment_item) >>
+                string_case_directive | compose_directive | rababa_directive |
+                bare_rule | comment_item) >>
               whitespace?
           end
 
@@ -58,9 +58,29 @@ module Stages
             (str("downcase") | str("upcase") | str("title_case")).as(:case)
           end
 
-          # `compose` — compose decomposed characters (NFC-ish).
+          # `compose` / `decompose` — Unicode normalization directives.
           rule(:compose_directive) do
-            (str("compose") | str("decompose")).as(:compose)
+            str("compose").as(:compose) | str("decompose").as(:compose)
+          end
+
+          # `rababa config: "key"` — invoke the rababa diacritization service.
+          # The keyword arguments are passed through to the runtime funcall.
+          rule(:rababa_directive) do
+            str("rababa").as(:funcall_name) >>
+              (whitespace >> kwarg_list.as(:funcall_kwargs)).maybe
+          end
+
+          # `name: "value"` (`,`-separated). Used by rababa and other
+          # function-call directives. Each kwarg is captured as a
+          # subtree so multiple kwargs collect into a list.
+          rule(:kwarg_list) do
+            kwarg.as(:kwarg) >> (str(",") >> whitespace? >> kwarg.as(:kwarg)).repeat
+          end
+
+          rule(:kwarg) do
+            identifier.as(:kwarg_name) >> whitespace? >>
+              str(":") >> whitespace? >>
+              quoted_string.as(:kwarg_value)
           end
 
           rule(:rule_line) do

lib/interscript/isc/node_adapter.rb

@@ -88,6 +88,11 @@ def build_stage(stage_def)
             stage.children << sym
           when :compose
             stage.children << :compose
+          when :funcall
+            stage.children << Interscript::Node::Rule::Funcall.new(
+              item[:name].to_sym,
+              **item[:kwargs].transform_keys(&:to_sym),
+            )
           end
         end
         stage