parsanol 1.3.56 → 1.3.57

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fd20e8200bbd5f3eadcab0100d7854cd97cafdea7a2a04c4b6fda000c3a46c5
-  data.tar.gz: d35a9d04dbb252eb567ddd4a267d1603a2e3ec538f32e866ad32bb6adcaf11a8
+  metadata.gz: dac1ca6df26172acdc4f7a676c018d1a9cf6107f5a2b6643b1274cbd56ba3b8f
+  data.tar.gz: bbeebb38922a236a170578538858e2f795e9da94679dd6c7a0cd81576d4542a7
 SHA512:
-  metadata.gz: 7432ac5ea256ecc15bc615dd342c38bf0912fca1cda343b7dcbeafb05e636b9461f110e0d15830f81434e426eccd62c353fc786eee21f1b51e94372ed3adf051
-  data.tar.gz: 609460b69aee699d6fd03d7ee90047f22f8d990e6abcd60e3bd8ebf48c99c853a94fd4d9290823069a517741fb3d8f7ff57c86d73a26746809eb35d1d223727b
+  metadata.gz: 9170d4b42f82853d41741475abb92fe26f126fde281b4c1b2f31b6b6004dab21fa7a9a9a23b580b83c86f89978dd021767d5464c79080ef19d9ba68771cd7d23
+  data.tar.gz: 633a3b087e6b6d6656e8ddd0db3c0548f6985ea72e43da51537a95d07c480957397b5fe6eda56b8651a2d302cb6b886b5661fc2446dfc4aceb2943a9c31ba2a5

data/Cargo.lock

@@ -54,6 +54,15 @@ version = "2.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
 
+[[package]]
+name = "block-buffer"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa"
+dependencies = [
+ "hybrid-array",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.20.3"
@@ -86,6 +95,41 @@ dependencies = [
  "libloading",
 ]
 
+[[package]]
+name = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+]
+
 [[package]]
 name = "either"
 version = "1.18.0"
@@ -148,6 +192,15 @@ dependencies = [
  "foldhash",
 ]
 
+[[package]]
+name = "hybrid-array"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27f864f10dfb56725ce5ce5472bc52252c8f93a4ab86327122cebf62c5f59a17"
+dependencies = [
+ "typenum",
+]
+
 [[package]]
 name = "itertools"
 version = "0.13.0"
@@ -165,9 +218,9 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "js-sys"
-version = "0.3.105"
+version = "0.3.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce57d20d1ea864ce2ac172ab472d409214f4fd359f0b2a2775abdf522e2af99e"
+checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"
 dependencies = [
  "cfg-if",
  "wasm-bindgen",
@@ -203,9 +256,9 @@ checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
 
 [[package]]
 name = "magnus"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "379d50b6eea4ca84074ccd3e551eb9b07f7865194d5b3198325317e9ef78e5e9"
+checksum = "4c01bef153b8d0f086991f0e166474a1d57b738221f9a9c11405d498ac95a44d"
 dependencies = [
  "magnus-macros",
  "rb-sys",
@@ -215,9 +268,9 @@ dependencies = [
 
 [[package]]
 name = "magnus-macros"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ca70566af98184bb92d4d9853daaf533c1a3418b9570d0547ea44970035f3fe"
+checksum = "9dafde2eeb66f090e0f326112323eb8324b12cb32b5d1210e541d3df6b0ce77e"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -254,9 +307,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.8.11"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c28a0cd3b3e2491ef72c99f3dc59ef25ea2e0f13b8cd6ea31a05eb085a33f801"
+checksum = "3201f3b6340113ce57871a1405679ad7520a420cb8958777983371a2d4e6bf55"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -265,15 +318,17 @@ dependencies = [
  "magnus",
  "parsanol-derive",
  "regex",
+ "regex-syntax",
  "serde",
  "serde_json",
+ "sha2",
 ]
 
 [[package]]
 name = "parsanol-derive"
-version = "0.8.11"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ccfdf8325c4890930bbc1510bc9dfc929d485d1aa6c29cb563c5dc77d7a0080"
+checksum = "07bea1e5fb6a78314596116ac62e08ab5c73c201c62cd83715e75309c44e0977"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -445,6 +500,17 @@ dependencies = [
  "zmij",
 ]
 
+[[package]]
+name = "sha2"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
 [[package]]
 name = "shell-words"
 version = "1.1.1"
@@ -479,6 +545,12 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.26"
@@ -502,9 +574,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.128"
+version = "0.2.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aecb87a33d3b0c5e3b7aa46336eaf486cffafbd281b195e4c8b80d50df2351bf"
+checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -515,9 +587,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.128"
+version = "0.2.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a690d511e3c1a8b3a55e33511e3c2c00c78415cd23650f32b808627f5696b9ed"
+checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -525,9 +597,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.128"
+version = "0.2.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "411e4887f0071ef2d2164a9d5fdf2d20efbef78fccd3a78b0c10a1dc5295e48a"
+checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -538,9 +610,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.128"
+version = "0.2.129"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81941cd78d0c92026c33e5e01312845a4cb1e9af3407f9134b100dd03144103e"
+checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"
 dependencies = [
  "unicode-ident",
 ]
@@ -559,18 +631,18 @@ checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
 
 [[package]]
 name = "zerocopy"
-version = "0.8.57"
+version = "0.8.59"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d35102a9f36d089ccae9e4c6802bc118be4487b80aaffc0ab4e0cf5ce92d2873"
+checksum = "6df92bf3d9227be3d53173901ddbffac2babc27ae50f397776ffd6dc33f800cb"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.57"
+version = "0.8.59"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "146c01f5ab44258da43cf276c74a2763db2ff3969c9c652c3f2de07041d0b2bc"
+checksum = "ac4f328cf2f05d084e496c3e9c3f33ed0a183656a16e1fcec4d464d8373aec82"
 dependencies = [
  "proc-macro2",
  "quote",

data/exe/parsanol

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "parsanol"
+require "parsanol/parg/cli"
+argv = ARGV[0] == "parg" ? ARGV[1..] : ARGV
+exit Parsanol::PARG::CLI.run(argv)

data/ext/parsanol_cdylib/Cargo.toml

@@ -12,4 +12,4 @@ crate-type = ["cdylib"]
 doc = false
 
 [dependencies]
-parsanol = { version = "0.8.8" }
+parsanol = { version = "0.10" }

data/ext/parsanol_native/Cargo.toml

@@ -27,8 +27,8 @@ rb-sys = { version = "0.9.124", features = ["global-allocator"] }
 # magnus for Ruby bindings (from crates.io, patched locally for Ruby 4.0 support)
 magnus = { version = "0.9" }
 
-# parsanol parser library (from git for latest features)
-parsanol = { version = "0.8.9", features = ["ruby"] }
+# parsanol parser library (crates.io; 0.10 carries the class fast-path fix)
+parsanol = { version = "0.10", features = ["ruby"] }
 
 # Logging
 log = "0.4"

data/ext/parsanol_native/build.rs

@@ -0,0 +1,9 @@
+fn main() {
+    // MRI loadables on macOS resolve ruby symbols from the host process
+    // at load time; cargo's cdylib link defaults to failing on undefined
+    // symbols, so the flag must come from the top-level package.
+    if cfg!(target_os = "macos") {
+        println!("cargo:rustc-link-arg=-Wl,-undefined,dynamic_lookup");
+    }
+    println!("cargo:rerun-if-changed=build.rs");
+}

data/ext/parsanol_native/extconf.rb

@@ -30,6 +30,16 @@ create_rust_makefile("parsanol/parsanol_native") do |r|
   # Create debug builds in dev, release in production
   r.profile = ENV.fetch("RB_SYS_CARGO_PROFILE", :dev).to_sym
 
+  # cargo rustc builds dependency cdylibs verbatim, and parsanol ships
+  # a cdylib crate-type (the ffi tier). On macOS every dylib in the
+  # build resolves ruby symbols from the host process at load time, so
+  # every link must tolerate undefined symbols. (extconf runs as a
+  # subprocess, so this must be baked into the Makefile — env changes
+  # here would not survive it.)
+  if RbConfig::CONFIG["host_os"].include?("darwin")
+    r.extra_rustflags = %w[-C link-arg=-Wl,-undefined,dynamic_lookup]
+  end
+
   # Enable stable API compiled fallback for ruby-head and older Ruby versions
   r.use_stable_api_compiled_fallback = true
 

data/lib/parsanol/native/serializer.rb

@@ -95,9 +95,12 @@ module Parsanol
 
     def serialize_re(atom)
       # Ruby's Regexp#to_s produces "(?-mix:pattern)" format
-      # We need to extract just the pattern for the Rust parser
+      # The pattern must reach the Rust regex engine verbatim, including
+      # inline flag groups: stripping (?i:...) silently turned every
+      # case-insensitive regex into a case-sensitive one on the native
+      # path (the Ruby atom still compiled it with the flag, so the two
+      # engines disagreed). Rust regex understands the same inline groups.
       pattern = atom.match
-      pattern = ::Regexp.last_match(1) if pattern =~ /^\(\?[-mix]*:(.+)\)$/
       {
         "Re" => {
           "pattern" => pattern,

data/lib/parsanol/parg/artifact.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module Parsanol
+  module PARG
+    # A compiled artifact envelope: load, verify checksum, parse inputs.
+    #
+    # The envelope's grammar section is the portable JSON the native engines
+    # consume; the embedded PARG source lets a Ruby runtime recompile the atom
+    # tree locally without any other dependency.
+    class Artifact
+      attr_reader :envelope, :path, :tables_dir
+
+      def self.load(path, tables_dir: nil)
+        envelope = JSON.parse(File.read(path))
+        new(envelope, path, tables_dir || File.dirname(path))
+      end
+
+      def self.from_json(text, tables_dir: nil)
+        new(JSON.parse(text), nil, tables_dir)
+      end
+
+      SUPPORTED_SHAPE = "parsanol-tree/v2"
+
+      def initialize(envelope, path, tables_dir)
+        unless envelope["shape"] == SUPPORTED_SHAPE
+          raise ArtifactError,
+                "unsupported artifact shape #{envelope['shape'].inspect} " \
+                "(this runtime implements #{SUPPORTED_SHAPE.inspect})"
+        end
+        @envelope = envelope
+        @path = path
+        @tables_dir = tables_dir
+        verify_checksum!
+        @compiler = nil
+      end
+
+      def version = envelope["version"]
+
+      def entries = envelope["entries"].keys
+
+      def entry(name)
+        envelope["entries"].fetch(name) do
+          raise ArtifactError, "unknown entry #{name.inspect}"
+        end
+      end
+
+      # Parse via the native engine: the envelope's grammar section is the
+      # exact portable JSON the Rust side registers, so the artifact parse
+      # path is a straight register-and-run — no Ruby recompilation. The
+      # Ruby atom runtime (mode: :ruby) remains available explicitly, and
+      # serves as the fallback on platforms without the extension.
+      def parse(entry_name, input, mode: :native)
+        case mode
+        when :native
+          if Native.available?
+            return Native.parse(JSON.generate(entry(entry_name).fetch("grammar")), input)
+          end
+
+          root_atom(entry_name).parse(input)
+        when :ruby
+          root_atom(entry_name).parse(input)
+        else
+          raise ArgumentError, "unknown mode #{mode.inspect} (use :native or :ruby)"
+        end
+      end
+
+      def apply_bindings(entry_name, shape)
+        Bindings.apply(self, entry(entry_name), shape)
+      end
+
+      # Render the identifier string from a bound attribute map (F6).
+      def render(_entry_name, bound, variant: "default")
+        Render.apply(envelope["render"] || {}, variant, bound)
+      end
+
+      def render_string(entry_name, input, variant: "default")
+        render(entry_name, parse_and_bind(entry_name, input), variant: variant)
+      end
+
+      # Evaluate a named derive spec against a bound map (F6).
+      def derive(name, bound)
+        Derive.apply(envelope["derive"] || {}, name, bound)
+      end
+
+      def derive_string(entry_name, input, name)
+        derive(name, parse_and_bind(entry_name, input))
+      end
+
+      def parse_and_bind(entry_name, input, mode: :native)
+        apply_bindings(entry_name, parse(entry_name, input, mode: mode))
+      end
+
+      # Re-run the grammar's in-file tests against this artifact. Returns
+      # the failure descriptions; empty means every test passes.
+      def run_tests(mode: :native)
+        run_test_list(envelope.fetch("tests", []), mode: mode)
+      end
+
+      # Run an external test list (suite files yield Document::Test
+      # structs; embedded tests are artifact-shaped hashes).
+      def run_test_list(tests, mode: :native)
+        tests.filter_map do |test|
+          hash = test.is_a?(Document::Test) ? test_to_hash(test) : test
+          entry_name = hash["entry"] || entries.first
+          begin
+            bound = parse_and_bind(entry_name, hash["input"], mode: mode)
+            if hash["kind"] == "reject"
+              "test #{hash['input'].inspect}: expected the input to be rejected"
+            elsif hash["kind"] == "example"
+              expect = hash["expect"].to_h { |key, value| [key.to_sym, value] }
+              mismatched = expect.reject { |key, value| bound.key?(key) && bound[key] == value }
+              next if mismatched.empty?
+
+              "test #{hash['input'].inspect}: expected captures " \
+                "#{mismatched.transform_values(&:inspect).inspect}, got #{bound.inspect}"
+            end
+          rescue Parsanol::ParseFailed
+            unless hash["kind"] == "reject"
+              "test #{hash['input'].inspect}: expected the input to parse"
+            end
+          end
+        end
+      end
+
+      def test_to_hash(test)
+        {
+          "entry" => test.entry,
+          "kind" => test.kind.to_s,
+          "input" => test.input,
+          "expect" => test.expect,
+        }
+      end
+
+      # Rule documentation embedded from ## doc comments.
+      def rule_docs = envelope.fetch("docs", {})
+
+      # Structured parse diagnostics (PN 2): {offset, message} for the
+      # deepest failure of the most recent parse attempt on this entry.
+      def parse_with_diagnostics(entry_name, input, mode: :native)
+        shape = parse(entry_name, input, mode: mode)
+        { "ok" => true, "offset" => nil, "message" => nil, "shape" => shape }
+      rescue Parsanol::ParseFailed => e
+        cause = deepest_cause(e.parse_failure_cause)
+        { "ok" => false, "offset" => cause&.position,
+          "message" => cause&.message || e.message, "shape" => nil }
+      end
+
+      def deepest_cause(cause)
+        return cause if cause.nil? || cause.children.empty?
+
+        deepest = cause.children.filter_map { |child| deepest_cause(child) }
+          .max_by { |node| node.position.to_i }
+        (deepest&.position.to_i >= cause.position.to_i ? deepest : cause)
+      end
+
+      def table_rows(name)
+        @table_cache ||= {}
+        return @table_cache[name] if @table_cache.key?(name)
+
+        declared = envelope["tables"].fetch(name) do
+          raise ArtifactError, "artifact does not declare table #{name.inspect}"
+        end
+        if declared.is_a?(Hash) && declared.key?("rows")
+          return @table_cache[name] = declared["rows"]
+        end
+
+        file = declared
+        path = File.join(@tables_dir.to_s, file)
+        raw = path.end_with?(".json") ? JSON.parse(File.read(path)) : YAML.safe_load_file(path, aliases: true)
+        rows = case raw
+               when Hash
+                 raw.map { |key, value| { "name" => key.to_s }.merge(value.to_h.transform_keys(&:to_s)) }
+               when Array then raw.map { |row| row.to_h.transform_keys(&:to_s) }
+               else raise ArtifactError, "table #{name.inspect} must be a map or array"
+               end
+        @table_cache[name] = rows
+      end
+
+      def compiler
+        @compiler ||= begin
+          document = Parser.new(envelope.fetch("source")).parse
+          # `use`-importing grammars carry dotted cross-grammar rule
+          # references that only resolve once the imported sources merge;
+          # without this the pure-Ruby path fails on artifacts whose
+          # native atom graphs inline everything. The imported sources
+          # sit beside the artifact (vendors ship them together).
+          imports_dir = path && File.directory?(File.dirname(path)) ? File.dirname(path) : nil
+          Imports.merge!(document, [imports_dir].compact) if imports_dir
+          Compiler.new(document, @tables_dir)
+        end
+      end
+
+      def root_atom(entry_name)
+        rule = entry(entry_name).fetch("root")
+        @compiled ||= {}
+        @compiled[rule] ||= compiler.atom_for(rule)
+      end
+
+      def verify_checksum!
+        stored = envelope["checksum"]
+        computed = Compiler.checksum(envelope)
+        return if stored == computed
+
+        raise ArtifactError,
+              "artifact checksum mismatch: stored #{stored.inspect}, " \
+              "computed #{computed.inspect}"
+      end
+    end
+  end
+end

data/lib/parsanol/parg/authoring.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Parsanol
+  module PARG
+    # External test suites: *.pgtest files carrying the same test syntax
+    # as the inline test section (accept / reject / example). Suites are
+    # development-time corpora — they iterate a grammar against its
+    # binding requirements without being embedded in the artifact.
+    #
+    #   suite smoke for entry identifier {
+    #     accept "ISO 8601-1:2019"
+    #     example "ISO/CD 12345" { stage: "draft20" }
+    #   }
+    module Suite
+      module_function
+
+      # Load every *.pgtest file in a directory.
+      # Returns { suite_name => [Document::Test, ...] }.
+      def load(dir)
+        Dir.glob(File.join(dir, "*.pgtest")).to_h do |file|
+          [File.basename(file, ".pgtest"), read_file(file)]
+        end
+      end
+
+      def read_file(file)
+        content = File.read(file).gsub(/^#[^\n]*\n/, "")
+        header = content.match(/suite\s+\w+(?:\s+for\s+entry\s+(?<entry>\w+))?\s*\{/)
+        unless header
+          raise ParseError,
+                "#{file}: expected 'suite <name> [for <entry>] { ... }'"
+        end
+
+        body = content[header.end(0)..].sub(/\}\s*\z/, "")
+        document = Parser.new("grammar Suite version \"0.0.0\" {\n}\ntest {\n#{body}\n}\n").parse
+        document.tests.map do |test|
+          Document::Test.new(header[:entry] || test.entry, test.kind, test.input, test.expect)
+        end
+      end
+    end
+
+    # The binding-requirements schema: what a language-specific data model
+    # must implement for an entry. Derived from the declared bindings plus
+    # the observed example values.
+    module Schema
+      module_function
+
+      def from_artifact(artifact)
+        artifact.entries.to_h do |entry|
+          entry_data = artifact.entry(entry)
+          fields = entry_data["bindings"].to_h do |binding|
+            requirements = {
+              "type" => binding["type"],
+              "card" => binding["card"] || "1",
+            }
+            requirements["preprocess"] = binding["preprocess"] if binding["preprocess"]
+            [binding["path"], requirements]
+          end
+          examples = artifact.envelope.fetch("tests", [])
+            .select { |test| (test["kind"] == "example" && test["entry"].nil?) || test["entry"] == entry }
+            .map { |test| { "input" => test["input"], "captures" => test["expect"] } }
+          [entry, { "root" => entry_data["root"], "fields" => fields, "examples" => examples }]
+        end
+      end
+
+      # TypeScript materialization types: one interface per entry, one
+      # property per bound field. Cards ending in * become arrays;
+      # 0..1 becomes nullable.
+      def to_typescript(schema)
+        lines = ["// Generated by parsanol parg schema --ts — binding-requirements types."]
+        schema.each do |entry, data|
+          lines << ""
+          lines << "export interface #{ts_name(entry)} {"
+          data["fields"].each do |path, requirements|
+            lines << "  #{ts_prop(path)}: #{ts_type(requirements)};"
+          end
+          lines << "}"
+        end
+        "#{lines.join("\n")}\n"
+      end
+
+      def ts_name(entry)
+        entry.split(/[_.]/).map(&:capitalize).join
+      end
+
+      def ts_prop(path)
+        leaf = path.include?("[]") ? path.split("].").last : path
+        leaf.gsub(/([A-Za-z0-9])_([a-z])/) do
+          "#{Regexp.last_match(1)}#{Regexp.last_match(2).upcase}"
+        end
+      end
+
+      def ts_type(requirements)
+        base = case requirements["type"]
+               when "integer", "float" then "number"
+               when "boolean" then "boolean"
+               else "string"
+               end
+        if requirements["card"].to_s.end_with?("*")
+          "#{base}[]"
+        elsif requirements["card"] == "0..1"
+          "#{base} | null"
+        else
+          base
+        end
+      end
+    end
+  end
+end