fix: alias refs in any() keep set semantics like the legacy DSL

Bare identifiers inside any(...) parsed as :alias_ref, which no
transform rule matched — the hash degraded downstream into the debug
string "[:alias_ref, \"greek\"]" baked into constraint regexps, so
every context-gated rule silently never fired (Greek velar
assimilation γ→n, ta-marbuta contexts). Two parts:

- transform rules for :alias_ref (list entries and single any() args)
- single-alias any() args stay a Set; imported aliases compile to the
  vacuous fragment exactly as the legacy runtime's Any(nil) does —
  resolving them to the charset string would bake a 1000-char literal
  into a lookbehind that never matches

Author: ronaldtse

lib/interscript/isc/node_adapter.rb

@@ -218,7 +218,14 @@ def convert_set(set)
             when Items::Primitive
               convert_primitive(c)
             when Items::AliasRef
-              convert_alias_ref(c)
+              # Legacy parity: a bare alias inside any(...) compiles to the
+              # Stdlib value (Any(nil) there for imported aliases). Keeping
+              # the Alias item resolves to the imported charset *string* at
+              # build time, baking a 1000-char literal into the constraint
+              # regexp — a lookbehind that never matches.
+              name = convert_alias_ref(c).name
+              val = Interscript::Stdlib::ALIASES[name]
+              val ? Interscript::Node::Item::Any.new(val) : Interscript::Node::Item::String.new("")
             else
               convert_item(c)
             end

lib/interscript/isc/transform.rb

@@ -29,6 +29,11 @@ class Transform < Parslet::Transform
         Items::AliasRef.new(q.to_s, map: n.to_s)
       }
       rule(alias: simple(:n)) { Items::AliasRef.new(n.to_s) }
+      # Bare identifiers inside any(...) lists parse as :alias_ref (the
+      # :alias key only covers direct item position). Unmatched, the hash
+      # degraded downstream into the debug string "[:alias_ref, \"name\"]".
+      rule(alias_ref: {identifier: simple(:n)}) { Items::AliasRef.new(n.to_s) }
+      rule(alias_ref: 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(Interscript::Isc::Transform.materialize_item(inner)) }
       rule(maybe_inner: subtree(:inner)) { Items::Maybe.new(Interscript::Isc::Transform.materialize_item(inner)) }
@@ -84,7 +89,13 @@ def self.decode_string_parts(parts)
       rule(list: sequence(:arr)) do
         Items::Set.new(arr)
       end
-      rule(any: subtree(:h)) { h }
+      rule(any: subtree(:h)) do
+        # A single alias argument keeps set semantics: the legacy runtime
+        # builds Any(Alias) which resolves through Stdlib (Any(nil) for
+        # imported aliases). Unwrapped, the bare Alias resolves to the
+        # imported charset string and compiles as a literal.
+        h.is_a?(Items::AliasRef) ? Items::Set.new([h]) : h
+      end
 
       rule(concatenation: subtree(:parts)) do
         Items::Concat.from_parts(Array(parts))

spec/interscript/isc/node_adapter_spec.rb

@@ -326,3 +326,35 @@ def parse_and_adapt(src)
     expect(tests[1]).to eq(["a\tb\nc", "déjà"])
   end
 end
+
+RSpec.describe "NodeAdapter alias refs in constraints" do
+  it "compiles bare alias refs in sets like the legacy DSL — no debug dump, no literal-charset lookbehind" do
+    src = <<~ISC
+      system "t:g-c:C-D:1" {
+        metadata { name "T" }
+        stage main {
+          sub {
+            from "γ"
+            to "n"
+            before any(greek)
+            after any("κΚ") + any(greek)
+            not_before boundary
+          }
+        }
+      }
+    ISC
+    node = Interscript::Isc::NodeAdapter.to_interscript_node(
+      Interscript::Isc::DocumentBuilder.build(Interscript::Isc::Parser.parse(src))
+    )
+    rule = node.stages[:main].children.first
+    expect(rule.before).to be_a(Interscript::Node::Item::Any)
+    expect(rule.before.inspect).not_to include("alias_ref")
+    expect(rule.after.inspect).not_to include("alias_ref")
+    # The legacy runtime compiles an imported alias in a set to a vacuous
+    # fragment (Any(nil)); resolving it to the charset *string* would bake
+    # a 1000-char literal into the lookbehind and never match.
+    interp = Interscript::Interpreter.new
+    interp.compile(node)
+    expect(interp.call("αγκα")).to eq("αnκα")
+  end
+end