hecks 3.2.0 → 3.3.0

data/rust/project/types.rb

@@ -1,225 +0,0 @@
-module RustProjection
-  module Projector
-    module_function
-
-    # `check_invariants` mirroring `Value.build` (runtime/value/coercion.rb). `offered` sorts only
-    # the top-level fields, matching Ruby's `canonical_fields`.
-    def emit_check_invariants(vo, value_objects_by_name, aggregates_by_name)
-      name = rust_ident(vo[:name])
-      type_name = vo[:name].to_s
-
-      # Ruby's order (`Value.build`, coercion.rb): nested value objects, then field
-      # constraints, then invariants last, so a failed pattern is a `TypeMismatch`.
-      body = []
-
-      vo[:attributes].each do |attr|
-        next if SCALAR.key?(attr[:type])
-
-        nested = value_objects_by_name[attr[:type]]
-        next unless nested && !nested[:closed_set]
-
-        field = rust_ident_field(attr[:name])
-        body << (attr[:list] ? "        for item in &self.#{field} { item.check_invariants()?; }" : "        self.#{field}.check_invariants()?;")
-      end
-
-      # `pattern:`/`admits:` declared on the value object's own fields; command-argument
-      # usage-level `admits:` is handled in commands.rb.
-      vo[:attributes].each do |attr|
-        next if attr[:list]
-
-        field = "self.#{rust_ident_field(attr[:name])}"
-        admits_line = emit_admits_check(field, attr, aggregates_by_name, value_objects_by_name)
-        body << "        #{admits_line}" if admits_line
-        pattern_line = emit_pattern_check(field, attr, name, value_objects_by_name)
-        body << "        #{pattern_line}" if pattern_line
-      end
-
-      body += vo[:invariants].map do |inv|
-        expr = ExprEmitter.emit_ast(inv[:ast])
-        <<~RUST.rstrip
-                  {
-                      let ctx = crate::kernel::EvalContext { args: &crate::kernel::NoFields, instance: self };
-                      if !crate::kernel::interpret(&#{expr}, &ctx)?.truthy() {
-                          let mut offered = self.to_json();
-                          if let crate::kernel::Json::Object(fields) = &mut offered {
-                              fields.sort_by(|a, b| a.0.cmp(&b.0));
-                          }
-                          let offered = offered.to_json_string();
-                          return Err(crate::kernel::Refusal::InvariantViolation(crate::kernel::refusal_wording::InvariantViolationValueObjectInvariantArgs {
-                              name: #{type_name.inspect},
-                              description: #{rust_string_literal(inv[:description])},
-                              offered: offered.as_str(),
-                          }.render_args()));
-                      }
-                  }
-        RUST
-      end
-
-      <<~RUST
-        impl #{name} {
-            pub fn check_invariants(&self) -> Result<(), crate::kernel::Refusal> {
-        #{body.join("\n")}
-                Ok(())
-            }
-        }
-      RUST
-    end
-
-    # A multi-field closed set: a plain struct plus a `pub const` array of members.
-    # No `Fielded` or `check_invariants`.
-    def emit_closed_set_table(vo)
-      name = rust_ident(vo[:name])
-
-      field_subs_list = vo[:attributes].map do |attr|
-        type = rust_type(attr[:type], list: attr[:list])
-        type = "&'static str" if type == "String" # static data — a borrowed literal, not an owned String
-        { "TmplFieldType" => type, "tmpl_field" => rust_ident_field(attr[:name]) }
-      end
-      struct_part = Exemplar.compose("plain_struct", { "TmplType" => name }, field_id: "struct_field", field_subs_list: field_subs_list)
-
-      # Rows carry only the fields they set; missing ones fall back to `default:` or "".
-      member_literals = vo[:members].map do |row|
-        present = row.to_h { |field_name, value| [field_name.to_s, value] }
-        fields = vo[:attributes].map do |attr|
-          field_name = attr[:name].to_s
-          raw = present.key?(field_name) ? present[field_name] : (attr[:default] || "")
-          literal = case attr[:type]
-                    when "Integer" then raw.to_i.to_s
-                    when "Float"   then "#{raw.to_f}f64"
-                    else rust_string_literal(raw.to_s) # String, or an unrecognized type — treated as text, not silently dropped
-                    end
-          Exemplar.render("closed_set_table_row_field", "tmpl_field" => rust_ident_field(attr[:name]), "tmpl_value_placeholder()" => literal)
-        end.join(", ")
-        "    #{name} { #{fields} },"
-      end
-
-      "#{struct_part}\n\npub const #{screaming_snake(vo[:name])}: &[#{name}] = &[\n#{member_literals.join("\n")}\n];"
-    end
-
-    def emit_value_object(vo, value_objects_by_name, aggregates_by_name)
-      name = rust_ident(vo[:name])
-
-      if vo[:closed_set]
-        # One field is an enum tag. Several are a data table: members can share any
-        # single field (Keyword rows share `word`), so no one field can be the tag.
-        return emit_closed_set_table(vo) if vo[:attributes].size > 1
-
-        variants = vo[:members].map { |row| closed_set_variant(row) }
-        enum_part = Exemplar.compose(
-          "closed_set_enum",
-          { "TmplKind" => name },
-          field_id: "closed_set_enum:VARIANT",
-          field_subs_list: variants.map { |v| { "TmplMemberA" => v } }
-        )
-        # Consumer of `fielded_capable_nested?` (naming.rb).
-        return "#{enum_part}\n\n#{emit_closed_set_fielded_impl(vo)}"
-      end
-
-      field_subs_list = vo[:attributes].map do |attr|
-        type = rust_type(attr[:type], list: attr[:list])
-        type = "Option<#{type}>" if attr[:optional]
-        { "TmplFieldType" => type, "tmpl_field" => rust_ident_field(attr[:name]) }
-      end
-      struct_part = Exemplar.compose("plain_struct", { "TmplType" => name }, field_id: "struct_field", field_subs_list: field_subs_list)
-
-      [
-        struct_part,
-        emit_fielded_flat(name, vo[:attributes], value_objects_by_name,
-                          entity_names: aggregates_by_name.values.flat_map { |a| a[:entities].map { |e| e[:name] } }),
-        emit_check_invariants(vo, value_objects_by_name, aggregates_by_name),
-      ].join("\n\n")
-    end
-
-    def unsupported_attribute_types(aggregate, value_objects_by_name)
-      entity_names = aggregate[:entities].map { |e| e[:name] }
-      aggregate[:attributes]
-        .reject do |attr|
-          effective_scalar_type(attr[:type]) || value_objects_by_name.key?(attr[:type]) ||
-            (attr[:list] && entity_names.include?(attr[:type]))
-        end
-        .map { |attr| attr[:type] }
-        .uniq
-    end
-
-    # An entity as a struct with a `Fielded` impl and no `check_invariants`.
-    # Commands addressing one element by identity are not generated; this only enables `append`.
-    def emit_entity(entity, value_objects_by_name)
-      name = rust_ident(entity[:name])
-      field_subs_list = entity[:attributes].map do |attr|
-        type = rust_type(attr[:type], list: attr[:list])
-        # `optional: true` becomes `Option<T>`; `command_skip_reason` (bridging.rb) skips
-        # optional sources feeding a non-optional field.
-        type = "Option<#{type}>" if attr[:optional]
-        { "TmplFieldType" => type, "tmpl_field" => rust_ident_field(attr[:name]) }
-      end
-      field_subs_list << { "TmplFieldType" => "String", "tmpl_field" => rust_ident_field(entity[:lifecycle][:field]) } if entity[:lifecycle]
-      struct_part = Exemplar.compose("plain_struct", { "TmplType" => name }, field_id: "struct_field", field_subs_list: field_subs_list)
-
-      # The entity's TransitionCheck reads the lifecycle field generically, in the flat shape.
-      lifecycle_arm =
-        if entity[:lifecycle]
-          field = rust_field(entity[:lifecycle][:field])
-          ident = rust_ident_field(entity[:lifecycle][:field])
-          [%(            "#{field}" => Some(Field::Value(Value::Str(self.#{ident}.clone()))),)]
-        else
-          []
-        end
-      "#{struct_part}\n\n#{emit_fielded_flat(name, entity[:attributes], value_objects_by_name, extra_arms: lifecycle_arm)}"
-    end
-
-    def emit_record(aggregate, value_objects_by_name)
-      name = rust_ident(aggregate[:name])
-      field_subs_list = aggregate[:attributes].map do |attr|
-        # Optional because a creating command may not set every field. A list field stays a
-        # `Vec<T>` unless `list_attr_creation_optional?`.
-        type = rust_type(attr[:type], list: attr[:list])
-        type = "Option<#{type}>" if !attr[:list] || list_attr_creation_optional?(aggregate, attr[:name], value_objects_by_name)
-        { "TmplFieldType" => type, "tmpl_field" => rust_ident_field(attr[:name]) }
-      end
-      field_subs_list << { "TmplFieldType" => "String", "tmpl_field" => rust_ident_field(aggregate[:lifecycle][:field]) } if aggregate[:lifecycle]
-      # One plain `bool` field per event a command `corrects` (see `corrects_flag_field`).
-      correctable_event_names(aggregate).each { |ev| field_subs_list << { "TmplFieldType" => "bool", "tmpl_field" => corrects_flag_field(ev) } }
-      struct_part = Exemplar.compose("plain_struct", { "TmplType" => name }, field_id: "struct_field", field_subs_list: field_subs_list)
-
-      "#{struct_part}\n\n#{emit_fielded_record(aggregate, value_objects_by_name)}"
-    end
-
-    # `projects` fields become always-optional String attributes. The caller merges them onto
-    # `aggregate[:attributes]` for record emission only, never for command Args or from_json_flat.
-    def projected_field_pseudo_attributes(aggregate)
-      (aggregate[:projected_fields] || []).map do |field|
-        { name: field[:name], type: "String", list: false, optional: true }
-      end
-    end
-
-    # `impl SetProjectedField`: one arm per `projects` field, empty match when there are none,
-    # so dispatch can require the bound unconditionally.
-    def emit_set_projected_field(aggregate)
-      name = rust_ident(aggregate[:name])
-      arms = (aggregate[:projected_fields] || []).map do |field|
-        ident = rust_ident_field(field[:name])
-        "            #{field[:name].inspect} => self.#{ident} = value,"
-      end
-      <<~RUST
-        impl crate::kernel::SetProjectedField for #{name} {
-            fn set_projected_field(&mut self, name: &'static str, value: Option<String>) {
-                match name {
-        #{arms.join("\n")}
-                    _ => {}
-                }
-            }
-        }
-      RUST
-    end
-
-    # `<NAME>_PROJECTED_FIELDS`: one `ProjectedFieldSpec` row per `projects` field, empty if none.
-    def emit_projected_field_table(aggregate)
-      name = screaming_snake(aggregate[:name])
-      rows = (aggregate[:projected_fields] || []).map do |field|
-        "    crate::kernel::ProjectedFieldSpec { field: #{field[:name].inspect}, reference: #{field[:reference].inspect}, " \
-          "remote_field: #{field[:remote_field].inspect} },"
-      end
-      "pub static #{name}_PROJECTED_FIELDS: &[crate::kernel::ProjectedFieldSpec] = &[\n#{rows.join("\n")}\n];\n"
-    end
-  end
-end

data/rust/project/write_if_changed.rb

@@ -1,7 +0,0 @@
-require "hecks/rust_build/write_if_changed"
-
-module RustProjection
-  # The write-if-unchanged helper moved to `Hecks::RustBuild::WriteIfChanged`, which the
-  # codegen-backed `hecks project_rust` also uses; this name stays until this generator is deleted.
-  WriteIfChanged = Hecks::RustBuild::WriteIfChanged
-end

data/rust/project.rb

@@ -1,30 +0,0 @@
-# Build-time generator: turns one domain's canonical IR into Rust source under rust/src/generated/.
-# The compiled binary never parses or interprets bluebooks.
-#
-#   hecks project_rust <domain>
-#
-# The IR arrives JSON-shaped, so mutation ops, targets and attribute names are Strings; compare
-# them with `.to_s`. Commands the kernel cannot express are skipped loudly, by name and reason.
-module RustProjection
-end
-
-require_relative "project/write_if_changed"
-require_relative "project/skip_reason"
-require_relative "project/exemplar"
-require_relative "project/expr_emitter"
-require_relative "project/naming"
-require_relative "project/reference_specs"
-require_relative "project/constraints"
-require_relative "project/fielded"
-require_relative "project/json_codec"
-require_relative "project/types"
-require_relative "project/bridging"
-require_relative "project/mutations"
-require_relative "project/dependency_planning"
-require_relative "project/commands"
-require_relative "project/ports"
-require_relative "project/registry"
-require_relative "project/reactions"
-require_relative "project/queries"
-require_relative "project/read_models"
-require_relative "project/domain_generator"

data/rust/project_rust_pipeline.rb

@@ -1,391 +0,0 @@
-require "json"
-require "fileutils"
-require "open3"
-require "tmpdir"
-
-# Opt-in, all-Rust equivalent of hecks project_rust's default path, selected
-# when HECKS_PARSER=rust and HECKS_CODEGEN=rust; never boots a bluebook DSL.
-module RustProjectPipeline
-  ROOT = File.expand_path("..", __dir__).freeze
-  PARSER_DIR = File.join(ROOT, "rust/parser").freeze
-  CODEGEN_DIR = File.join(ROOT, "rust/codegen").freeze
-  PARSER_BIN = File.join(PARSER_DIR, "target/debug/hecks-parse").freeze
-  CODEGEN_BIN = File.join(CODEGEN_DIR, "target/debug/hecks-codegen").freeze
-
-  module_function
-
-  def call(domain)
-    ensure_binaries_built!
-
-    target_mod_name = File.basename(domain)
-    # Becomes a directory name, Rust module identifier, and Cargo feature
-    # name below (see Projector.valid_domain_mod_name?).
-    unless RustProjection::Projector.valid_domain_mod_name?(target_mod_name)
-      abort "hecks project_rust (Rust path): domain name #{target_mod_name.inspect} (from #{domain.inspect}) can't be " \
-            "used as-is — it has to double as a Rust module identifier and a Cargo feature name, and this one is " \
-            "either not a plain lowercase identifier, is a Rust keyword, or collides with a reserved Cargo.toml " \
-            "key (#{RustProjection::Projector::CARGO_RESERVED_DOMAIN_NAMES.join(', ')}). Rename the domain directory."
-    end
-    bluebook_paths = Dir.glob(File.join(domain, "bluebook", "*.bluebook")).sort
-    abort "hecks project_rust (Rust path): #{domain} has no .bluebook files" if bluebook_paths.empty?
-    hecksagon_path = File.join(domain, "bluebook", "#{target_mod_name}.hecksagon")
-    hecksagon_path = nil unless File.exist?(hecksagon_path)
-
-    target_chapter_name = header_chapter_name(bluebook_paths.first)
-    target_bluebooks = bluebook_paths.select { |path| header_chapter_name(path) == target_chapter_name }
-
-    gem_chapter_names, vendored_package_names =
-      if hecksagon_path
-        resolved = JSON.parse(run_capture!(PARSER_BIN, "resolve", "--chapter", target_chapter_name, hecksagon_path))
-        [resolved.fetch("gem_chapters"), resolved.fetch("vendored_packages")]
-      else
-        [[], []]
-      end
-
-    target_files = target_bluebooks + [hecksagon_path].compact
-    target_ir_text = derive_append_optionals(run_capture!(PARSER_BIN, "chapter", "--chapter", target_chapter_name, *target_files))
-    # Only the target gets a lineage sidecar — matches the default path,
-    # which never sets one on a framework chapter either.
-    target_ir_text = derive_lineage(target_ir_text, hecksagon_path, sibling_world_path(domain, target_mod_name))
-
-    # Mirrors hecks project_rust's own Framework.load! resolution. A framework
-    # member has no .hecksagon of its own, only its .bluebook.
-    # A gem chapter that is not a framework member (the language, Tenancy, Deploy) is loaded by
-    # the Ruby runtime alone, so it is checked against the one table and skipped here.
-    chapters = gem_chapter_names.filter_map do |fw_name|
-      next if Hecks::Chapters.index.key?(fw_name) && !Hecks::Framework.members.key?(fw_name)
-
-      fw_path = Hecks::Framework.members.fetch(fw_name) do
-        abort "hecks project_rust (Rust path): attaches #{fw_name.inspect} names no chapter the gem carries — known: #{Hecks::Chapters.table.keys.sort.join(', ')}"
-      end
-      fw_chapter_name = header_chapter_name(fw_path)
-      unless fw_chapter_name == fw_name
-        abort "hecks project_rust (Rust path): #{fw_path} declares chapter #{fw_chapter_name.inspect}, but attaches named #{fw_name.inspect}"
-      end
-      fw_ir_text = derive_append_optionals(run_capture!(PARSER_BIN, "chapter", "--chapter", fw_chapter_name, fw_path))
-      {
-        mod_name:     fw_name.downcase,
-        source_label: "#{domain} (attaches #{fw_name.inspect})",
-        ir_text:      fw_ir_text
-      }
-    end
-
-    # Mirrors EmbryonautBluebook.load!: every .bluebook file directly under
-    # vendor/embryonaut_bluebooks/<name>/bluebook/, sorted. A vendored
-    # package has no .hecksagon of its own either, just its .bluebook(s).
-    chapters += vendored_package_names.map do |pkg_name|
-      unless pkg_name.to_s.match?(Hecks::EmbryonautBluebook::PACKAGE_NAME)
-        abort "hecks project_rust (Rust path): attaches #{pkg_name.inspect}, from: :vendor is not a package " \
-              "name — it must match [a-z][a-z0-9_]* (the name `hecks vendor` accepts)"
-      end
-      pkg_dir = File.join(domain, "vendor", "embryonaut_bluebooks", pkg_name.to_s, "bluebook")
-      pkg_files = Dir.glob(File.join(pkg_dir, "*.bluebook")).sort
-      if pkg_files.empty?
-        abort "hecks project_rust (Rust path): attaches #{pkg_name.inspect}, from: :vendor names no vendored " \
-              "bluebook at #{pkg_dir} — run hecks vendor #{pkg_name}"
-      end
-      pkg_chapter_name = header_chapter_name(pkg_files.first)
-      expected_chapter_name = Hecks::Naming.pascal(pkg_name.to_s)
-      unless pkg_chapter_name == expected_chapter_name
-        abort "hecks project_rust (Rust path): #{pkg_files.first} declares chapter #{pkg_chapter_name.inspect}, but " \
-              "attaches #{pkg_name.inspect}, from: :vendor expects #{expected_chapter_name.inspect}"
-      end
-      pkg_bluebooks = pkg_files.select { |path| header_chapter_name(path) == pkg_chapter_name }
-      pkg_ir_text = derive_append_optionals(run_capture!(PARSER_BIN, "chapter", "--chapter", pkg_chapter_name, *pkg_bluebooks))
-      {
-        # Derived from the declared chapter name, not pkg_name.downcase
-        # directly — the two diverge once a package name has an underscore.
-        mod_name:     expected_chapter_name.downcase,
-        source_label: "#{domain} (attaches #{pkg_name.inspect}, from: :vendor)",
-        ir_text:      pkg_ir_text
-      }
-    end
-
-    # Framework- and embryonaut_bluebook-derived chapters can collide on
-    # mod_name (chapters here is a plain Array, not a Hash), so guard
-    # explicitly against two entries overwriting each other's sidecars.
-    chapters.group_by { |c| c[:mod_name] }.each_value do |group|
-      next if group.size == 1
-
-      abort "hecks project_rust (Rust path): #{group.map { |c| c[:source_label] }.join(' and ')} both resolve to the " \
-            "same generated module #{group.first[:mod_name].inspect} — attach #{target_chapter_name} to at most one " \
-            "of them"
-    end
-
-    # The self-hosted grammar's own "Bluebook" chapter, read without
-    # booting anything.
-    meta_files = Hecks::Bluebook::MetaValidator::GRAMMAR_FILES
-    meta_ir_text = derive_append_optionals(run_capture!(PARSER_BIN, "chapter", "--chapter", "Bluebook", *meta_files))
-
-    # `HECKS_RUST_DIR` picks the crate to project into, as it does for hecks project_rust's
-    # Ruby path; unset, it is this repository's own `rust/`.
-    rust_dir = ENV.fetch("HECKS_RUST_DIR", File.expand_path("../rust", __dir__))
-    out_root = File.join(rust_dir, "src/generated")
-    FileUtils.mkdir_p(out_root)
-    # Only this run's own directories are cleared — other domains coexist
-    # on disk.
-    FileUtils.rm_rf(File.join(out_root, "meta"))
-    FileUtils.rm_rf(File.join(out_root, "active"))
-    FileUtils.rm_rf(File.join(out_root, target_mod_name))
-    chapters.each { |c| FileUtils.rm_rf(File.join(out_root, c[:mod_name])) }
-
-    Dir.mktmpdir("hecks-codegen-full") do |tmp|
-      meta_ir_path = File.join(tmp, "meta_ir.json")
-      File.write(meta_ir_path, meta_ir_text)
-      meta_source_label = "the self-hosted language (lib/hecks/language/bluebook)"
-      run!(CODEGEN_BIN, "full", out_root, "meta", meta_source_label, meta_ir_path)
-      write_sidecars!(File.join(out_root, "meta"), meta_ir_text, meta_source_label)
-
-      target_ir_path = File.join(tmp, "target_ir.json")
-      File.write(target_ir_path, target_ir_text)
-
-      codegen_args = [out_root, target_mod_name, domain, target_ir_path]
-      chapters.each_with_index do |c, i|
-        ir_path = File.join(tmp, "chapter_#{i}_ir.json")
-        File.write(ir_path, c[:ir_text])
-        codegen_args.concat([c[:mod_name], c[:source_label], ir_path])
-      end
-      run!(CODEGEN_BIN, "full", *codegen_args)
-    end
-
-    write_sidecars!(File.join(out_root, target_mod_name), target_ir_text, domain)
-    chapters.each { |c| write_sidecars!(File.join(out_root, c[:mod_name]), c[:ir_text], c[:source_label]) }
-
-    sync_mod_and_cargo!(out_root, target_mod_name)
-  end
-
-  # Applies the same append-optional-field derivation domain_generator.rb
-  # applies in Ruby — hecks-parse's own ir.json has not had it applied yet.
-  def derive_append_optionals(ir_text)
-    ir = JSON.parse(ir_text, symbolize_names: true)
-    ir[:aggregates].each do |aggregate|
-      value_objects_by_name = aggregate[:value_objects].to_h { |vo| [vo[:name], vo] }
-      RustProjection::Projector.mark_append_optional_fields!(aggregate, value_objects_by_name)
-    end
-    JSON.pretty_generate(ir)
-  end
-
-  # Text-based equivalent of Exporter.lineage — no Runtime::Registry boot.
-  def derive_lineage(ir_text, hecksagon_path, world_path = nil)
-    ir = JSON.parse(ir_text, symbolize_names: true)
-    binds = hecksagon_path ? persistence_binds(hecksagon_path) : {}
-    fallback = (world_path && default_adapter_name(world_path, ir[:name])) || "Memory"
-    capable_adapters = lineage_capable_adapter_names
-
-    capable = ir[:aggregates].select do |aggregate|
-      adapter_name = binds.fetch(aggregate[:name], fallback)
-      capable_adapters.include?(adapter_name)
-    end
-
-    ir[:lineage] = {
-      capable_aggregates: capable.map { |aggregate| { name: aggregate[:name], storage_name: Hecks::Naming.snake(aggregate[:name]) } }
-    }
-    JSON.pretty_generate(ir)
-  end
-
-  # Matches only role-less persisted_by binds — the sole authoritative kind.
-  def persistence_binds(hecksagon_path)
-    text = File.read(hecksagon_path)
-    binds = {}
-    text.each_line do |line|
-      next if line =~ /\brole:/
-      next unless line =~ /(?:\w+(?:::\w+)*::)?(\w+)\.persisted_by\(\s*"([^"]+)"/
-
-      binds[Regexp.last_match(1)] = Regexp.last_match(2)
-    end
-    binds
-  end
-
-  # The target's own `.world` file, if it has one — named for the domain the
-  # same way its `.hecksagon` is.
-  def sibling_world_path(domain, target_mod_name)
-    path = File.join(domain, "bluebook", "#{target_mod_name}.world")
-    path if File.exist?(path)
-  end
-
-  # A .world file may hold several worlds (one per chapter) — only lines
-  # inside the target chapter's own Hecks.world block count, and the last
-  # default_adapter there wins, matching the Ruby builder.
-  def default_adapter_name(world_path, chapter)
-    in_target_world = false
-    found = nil
-    File.foreach(world_path) do |line|
-      if (opened = line[/\AHecks\.world[^"]*"([^"]*)"/, 1])
-        in_target_world = opened == chapter
-      elsif in_target_world && (name = line[/\A\s*default_adapter\s+"([^"]*)"/, 1])
-        found = name
-      end
-    end
-    found
-  end
-
-  # Read off adapter source directly, so a new lineage-capable adapter
-  # needs no change here.
-  def lineage_capable_adapter_names
-    Dir[File.join(ROOT, "lib/hecks/adapters/driven/*.rb")].filter_map do |path|
-      text = File.read(path)
-      next unless text.match?(/lineage_capable\?\s*=\s*true/)
-
-      text[/^\s*class\s+(\w+)/, 1]
-    end.compact
-  end
-
-  # The declared chapter name off a .bluebook file's own header line.
-  def header_chapter_name(path)
-    line = File.foreach(path).find { |l| l =~ /\A\s*Hecks\.bluebook\s+"([^"]+)"/ }
-    (line && Regexp.last_match(1)) or abort "hecks project_rust (Rust path): #{path} has no 'Hecks.bluebook \"Name\"' header"
-  end
-
-  # Writes ir.json byte-identical to hecks-parse's own output — never
-  # reparsed or reformatted, to avoid a non-byte-exact diff for no reason.
-  def write_sidecars!(mod_dir, ir_text, source_label)
-    FileUtils.mkdir_p(mod_dir)
-
-    ir_json_path = File.join(mod_dir, "ir.json")
-    File.write(ir_json_path, ir_text)
-    puts "wrote #{ir_json_path}"
-
-    metadata_path = File.join(mod_dir, "metadata.rs")
-    File.open(metadata_path, "w") do |f|
-      f.puts "// GENERATED by hecks project_rust — #{source_label}'s own canonical IR,"
-      f.puts "// embedded for runtime self-description. Not read by any dispatch"
-      f.puts "// function in this module — introspection only."
-      f.puts "pub const IR_JSON: &str = #{RustProjection::Projector.rust_string_literal(ir_text)};"
-    end
-    puts "wrote #{metadata_path}"
-  end
-
-  def ensure_binaries_built!
-    build!(PARSER_DIR)
-    build!(CODEGEN_DIR)
-  end
-
-  def build!(crate_dir)
-    ok = system("cargo", "build", chdir: crate_dir, out: $stdout, err: $stderr)
-    ok or abort "hecks project_rust (Rust path): cargo build failed in #{crate_dir} — run it there directly to see why"
-  end
-
-  def run_capture!(*cmd)
-    out, err, status = Open3.capture3(*cmd)
-    status.success? or abort "hecks project_rust (Rust path): #{cmd.join(' ')} failed:\n#{err}"
-    out
-  end
-
-  def run!(*cmd)
-    ok = system(*cmd)
-    ok or abort "hecks project_rust (Rust path): #{cmd.join(' ')} failed"
-  end
-
-  # Duplicates hecks project_rust's own default-path tail (root mod.rs +
-  # Cargo.toml feature sync) rather than extracting a shared method, so
-  # the default path's own body stays byte-for-byte untouched.
-  def sync_mod_and_cargo!(out_root, target_mod_name)
-    all_dirs = Dir.children(out_root).select { |name| File.directory?(File.join(out_root, name)) }.sort
-    domains = all_dirs.select { |name| File.exist?(File.join(out_root, name, "merged.rs")) }
-
-    root_mod_path = File.join(out_root, "mod.rs")
-    File.open(root_mod_path, "w") do |f|
-      f.puts "// GENERATED by hecks project_rust — re-run it to refresh this list."
-      f.puts "//"
-      f.puts "// BUG#25 — every DOMAIN (an entry in `domains`, below: a directory"
-      f.puts "// carrying its own merged.rs and therefore its own Cargo feature) is"
-      f.puts "// declared behind that SAME feature, so a broken or absent domain's"
-      f.puts "// generated code is never even compiled into a build that selects a"
-      f.puts "// DIFFERENT domain — `cargo build --features waybill` used to pull in"
-      f.puts "// every OTHER domain's `pub mod` unconditionally, so one domain's own"
-      f.puts "// non-compiling generated code (a `has_many` field, before this fix)"
-      f.puts "// broke every feature's build, not just its own. A shared FRAMEWORK"
-      f.puts "// chapter (governance/identity — no merged.rs of its own, so absent"
-      f.puts "// from `domains`) stays unconditional: it has no single feature of its"
-      f.puts "// own to gate behind, and is compiled in by whichever domain(s) attach"
-      f.puts "// it via `attaches`."
-      all_dirs.each do |name|
-        f.puts "#[cfg(feature = #{name.inspect})]" if domains.include?(name)
-        f.puts "pub mod #{name};"
-      end
-      f.puts
-      f.puts "// `active` is whichever ONE domain's own merged Store/dispatch table"
-      f.puts "// is selected by Cargo feature (rust/Cargo.toml, kept in sync with this"
-      f.puts "// list by hecks project_rust) — kernel/cli.rs imports"
-      f.puts "// `crate::generated::active::{dispatch_by_name, Store, ...}` unchanged"
-      f.puts "// no matter which domain that resolves to."
-      f.puts "//"
-      f.puts "// DOMAIN FEATURES ARE MUTUALLY EXCLUSIVE (R5) — Cargo has no native"
-      f.puts "// concept of that, and `default = [#{target_mod_name.inspect}]` in"
-      f.puts "// Cargo.toml stays enabled unless a build passes"
-      f.puts "// `--no-default-features`, so a plain `cargo build --features banking`"
-      f.puts "// used to enable BOTH the default domain's feature and banking's,"
-      f.puts "// producing two `pub use ... as active;` imports and a hard E0252."
-      f.puts "// Fixed two ways below, entirely mechanically from `domains`/"
-      f.puts "// `target_mod_name` (this run's new default) — never hand-maintained:"
-      f.puts "//"
-      f.puts "//   1. THE DEFAULT DOMAIN'S OWN re-export backs off whenever any OTHER"
-      f.puts "//      domain feature is also enabled, so it never contends for `active`"
-      f.puts "//      by accident — `cargo build --features banking` (still implicitly"
-      f.puts "//      carrying the default feature) now resolves to banking alone,"
-      f.puts "//      same as if `--no-default-features` had been passed explicitly."
-      f.puts "//   2. Two NON-default domain features enabled TOGETHER (a genuine,"
-      f.puts "//      not-accidental conflict — nothing makes that combination"
-      f.puts "//      meaningful) still fail the build, but with an explicit"
-      f.puts "//      `compile_error!` naming both features instead of a cryptic"
-      f.puts "//      \"defined multiple times\"."
-      domains.each do |name|
-        other_domains = domains - [name]
-        if name == target_mod_name && !other_domains.empty?
-          guard = other_domains.map { |o| "feature = #{o.inspect}" }.join(", ")
-          f.puts "#[cfg(all(feature = #{name.inspect}, not(any(#{guard}))))]"
-        else
-          f.puts "#[cfg(feature = #{name.inspect})]"
-        end
-        f.puts "pub use #{name}::merged as active;"
-      end
-      non_default_domains = domains - [target_mod_name]
-      if non_default_domains.size > 1
-        f.puts
-        f.puts "// Explicit conflict guard — see point 2 above. Only fires when TWO"
-        f.puts "// non-default domain features are both turned on; the default"
-        f.puts "// domain's own feature never reaches here (point 1 already excludes"
-        f.puts "// it whenever any other domain feature is present)."
-        non_default_domains.combination(2).each do |a, b|
-          f.puts "#[cfg(all(feature = #{a.inspect}, feature = #{b.inspect}))]"
-          f.puts "compile_error!(\"domain features are mutually exclusive — enable only one of: #{domains.join(', ')} (both #{a} and #{b} are enabled)\");"
-        end
-      end
-    end
-    puts "wrote #{root_mod_path}"
-
-    # The crate's own Cargo.toml, two levels above src/generated — the one `HECKS_RUST_DIR` chose.
-    cargo_toml_path = File.expand_path("../../Cargo.toml", out_root)
-    cargo_toml = File.read(cargo_toml_path)
-    unless cargo_toml.include?("[features]")
-      cargo_toml = cargo_toml.sub(/\A/, <<~TOML)
-        # ONE FEATURE PER GENERATED DOMAIN — selects which domain's own
-        # generated::<domain>::merged module `generated::active` re-exports
-        # (rust/src/generated/mod.rs). Kept in sync by hecks project_rust: a
-        # feature is added here whenever a new domain is generated, never
-        # removed (the domain's own generated/<name>/ directory is the
-        # source of truth for whether it still exists). `default` tracks
-        # whichever domain was generated MOST RECENTLY, so a bare
-        # `cargo build`/`cargo test` keeps behaving exactly as it always
-        # has; any other still-generated domain stays reachable via
-        # `--no-default-features --features <name>`.
-        [features]
-        default = []
-
-      TOML
-    end
-    # Scoped to the [features] table only — checking against the whole
-    # file false-positives against [package]/[lib] keys sharing a word
-    # with a domain name (version, edition, name, path, ...).
-    features_table = cargo_toml[/^\[features\](?:\n(?!\[).*)*$/] || ""
-    domains.each do |name|
-      next if features_table =~ /^#{Regexp.escape(name)}\s*=/
-
-      cargo_toml = cargo_toml.sub(/^default\s*=.*$/) { "#{Regexp.last_match(0)}\n#{name} = []" }
-      features_table = cargo_toml[/^\[features\](?:\n(?!\[).*)*$/] || ""
-    end
-    cargo_toml = cargo_toml.sub(/^default\s*=.*$/, "default = [#{target_mod_name.inspect}]")
-    File.write(cargo_toml_path, cargo_toml)
-    puts "wrote #{cargo_toml_path} (default feature: #{target_mod_name})"
-  end
-end