fix(isc): achieve 289/289 parse parity with escaped braces, primitive-aware alias_arg, and multi-line field handlers

Codemod fixes:
- Remove broken "Generic field with multi-line quoted value" code that was
  leaking into the multi-line list handler (caused iso-ara/ua-ukr regressions)
- Multi-line list handler now wraps in braces and uses
  convert_indented_block_until_dedent for continuation lines
- Add multi-line unquoted text handler for fields like original_notes
- Escape literal braces in heredoc/raw text bodies so braces in description
  blocks (e.g. Python code in moct-kor) don't prematurely close the block
- Drop colon after separator keyword

Grammar fixes:
- raw_text rule handles escaped braces for description bodies
- alias_arg excludes zero-width primitives so any(space+line_end) parses
  correctly instead of greedily consuming space as an alias name
- separate_directive accepts optional separator argument

DocumentBuilder:
- Handle field_block in extract_metadata (braced generic fields)
- unescape_braces reverses the codemod escaping for description/field_block
- Extract separator from separate directive

Author: ronaldtse

exe/codemod-imp-to-isc

@@ -145,7 +145,7 @@ module Interscript
           elsif @scanner.scan(/,/)
             # Trailing comma — drop in compact rule contexts, leave elsewhere.
             @out << ""
-          elsif @scanner.scan(/(before|after|not_before|not_after):/)
+          elsif @scanner.scan(/(before|after|not_before|not_after|separator):/)
             # Drop the colon in modifier kwarg form.
             @out << "#{@scanner[1]} "
           elsif @scanner.scan(/[A-Za-z_][A-Za-z0-9_]*/)
@@ -301,32 +301,19 @@ module Interscript
             indent = @scanner[1]
             field = @scanner[2]
             item_indent = @scanner[3]
-            @out << "\n#{indent}#{field} "
+            @out << "\n#{indent}#{field} {"
+            @out << "\n#{item_indent}- "
             text = @scanner.scan(/[^\n]+/).to_s
-            @out << text
-            while @scanner.check(/\n[ \t]{#{item_indent.length},}-[ \t]/)
-              @scanner.scan(/\n[ \t]+-[ \t]+/)
-              text = @scanner.scan(/[^\n]+/).to_s
-              @out << " " + text
-            end
-          # Generic field with multi-line quoted value
-          indent = @scanner[1]
+            @out << escape_braces(text)
+            convert_indented_block_until_dedent(indent)
+            @out << "\n#{indent}}"
+          elsif @scanner.scan(/(?:\A|\n)([ \t]+)([A-Za-z_][\w]*)[ \t]*:[ \t]*\n([ \t]+)(?![ \t]*(?:-|"|\[|\]|\|))(?![ \t]*$)/)
+            # Multi-line unquoted text value: `field:\n    text` (not list, quote, heredoc)
+            indent = @scanner[1]
             field = @scanner[2]
-            @out << "\n#{indent}#{field} \""
-            until @scanner.eos?
-              if @scanner.scan(/[^"\n]+/)
-                @out << @scanner.matched
-              elsif @scanner.scan(/"/)
-                @out << @scanner.matched
-                break
-              elsif @scanner.scan(/\n[ \t]+/)
-                @out << " "
-              elsif @scanner.scan(/\n/)
-                @out << " "
-              else
-                break
-              end
-            end
+            @out << "\n#{indent}#{field} {"
+            convert_indented_block_until_dedent(indent)
+            @out << "\n#{indent}}"
           elsif @scanner.scan(/(?:\A|\n)([ \t]+)([A-Za-z_][\w]*)[ \t]*:[ \t]*\|[ \t]*\n/)
             # Generic field with heredoc: `field: |\n    body`
             indent = @scanner[1]
@@ -365,13 +352,17 @@ module Interscript
           elsif @scanner.scan(/\n/)
             @out << "\n"
           elsif @scanner.scan(/[^\n]+/)
-            @out << @scanner.matched
+            @out << escape_braces(@scanner.matched)
           else
             @out << @scanner.getch
           end
         end
       end
 
+      def escape_braces(text)
+        text.gsub("\\", "\\\\\\\\").gsub(/[{}]/) { |c| "\\#{c}" }
+      end
+
       # Notes list: each item begins with `- `. Convert each to `note "..."`.
       # A `- |` item is a multi-line YAML heredoc; consume subsequent indented lines.
       def convert_notes_list_until_dedent(indent)

lib/interscript/isc/document_builder.rb

@@ -72,6 +72,10 @@ def unquote(fragment)
         out.is_a?(Items::StringValue) ? out.value : out.to_s
       end
 
+      def unescape_braces(text)
+        text.gsub(/\\([{}\\])/, '\1')
+      end
+
       # Apply Transform to an identifier fragment.
       def ident(fragment)
         return "" if fragment.nil?
@@ -104,18 +108,22 @@ def extract_metadata(arr)
           when field.key?(:relations)
             h[:relations] = extract_relations(field[:relations])
           when field.key?(:description)
-            h[:description] = field[:description].to_s.strip
+            h[:description] = unescape_braces(field[:description].to_s.strip)
           when field.key?(:field_name)
             # Generic field: identifier + raw value
             name = ident(field[:field_name]).to_sym
-            raw = field[:field_value]
-            val_str = case raw
-                      when Hash
-                        raw.key?(:string) ? unquote(raw) : (raw[:raw]&.to_s || "").strip
-                      when nil then ""
-                      else raw.to_s.strip
-                      end
-            h[name] = val_str
+            if field.key?(:field_block)
+              h[name] = unescape_braces(field[:field_block].to_s.strip)
+            else
+              raw = field[:field_value]
+              val_str = case raw
+                        when Hash
+                          raw.key?(:string) ? unquote(raw) : (raw[:raw]&.to_s || "").strip
+                        when nil then ""
+                        else raw.to_s.strip
+                        end
+              h[name] = val_str
+            end
           else
             # Specific named field (authority, name, system_status, etc.)
             field.each do |key, val|
@@ -171,7 +179,7 @@ def extract_stage_items(n)
         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[: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[:dep]       then [{ kind: :run, dependency: ident(n[:dep]), stage: ident(n[:stage]) }]

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

@@ -61,8 +61,10 @@ module Items
           end
 
           # `any(identifier)` — accept a bare alias reference inside any().
+          # Exclude zero-width primitives (space, boundary, etc.) which are
+          # handled by `item` via `zero_width_primitive` in `item_atom`.
           rule(:alias_arg) do
-            (keyword.absent? >> identifier).as(:alias_ref)
+            (zero_width_primitive.absent? >> keyword.absent? >> identifier).as(:alias_ref)
           end
 
           # capture(...) — wraps a sub-expression with a capture group.

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

@@ -130,9 +130,10 @@ module Metadata
           end
 
           # Raw text inside `{ ... }` — for description blocks. Consumes any
-          # character that isn't an unescaped closing brace.
+          # character that isn't an unescaped closing brace. Literal braces
+          # inside the body are escaped as `\{` and `\}` by the codemod.
           rule(:raw_text) do
-            (str("}").absent? >> any).repeat
+            (str("\\{") | str("\\}") | (str("}").absent? >> any)).repeat
           end
         end
       end

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

@@ -48,7 +48,9 @@ module Stages
           end
 
           rule(:separate_directive) do
-            str("separate").as(:separate)
+            str("separate").as(:separate) >>
+              (whitespace >> str("separator") >> whitespace >>
+                item_atom.as(:separator)).maybe
           end
 
           # `downcase`, `upcase`, `title_case` — string-case directives.