interscript 3.2.1 → 3.4.0

data/lib/interscript/isc/node_adapter.rb

@@ -26,10 +26,16 @@ module Interscript
         @local_raw = Array(isc_doc[:aliases]).to_h { |a| [a[:name].to_sym, a[:value]] }
         @charset_cache = {}
         @resolving = []
+        # ISC-WF-1 W1: memoized fully-expanded rulesets, keyed
+        # [dependency alias or nil, ruleset name]; @resolving_rulesets
+        # guards `use` cycles (a load error, spec §6.4).
+        @ruleset_memo = {}
+        @resolving_rulesets = []
       end
 
       def build
         Interscript::Node::Document.new.tap do |doc|
+          @doc = doc
           doc.metadata = build_metadata
           doc.tests = build_tests
           # Maps are addressed by their file-derived name (locate() and
@@ -55,6 +61,10 @@ module Interscript
           # (grek_latn_any = any([grek_any, …])) resolve too.
           @imported = doc.imported_aliases
           doc.aliases = build_aliases(doc.name)
+          # ISC-WF-1: declarations before stage building — `use` expansion
+          # resolves against the document's rulesets and its dependencies'.
+          doc.languages = build_languages
+          doc.rulesets = build_rulesets(doc.name)
           build_stages(doc.name).each { |name, stage| doc.stages[name] = stage }
         end
       end
@@ -126,39 +136,189 @@ module Interscript
         end
       end
 
+      # ISC-WF-1 W1: build + memoize every declared ruleset, fully
+      # expanded (nested `use` resolved, cycles rejected).
+      def build_rulesets(doc_name)
+        Array(@isc_doc[:rulesets]).each_with_object({}) do |rs, h|
+          h[rs[:name].to_sym] = resolve_ruleset(nil, rs[:name], doc_name: doc_name)
+        end
+      end
+
+      def build_languages
+        return nil unless @isc_doc[:languages]&.any?
+
+        Interscript::Node::LanguagesDecl.new(@isc_doc[:languages].map(&:to_sym))
+      end
+
       def build_stage(stage_def)
         stage = Interscript::Node::Stage.new(stage_def[:name].to_sym)
-        stage_def[:body].each do |item|
-          case item[:kind]
-          when :parallel
-            group = Interscript::Node::Group::Parallel.new
-            item[:rules].each { |r| group.children << build_rule(r) }
-            stage.children << group
-          when :sequence
-            item[:rules].each { |r| stage.children << build_rule(r) }
-          when :bare_rule
-            stage.children << build_rule(item[:rule])
-          when :run
-            stage.children << build_run_rule(item)
-          when :separate
-            kwargs = {}
-            kwargs[:separator] = item[:separator].value if item[:separator]
-            stage.children << Interscript::Node::Rule::Funcall.new(:separate, **kwargs)
-          when :string_case
-            stage.children << Interscript::Node::Rule::Funcall.new(item[:op].to_sym,
-              **(item[:kwargs] || {}).transform_keys(&:to_sym))
-          when :compose
-            stage.children << Interscript::Node::Rule::Funcall.new(:compose)
-          when :decompose
-            stage.children << Interscript::Node::Rule::Funcall.new(:decompose)
-          when :funcall
-            stage.children << Interscript::Node::Rule::Funcall.new(
-              item[:name].to_sym,
-              **item[:kwargs].transform_keys(&:to_sym)
-            )
+        expand_items(stage_def[:body]).each { |node| stage.children << node }
+        stage
+      end
+
+      # Build the Nodes for one ISC stage-item def (no `use` — that goes
+      # through expand_use). Returns a list; sequence blocks contribute
+      # their rules individually, parallel blocks one group.
+      def build_stage_item_nodes(item)
+        case item[:kind]
+        when :parallel
+          group = Interscript::Node::Group::Parallel.new
+          item[:rules].each { |r| group.children << build_rule(r) }
+          [group]
+        when :sequence
+          item[:rules].map { |r| build_rule(r) }
+        when :bare_rule
+          [build_rule(item[:rule])]
+        when :run
+          [build_run_rule(item)]
+        when :separate
+          kwargs = {}
+          kwargs[:separator] = item[:separator].value if item[:separator]
+          [Interscript::Node::Rule::Funcall.new(:separate, **kwargs)]
+        when :string_case
+          [Interscript::Node::Rule::Funcall.new(item[:op].to_sym,
+            **(item[:kwargs] || {}).transform_keys(&:to_sym))]
+        when :compose
+          [Interscript::Node::Rule::Funcall.new(:compose)]
+        when :decompose
+          [Interscript::Node::Rule::Funcall.new(:decompose)]
+        when :funcall
+          [Interscript::Node::Rule::Funcall.new(
+            item[:name].to_sym,
+            **item[:kwargs].transform_keys(&:to_sym)
+          )]
+        else
+          []
+        end
+      end
+
+      # -- ISC-WF-1 W1/W2: ruleset expansion --------------------------------
+
+      # Expand a list of ISC stage-item defs into Node children, resolving
+      # `use` directives recursively. Used for both stage bodies and
+      # ruleset bodies (a ruleset body is a stage body, spec §3.1).
+      def expand_items(items)
+        Array(items).flat_map do |item|
+          if item.is_a?(Hash) && item[:kind] == :use
+            expand_use(item)
+          else
+            build_stage_item_nodes(item)
           end
         end
-        stage
+      end
+
+      # Resolve + deep-copy + merge-override one `use` site (spec §3.2, §4).
+      def expand_use(item)
+        rs = resolve_ruleset(item[:dependency], item[:ruleset])
+        apply_overrides(deep_copy_children(rs.children), item[:overrides])
+      end
+
+      # The fully-expanded Node::Ruleset for a reference, memoized.
+      # Same-map rulesets build here; dependency rulesets arrive already
+      # built through the recursive adapter of the dependency document.
+      def resolve_ruleset(dep_alias, name, doc_name: nil)
+        key = [dep_alias&.to_sym, name.to_sym]
+        return @ruleset_memo[key] if @ruleset_memo&.key?(key)
+        raise cycle_error(name) if @resolving_rulesets.include?(key)
+
+        @resolving_rulesets << key
+        node =
+          if dep_alias
+            dep = @doc.dep_aliases[dep_alias.to_sym] ||
+              raise(Interscript::MapLogicError,
+                "use #{dep_alias}.#{name}: no declared dependency aliased #{dep_alias}")
+            dep.document&.rulesets&.[](name.to_sym) ||
+              raise(Interscript::MapLogicError,
+                "use #{dep_alias}.#{name}: ruleset not found in dependency #{dep.full_name}")
+          else
+            rs_def = Array(@isc_doc[:rulesets]).find { |r| r[:name] == name } ||
+              raise(Interscript::MapLogicError, "use #{name}: ruleset not found")
+            Interscript::Node::Ruleset.new(rs_def[:name].to_sym).tap do |rs|
+              rs.doc_name = doc_name
+              expand_items(rs_def[:body]).each { |child| rs.children << child }
+            end
+          end
+        @ruleset_memo[key] = node
+        node
+      ensure
+        @resolving_rulesets.delete(key)
+      end
+
+      def cycle_error(name)
+        Interscript::MapLogicError.new(
+          "use cycle: ruleset #{name} revisited through #{@resolving_rulesets.map { |_, n| n }.join(" -> ")}"
+        )
+      end
+
+      # Per-site deep copy: expansions must not share Group nodes (the
+      # Interpreter caches compiled pass trees on them) nor be mutated by
+      # another site's override merge. Rule/Item leaves are read-only at
+      # execution time and may be shared.
+      def deep_copy_children(children)
+        children.map { |node| deep_copy_node(node) }
+      end
+
+      def deep_copy_node(node)
+        case node
+        when Interscript::Node::Group
+          copy = node.class.new(reverse_run: node.reverse_run)
+          if node.is_a?(Interscript::Node::Stage)
+            copy.name = node.name
+            copy.doc_name = node.doc_name
+            copy.dont_reverse = node.dont_reverse
+          end
+          copy.children = node.children.map { |c| deep_copy_node(c) }
+          copy
+        else
+          node.dup
+        end
+      end
+
+      # ISC-WF-1 W2 merge (spec §4.2). R = the fully expanded ruleset rows
+      # (document order), O = the override rows.
+      #   1. A row whose from is byte-exact equal to an override from is
+      #      REPLACED — removed from wherever it sits; all same-from
+      #      duplicates go (the ruleset's internal last-wins winner is
+      #      superseded too). From-equality is computed on the node's
+      #      structural inspect — for plain strings this is exactly the
+      #      byte-exact string of the corpus convention.
+      #   2. Kept rows keep their order and block structure (§4.2.2 with
+      #      the §3.2 pass-structure inheritance).
+      #   3. The override rows land at the expansion tail: appended INTO
+      #      the final parallel block when the expansion ends with one, so
+      #      the child rows join that block's single longest-match pass
+      #      (§4.2.5, §4.3 — replacement on the source-script pass, not
+      #      post-pass re-substitution); otherwise appended as trailing
+      #      rows. Unmatched overrides are simply added (§4.2.4).
+      def apply_overrides(children, overrides)
+        return children if overrides.nil? || overrides.empty?
+
+        o_rules = overrides.map { |r| build_rule(r) }
+        o_keys = o_rules.map { |r| from_key(r) }
+
+        kept = children.filter_map do |node|
+          case node
+          when Interscript::Node::Group::Parallel
+            node.children.reject! { |c| c.is_a?(Interscript::Node::Rule::Sub) && o_keys.include?(from_key(c)) }
+            node
+          when Interscript::Node::Rule::Sub
+            o_keys.include?(from_key(node)) ? nil : node
+          else
+            node
+          end
+        end
+
+        tail = kept.last
+        if tail.is_a?(Interscript::Node::Group::Parallel)
+          tail.children.push(*o_rules)
+        else
+          kept.push(*o_rules)
+        end
+        kept
+      end
+
+      def from_key(rule)
+        rule.from.inspect
       end
 
       def build_rule(rule_def)
@@ -170,6 +330,9 @@ module Interscript
           constraint = rule_def[:constraints].find { |c| c[:kind] == k }
           opts[k] = convert_item(constraint[:item], :class)
         end
+        # ISC-WF-1 W3: the language guard rides on the rule; inert unless
+        # the interpreter selects a declared language.
+        opts[:when_languages] = rule_def[:when_languages] if rule_def[:when_languages]&.any?
         Interscript::Node::Rule::Sub.new(from, to, **opts)
       end
 

data/lib/interscript/isc/normalizer.rb

@@ -69,6 +69,16 @@ module Interscript
           {tests: merge_tests(items)}
         elsif block.key?(:stage)
           {stage_name: scalar(block[:stage_name]), stage: normalize_stage_items(block[:stage])}
+        elsif block.key?(:ruleset)
+          # ISC-WF-1 W1: same shape as a stage, under the ruleset key.
+          {ruleset_name: scalar(block[:ruleset_name]), ruleset: normalize_stage_items(block[:ruleset])}
+        elsif block.key?(:languages)
+          # ISC-WF-1 W3: `languages a, b` folds to a plain list of names.
+          # One language captures as a single {language:} hash, several as
+          # a list.
+          langs = block[:languages]
+          list = langs.is_a?(Hash) ? [langs] : Array(langs)
+          {languages: list.map { |l| l.is_a?(Hash) ? scalar(l[:language]) : scalar(l) }}
         elsif block.key?(:target)
           {target: scalar(block[:target]), alias: scalar(block[:alias])}.compact
         else
@@ -85,6 +95,17 @@ module Interscript
             %i[parallel sequence].each do |k|
               item = {k => []} if item.key?(k) && !item[k].is_a?(Array)
             end
+            # ISC-WF-1 W1/W2: `use` items get their reference identifiers
+            # folded to strings; the override rules keep their parslet
+            # shape (DocumentBuilder materializes them through Transform).
+            if item.key?(:use) && item[:use].is_a?(Hash)
+              use = item[:use]
+              item = {use: {
+                use_alias: use[:use_alias] && scalar(use[:use_alias]),
+                qualified_name: use[:qualified_name] && scalar(use[:qualified_name]),
+                use_overrides: use[:use_overrides]
+              }.compact}
+            end
           end
           item
         end

data/lib/interscript/isc/serializer.rb

@@ -21,10 +21,12 @@ module Interscript
 
       def serialize
         emit_system_open
+        emit_languages if @doc[:languages]&.any?
         emit_metadata if @doc[:metadata]&.any?
         emit_tests if @doc[:tests]&.any?
         emit_aliases if @doc[:aliases]&.any?
         emit_dependencies if @doc[:dependencies]&.any?
+        emit_rulesets
         emit_stages
         emit_system_close
         @out
@@ -40,6 +42,21 @@ module Interscript
         @out << "}\n"
       end
 
+      # ISC-WF-1 W3: the map's declared languages.
+      def emit_languages
+        @out << "\nlanguages #{@doc[:languages].join(" ")}\n"
+      end
+
+      # ISC-WF-1 W1: named rulesets, emitted ahead of the stages that
+      # reference them.
+      def emit_rulesets
+        @doc[:rulesets]&.each do |rs|
+          @out << "\nruleset #{rs[:name]} {\n"
+          rs[:body].each { |item| emit_stage_item(item) }
+          @out << "}\n"
+        end
+      end
+
       def emit_blank
         @out << "\n"
       end
@@ -157,6 +174,19 @@ module Interscript
           @out << "  }\n"
         when :bare_rule
           emit_rule(item[:rule], 2)
+        when :use
+          # ISC-WF-1 W1/W2: `use <dep>.<name> [override { rows }]` — the
+          # override block is part of the use directive (one syntax, one
+          # site, spec §4.1).
+          ref = item[:dependency] ? "#{item[:dependency]}.#{item[:ruleset]}" : item[:ruleset]
+          overrides = item[:overrides]
+          if overrides&.any?
+            @out << "  use #{ref} override {\n"
+            overrides.each { |r| emit_rule(r, 4) }
+            @out << "  }\n"
+          else
+            @out << "  use #{ref}\n"
+          end
         when :run
           dep = item[:dependency]
           stage = item[:stage]
@@ -179,6 +209,8 @@ module Interscript
         pad = " " * indent
         from_str = emit_item(rule[:from])
         to_str = emit_item(rule[:to])
+        # ISC-WF-1 W3: the language guard trails the constraints.
+        when_str = rule[:when_languages]&.any? ? "when #{rule[:when_languages].join(" ")}" : nil
 
         needs_block = rule[:from].is_a?(Items::Concat) || rule[:to].is_a?(Items::Concat)
 
@@ -188,11 +220,13 @@ module Interscript
           @out << "#{inner}from #{from_str}\n"
           @out << "#{inner}to #{to_str}\n"
           rule[:constraints]&.each { |c| @out << "#{inner}#{emit_constraint(c)}\n" }
+          @out << "#{inner}#{when_str}\n" if when_str
           @out << "#{pad}}\n"
         else
           constraints_str = rule[:constraints]&.map { |c| emit_constraint(c) }&.join(" ") || ""
           @out << "#{pad}sub #{from_str} #{to_str}"
           @out << " #{constraints_str}" unless constraints_str.empty?
+          @out << " #{when_str}" if when_str
           @out << "\n"
         end
       end

data/lib/interscript/isc/transform.rb

@@ -133,6 +133,21 @@ module Interscript
       rule(not_before: subtree(:x)) { {kind: :not_before, item: x} }
       rule(not_after: subtree(:x)) { {kind: :not_after, item: x} }
       rule(constraints: sequence(:c)) { c }
+
+      # ISC-WF-1 W3: a `when` guard folds to the plain list of language
+      # names. A single language captures as one {when_lang:} hash,
+      # several as a list; identifier leaves may still be raw slices at
+      # this point, so decode them here.
+      rule(when: subtree(:langs)) do
+        list = langs.is_a?(Hash) ? [langs] : Array(langs)
+        list.map do |l|
+          lang = l.is_a?(Hash) ? l[:when_lang] : l
+          case lang
+          when Hash then lang[:identifier].to_s
+          else lang.to_s
+          end
+        end.compact
+      end
     end
   end
 end

data/lib/interscript/isc/yaml_bridge.rb

@@ -31,6 +31,8 @@ module Interscript
             tests: (doc_hash[:tests] || []).map { |t| Model::Test.new(t.transform_keys(&:to_s)) },
             aliases: (doc_hash[:aliases] || []).map { |a| build_alias_model(a) },
             stages: (doc_hash[:stages] || []).map { |s| build_stage_model(s) },
+            rulesets: (doc_hash[:rulesets] || []).map { |r| build_ruleset_model(r) },
+            languages: doc_hash[:languages],
             dependencies: (doc_hash[:dependencies] || []).map { |d| build_dependency_model(d) }
           )
         end
@@ -63,6 +65,13 @@ module Interscript
           )
         end
 
+        def build_ruleset_model(ruleset_hash)
+          Model::Ruleset.new(
+            name: ruleset_hash[:name],
+            body: (ruleset_hash[:body] || []).map { |item| stage_item_to_model(item) }
+          )
+        end
+
         def build_dependency_model(dep_hash)
           Model::Dependency.new(
             target: dep_hash[:target],
@@ -80,6 +89,11 @@ module Interscript
           when :run
             attrs[:dependency] = item[:dependency]
             attrs[:stage] = item[:stage]
+          when :use
+            # ISC-WF-1 W1/W2
+            attrs[:dependency] = item[:dependency]
+            attrs[:ruleset] = item[:ruleset]
+            attrs[:overrides] = (item[:overrides] || []).map { |r| rule_to_model(r) }
           when :separate
             attrs[:separator] = item[:separator] ? item_to_model(item[:separator]) : nil
           when :string_case
@@ -92,7 +106,8 @@ module Interscript
           Model::Rule.new(
             from: item_to_model(rule_hash[:from]),
             to: item_to_model(rule_hash[:to]),
-            constraints: (rule_hash[:constraints] || []).map { |c| constraint_to_model(c) }
+            constraints: (rule_hash[:constraints] || []).map { |c| constraint_to_model(c) },
+            when_languages: rule_hash[:when_languages]
           )
         end
 
@@ -140,7 +155,7 @@ module Interscript
         # --- Reverse direction: model → document hash ---
 
         def model_to_hash(model)
-          {
+          hash = {
             schemaVersion: 1,
             systemCode: model.system_code,
             metadata: model_metadata_to_hash(model.metadata),
@@ -149,6 +164,11 @@ module Interscript
             stages: (model.stages || []).map { |s| stage_model_to_hash(s) },
             dependencies: (model.dependencies || []).map { |d| {target: d.target, alias: d.alias_name}.compact }
           }
+          # ISC-WF-1 keys round-trip only when present — pre-WF1 documents
+          # keep their exact hash shape.
+          hash[:languages] = model.languages if model.languages&.any?
+          hash[:rulesets] = (model.rulesets || []).map { |r| ruleset_model_to_hash(r) } if model.rulesets&.any?
+          hash
         end
 
         def model_metadata_to_hash(meta)
@@ -171,6 +191,11 @@ module Interscript
             {kind: :bare_rule, rule: rule_model_to_hash(item.rule)}
           when "run"
             {kind: :run, dependency: item.dependency, stage: item.stage}
+          when "use"
+            # ISC-WF-1 W1/W2
+            hash = {kind: :use, ruleset: item.ruleset, dependency: item.dependency}
+            hash[:overrides] = (item.overrides || []).map { |r| rule_model_to_hash(r) } if item.overrides&.any?
+            hash.compact
           when "separate"
             {kind: :separate, separator: item.separator ? model_to_item(item.separator) : nil}
           when "compose"
@@ -182,12 +207,21 @@ module Interscript
           end
         end
 
-        def rule_model_to_hash(rule_model)
+        def ruleset_model_to_hash(ruleset_model)
           {
+            name: ruleset_model.name,
+            body: ruleset_model.body.map { |item| stage_item_model_to_hash(item) }
+          }
+        end
+
+        def rule_model_to_hash(rule_model)
+          hash = {
             from: model_to_item(rule_model.from),
             to: model_to_item(rule_model.to),
             constraints: (rule_model.constraints || []).map { |c| constraint_model_to_hash(c) }
           }
+          hash[:when_languages] = rule_model.when_languages if rule_model.when_languages&.any?
+          hash
         end
 
         def constraint_model_to_hash(constraint_model)

data/lib/interscript/node/document.rb

@@ -2,6 +2,9 @@ class Interscript::Node::Document
   attr_accessor :metadata, :tests, :name
   attr_accessor :dependencies, :aliases, :stages, :dep_aliases
   attr_accessor :reversed_from
+  # ISC-WF-1: map-declared languages (LanguagesDecl or nil) and the named
+  # rulesets available to `use` expansion (name => Node::Ruleset).
+  attr_accessor :languages, :rulesets
 
   def initialize
     puts "Interscript::Node::Document.new " if $DEBUG
@@ -11,6 +14,8 @@ class Interscript::Node::Document
     @dep_aliases = {}
     @aliases = {}
     @stages = {}
+    @languages = nil
+    @rulesets = {}
   end
 
   def imported_aliases
@@ -69,11 +74,18 @@ class Interscript::Node::Document
   end
 
   def to_hash
-    {class: self.class.to_s, metadata: @metadata&.to_hash,
-     tests: @tests&.to_hash,
-     dependencies: @dependencies.map { |x| x.to_hash },
-     dep_aliases: @dep_aliases.transform_values(&:to_hash),
-     aliases: @aliases.transform_values(&:to_hash),
-     stages: @stages.transform_values(&:to_hash)}
+    hash = {
+      class: self.class.to_s, metadata: @metadata&.to_hash,
+      tests: @tests&.to_hash,
+      dependencies: @dependencies.map { |x| x.to_hash },
+      dep_aliases: @dep_aliases.transform_values(&:to_hash),
+      aliases: @aliases.transform_values(&:to_hash),
+      stages: @stages.transform_values(&:to_hash)
+    }
+    # ISC-WF-1 keys appear only on maps that use the constructs — the IR
+    # of every pre-WF1 map stays byte-identical.
+    hash[:languages] = @languages.to_hash if @languages
+    hash[:rulesets] = @rulesets.transform_values(&:to_hash) if @rulesets&.any?
+    hash
   end
 end

data/lib/interscript/node/group/parallel.rb

@@ -2,6 +2,10 @@ class Interscript::Node::Group::Parallel < Interscript::Node::Group
   # A place for Interpreter to store a compiled form of the tree
   attr_accessor :cached_tree
   attr_accessor :subs_regexp, :subs_replacements, :subs_array
+  # ISC-WF-1 W3: per-selected-language filtered variants of this pass
+  # (selected language => parallel group). Only populated for passes
+  # that contain `when`-guarded rules.
+  attr_accessor :wf1_variants
 
   def inspect
     "parallel {\n#{super}\n}"

data/lib/interscript/node/languages_decl.rb

@@ -0,0 +1,26 @@
+class Interscript::Node::LanguagesDecl < Interscript::Node
+  # ISC-WF-1 W3: the languages a map serves (spec §5.1). Attached to
+  # Node::Document#languages; nil means "no declaration" — every `when`
+  # guard is inert regardless of caller selection.
+  attr_accessor :languages
+
+  def initialize(languages = [])
+    self.languages = languages
+  end
+
+  def include?(language)
+    languages.include?(language)
+  end
+
+  def to_hash
+    {class: self.class.to_s, languages: languages}
+  end
+
+  def ==(other)
+    super && languages == other.languages
+  end
+
+  def inspect
+    "languages #{languages.join(" ")}"
+  end
+end

data/lib/interscript/node/rule/sub.rb

@@ -4,11 +4,14 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
   attr_accessor :reverse_before, :reverse_not_before, :reverse_after, :reverse_not_after
   attr_accessor :reverse_run
   attr_accessor :priority
+  # ISC-WF-1 W3: the language guard (`when kur, chv`). nil = unguarded.
+  attr_accessor :when_languages
 
   def initialize(from, to,
     before: nil, not_before: nil,
     after: nil, not_after: nil,
-    priority: nil, reverse_run: nil)
+    priority: nil, reverse_run: nil,
+    when_languages: nil)
     self.from = Interscript::Node::Item.try_convert from
     self.to = if to == :upcase
       :upcase
@@ -19,6 +22,7 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
     end
 
     self.priority = priority
+    self.when_languages = when_languages&.map(&:to_sym)
 
     # raise TypeError, "Can't supply both before and not_before" if before && not_before
     # raise TypeError, "Can't supply both after and not_after" if after && not_after
@@ -59,6 +63,7 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
     hash[:after] = after&.to_hash if after
     hash[:not_after] = not_after&.to_hash if not_after
     hash[:priority] = priority if priority
+    hash[:when_languages] = when_languages if when_languages
 
     hash
   end
@@ -91,7 +96,8 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
 
       reverse_run: rrun,
 
-      priority: priority ? -priority : nil)
+      priority: priority ? -priority : nil,
+      when_languages: when_languages)
   end
 
   def has_assertions?
@@ -202,7 +208,8 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
       after == other.after &&
       not_before == other.not_before &&
       not_after == other.not_after &&
-      priority == other.priority
+      priority == other.priority &&
+      when_languages == other.when_languages
   end
 
   def inspect
@@ -222,6 +229,7 @@ class Interscript::Node::Rule::Sub < Interscript::Node::Rule
     params << "not_after: #{@not_after.inspect}" if @not_after
 
     params << "priority: #{@priority.inspect}" if @priority
+    params << "when: #{@when_languages.join(", ")}" if @when_languages
     out << params.join(", ")
   end
   # standard:disable Layout/TrailingEmptyLines (deliberate)

data/lib/interscript/node/rule/use.rb

@@ -0,0 +1,31 @@
+class Interscript::Node::Rule::Use < Interscript::Node::Rule
+  # ISC-WF-1 W1/W2: a `use` directive before expansion. The NodeAdapter
+  # expands use directives at build time (macro expansion, spec §3.2), so
+  # this node only appears on documents built without expansion; it names
+  # the ruleset and, when present, the dependency alias and the per-site
+  # override rows.
+  attr_accessor :ruleset, :map, :overrides
+
+  def initialize(ruleset, map: nil, overrides: [])
+    self.ruleset = ruleset
+    self.map = map
+    self.overrides = overrides
+  end
+
+  def to_hash
+    {class: self.class.to_s,
+     ruleset: ruleset,
+     map: map,
+     overrides: overrides.map(&:to_hash)}
+  end
+
+  def ==(other)
+    super && ruleset == other.ruleset && map == other.map && overrides == other.overrides
+  end
+
+  def inspect
+    out = "use #{[map, ruleset].compact.map { |i| "@#{i}" }.join(".")}"
+    out += " override { #{overrides.map(&:inspect).join(", ")} }" unless overrides.empty?
+    out
+  end
+end

data/lib/interscript/node/rule.rb

@@ -3,6 +3,7 @@ class Interscript::Node::Rule < Interscript::Node
   autoload :Sub, "interscript/node/rule/sub"
   autoload :Run, "interscript/node/rule/run"
   autoload :Funcall, "interscript/node/rule/funcall"
+  autoload :Use, "interscript/node/rule/use"
 
   def ==(other)
     super && reverse_run == other.reverse_run