@fraczak/k 7.2.0 → 8.0.0

package/scripts/run-tests.mjs

@@ -32,6 +32,11 @@ const derivationTests = fs.readdirSync(path.join(root, "tests/code-derivation"))
 
 const tests = [
   ["tests/test.mjs", node, ["tests/test.mjs"]],
+  [
+    "tests/test-named-patterns.mjs",
+    node,
+    ["tests/test-named-patterns.mjs"]
+  ],
   ...derivationTests,
   ["tests/test-fingerprint.mjs", node, ["tests/test-fingerprint.mjs"]],
   ["tests/test-hash-fuzz.mjs", node, ["tests/test-hash-fuzz.mjs"]],

package/symbol-table.mjs

@@ -93,6 +93,7 @@ function union(rels) {
 class SymbolTable {
   constructor() {
     this.rels = {}; // name -> {def: rel_exp}
+    this.patterns = {}; // name -> {params: string[], filter: filter_ast}
     this.codes = {
       [unitCode]: {
         code: "product",
@@ -109,12 +110,29 @@ class SymbolTable {
   }
 
   add_rel(name, rel) {
-    if (this.rels[name] != undefined)
-      console.error(`SymbolTable: rel '${name}' is redefined (lines ${rel.start?.line}:${rel.start?.column}...${rel.end?.line}:${rel.end?.column})`);
+    if (this.rels[name] != undefined) {
+      console.error(
+        `SymbolTable: rel '${name}' is redefined ` +
+        `(lines ${rel.start?.line}:${rel.start?.column}...` +
+        `${rel.end?.line}:${rel.end?.column})`
+      );
+    }
 
     this.rels[name] = {def: rel};
   }
 
+  add_pattern(name, params, filter) {
+    if (this.patterns[name] != undefined) {
+      console.error(
+        `SymbolTable: pattern '${name}' is redefined ` +
+        `(lines ${filter.start?.line}:${filter.start?.column}...` +
+        `${filter.end?.line}:${filter.end?.column})`
+      );
+    }
+
+    this.patterns[name] = { params, filter };
+  }
+
   add_code(name, code) {
     this.codes[name] = code;
   }

package/tests/bench-djson-tries.mjs

@@ -0,0 +1,340 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import { createState, evaluateInput } from "../repl.mjs";
+import * as djsonCodec from "../codecs/djson.mjs";
+import btrieCodec, { indexToBitPath } from "../codecs/djson-btrie.mjs";
+import ptrieCodec from "../codecs/djson-ptrie.mjs";
+import {
+  compileWasmArtifactFromObject,
+  instantiateWasmArtifact,
+  writeValueToArena
+} from "../backends/wasm/src/wasm.mjs";
+import {
+  compileCaseExecutable,
+  prepareRelation,
+  runExecutableMainBench,
+  wireInput
+} from "../backends/llvm/tests/perf-support.mjs";
+
+const llvmCacheDir = fs.mkdtempSync(
+  path.join(os.tmpdir(), "k-djson-bench-")
+);
+
+console.log("=== 1. Codec Round-Trip Verification ===");
+const sampleJson = {
+  name: "Alice",
+  age: 30,
+  active: true,
+  nothing: null,
+  scores: [10, 20, 30, 40, 50],
+  nested: { a: 1, ab: 2, abc: 3, abd: 4, z: 99 }
+};
+const sampleStr = JSON.stringify(sampleJson);
+
+for (const [label, c, pat] of [
+  ["djson (cons-list)", djsonCodec, djsonCodec.DJSON_PATTERN],
+  ["djson-btrie (bit-trie)", btrieCodec, btrieCodec.pattern],
+  ["djson-ptrie (radix-trie)", ptrieCodec, ptrieCodec.pattern]
+]) {
+  const kVal = c.parse(sampleStr);
+  const roundTrip = JSON.parse(c.print(kVal));
+  assert.deepStrictEqual(
+    roundTrip,
+    sampleJson,
+    `${label} round-trip failed`
+  );
+  console.log(
+    `  [OK] ${label.padEnd(26)} pattern nodes: ${pat.length}`
+  );
+}
+
+function indexToKLiteral(idx) {
+  const bits = indexToBitPath(idx);
+  const tags = bits.slice().reverse().map((b) => `|${b}`).join("");
+  return `({}|_${tags})`;
+}
+
+async function setupBenchmarkState(kFile, benchSnippet) {
+  const st = createState({ engine: "wasm" });
+  await evaluateInput(`:load ${kFile}`, st);
+  await evaluateInput(benchSnippet, st);
+  return st;
+}
+
+async function benchRelationOnInput({
+  state,
+  relName,
+  kInput,
+  codec,
+  expectedJson,
+  calls = 1000
+}) {
+  const wire = wireInput(kInput, codec.pattern);
+  const wireBytes = wire.inputWire.length;
+  const prepared = prepareRelation(state, relName);
+
+  // 1. Wasm Compilation & Execution
+  const tWasmComp0 = performance.now();
+  const wasmBytes = await compileWasmArtifactFromObject(prepared.object, {
+    relation: prepared.relationName,
+    inputEnvelopePattern: wire.inputPattern,
+    usePKIR: false
+  });
+  const runner = await instantiateWasmArtifact(wasmBytes);
+  const wasmCompileMs = performance.now() - tWasmComp0;
+
+  // Verify output once
+  const outVal = runner.executeValue(kInput);
+  assert(outVal !== undefined, `${relName} Wasm returned undefined`);
+  assert.deepStrictEqual(
+    JSON.parse(codec.print(outVal)),
+    expectedJson,
+    `Wasm output mismatch for ${relName}`
+  );
+
+  // Write input once to arena, then loop N calls resetting arena mark
+  const ptrIn = writeValueToArena(
+    runner.exports,
+    kInput,
+    runner.inputPattern,
+    0,
+    new Map(),
+    runner.tags,
+    runner.metadata.inputPattern
+  );
+  const mark = runner.exports.arena_mark();
+  const entryFn = runner.exports[runner.metadata.entry];
+
+  // Warmup
+  for (let i = 0; i < 20; i++) {
+    runner.exports.arena_reset(mark);
+    entryFn(ptrIn);
+  }
+
+  const tWasmExec0 = performance.now();
+  for (let i = 0; i < calls; i++) {
+    runner.exports.arena_reset(mark);
+    entryFn(ptrIn);
+  }
+  const wasmExecNsPerCall =
+    ((performance.now() - tWasmExec0) * 1e6) / calls;
+
+  // 2. LLVM Compilation & Execution (-O3)
+  const tLlvmComp0 = performance.now();
+  const exePath = compileCaseExecutable({
+    object: prepared.object,
+    relationName: prepared.relationName,
+    relHash: prepared.relHash,
+    inputPattern: wire.inputPattern,
+    cacheDir: llvmCacheDir,
+    sourceLabel: relName,
+    runtimeMode: "fast",
+    clangOpt: "-O3",
+    usePKIR: false
+  });
+  const llvmCompileMs = performance.now() - tLlvmComp0;
+  const llvmRes = await runExecutableMainBench(
+    exePath,
+    wire.inputWire,
+    calls
+  );
+
+  return {
+    wireBytes,
+    wasmBytes: wasmBytes.length,
+    wasmCompileMs,
+    wasmExecNsPerCall,
+    llvmCompileMs,
+    llvmExecNsPerCall: llvmRes.perCallNs
+  };
+}
+
+const SCHEMAS = [
+  {
+    name: "djson (cons)",
+    kFile: "Examples/djson.k",
+    codec: { ...djsonCodec, pattern: djsonCodec.DJSON_PATTERN },
+    dotExpr:
+      "bench_dot = json? { " +
+      "/list /cons .car /string key, " +
+      "/list /cons .cdr /cons .car /object object } dot json?;"
+  },
+  {
+    name: "djson-btrie",
+    kFile: "Examples/djson-btrie.k",
+    codec: btrieCodec,
+    dotExpr:
+      "bench_dot = json? { " +
+      "{ 0 index, /list list } nth /string key, " +
+      "{ 1 index, /list list } nth /object object } dot json?;"
+  },
+  {
+    name: "djson-ptrie",
+    kFile: "Examples/djson-ptrie.k",
+    codec: ptrieCodec,
+    dotExpr:
+      "bench_dot = json? { " +
+      "{ 0 index, /list list } nth /string key, " +
+      "{ 1 index, /list list } nth /object object } dot json?;"
+  }
+];
+
+console.log(
+  "\n=== 2A. Object Lookup (`dot`) — " +
+  "Shared-Prefix Keys (Wasm vs LLVM -O3) ==="
+);
+for (const numKeys of [10, 100, 500]) {
+  const obj = {};
+  for (let i = 0; i < numKeys; i++) {
+    const k = `field_prefix_${String(i).padStart(4, "0")}`;
+    obj[k] = i * 10;
+  }
+  const targetKey =
+    `field_prefix_${String(numKeys - 1).padStart(4, "0")}`;
+  const expectedVal = (numKeys - 1) * 10;
+  const inputJsonStr = JSON.stringify([targetKey, obj]);
+
+  console.log(
+    `\n--- Object with ${numKeys} shared-prefix keys ` +
+    `(querying '${targetKey}') ---`
+  );
+  console.log(
+    "Schema          | Wire (B) | Wasm (B) | " +
+    "Wasm Comp | LLVM Comp | Wasm (ns/call) | LLVM (ns/call)"
+  );
+  console.log(
+    "----------------+----------+----------+-" +
+    "----------+-----------+----------------+---------------"
+  );
+
+  for (const s of SCHEMAS) {
+    const st = await setupBenchmarkState(s.kFile, s.dotExpr);
+    const kInput = s.codec.parse(inputJsonStr);
+    const res = await benchRelationOnInput({
+      state: st,
+      relName: "bench_dot",
+      kInput,
+      codec: s.codec,
+      expectedJson: expectedVal,
+      calls: 1000
+    });
+    console.log(
+      `${s.name.padEnd(15)} | ${String(res.wireBytes).padStart(8)} | ` +
+      `${String(res.wasmBytes).padStart(8)} | ` +
+      `${res.wasmCompileMs.toFixed(0).padStart(7)}ms | ` +
+      `${res.llvmCompileMs.toFixed(0).padStart(7)}ms | ` +
+      `${res.wasmExecNsPerCall.toFixed(0).padStart(14)} | ` +
+      `${res.llvmExecNsPerCall.toFixed(0).padStart(14)}`
+    );
+  }
+}
+
+console.log(
+  "\n=== 2B. Object Lookup (`dot`) — " +
+  "Distinct/Varied Keys (Wasm vs LLVM -O3) ==="
+);
+const WORDS = [
+  "account", "balance", "category", "database", "endpoint",
+  "filename", "geometry", "hostname", "identity", "journal",
+  "keyboard", "language", "metadata", "network", "operator",
+  "password", "quantity", "resource", "security", "template",
+  "username", "validate", "workflow", "x509cert", "yearbook", "zoneinfo"
+];
+for (const numKeys of [10, 100, 500]) {
+  const obj = {};
+  for (let i = 0; i < numKeys; i++) {
+    const w1 = WORDS[i % WORDS.length];
+    const w2 = WORDS[Math.floor(i / WORDS.length) % WORDS.length];
+    const k = `${w1}_${i}_${w2}_attr`;
+    obj[k] = i * 10;
+  }
+  const targetKey = Object.keys(obj).sort().at(-1);
+  const expectedVal = obj[targetKey];
+  const inputJsonStr = JSON.stringify([targetKey, obj]);
+
+  console.log(
+    `\n--- Object with ${numKeys} varied keys ` +
+    `(querying '${targetKey}') ---`
+  );
+  console.log(
+    "Schema          | Wire (B) | Wasm (B) | " +
+    "Wasm Comp | LLVM Comp | Wasm (ns/call) | LLVM (ns/call)"
+  );
+  console.log(
+    "----------------+----------+----------+-" +
+    "----------+-----------+----------------+---------------"
+  );
+
+  for (const s of SCHEMAS) {
+    const st = await setupBenchmarkState(s.kFile, s.dotExpr);
+    const kInput = s.codec.parse(inputJsonStr);
+    const res = await benchRelationOnInput({
+      state: st,
+      relName: "bench_dot",
+      kInput,
+      codec: s.codec,
+      expectedJson: expectedVal,
+      calls: 1000
+    });
+    console.log(
+      `${s.name.padEnd(15)} | ${String(res.wireBytes).padStart(8)} | ` +
+      `${String(res.wasmBytes).padStart(8)} | ` +
+      `${res.wasmCompileMs.toFixed(0).padStart(7)}ms | ` +
+      `${res.llvmCompileMs.toFixed(0).padStart(7)}ms | ` +
+      `${res.wasmExecNsPerCall.toFixed(0).padStart(14)} | ` +
+      `${res.llvmExecNsPerCall.toFixed(0).padStart(14)}`
+    );
+  }
+}
+
+console.log(
+  "\n=== 3. List Element Lookup (`nth`) Benchmark (Wasm vs LLVM -O3) ==="
+);
+for (const len of [10, 100, 500]) {
+  const arr = Array.from({ length: len }, (_, i) => i * 3);
+  const targetIdx = len - 1;
+  const expectedVal = targetIdx * 3;
+  const inputJsonStr = JSON.stringify(arr);
+  const idxLit = indexToKLiteral(targetIdx);
+  const nthExpr =
+    `bench_nth = json? { ${idxLit} index, /list list } nth json?;`;
+
+  console.log(
+    `\n--- Array with ${len} elements ` +
+    `(querying index ${targetIdx}) ---`
+  );
+  console.log(
+    "Schema          | Wire (B) | Wasm (B) | " +
+    "Wasm Comp | LLVM Comp | Wasm (ns/call) | LLVM (ns/call)"
+  );
+  console.log(
+    "----------------+----------+----------+-" +
+    "----------+-----------+----------------+---------------"
+  );
+
+  for (const s of SCHEMAS) {
+    const st = await setupBenchmarkState(s.kFile, nthExpr);
+    const kInput = s.codec.parse(inputJsonStr);
+    const res = await benchRelationOnInput({
+      state: st,
+      relName: "bench_nth",
+      kInput,
+      codec: s.codec,
+      expectedJson: expectedVal,
+      calls: 1000
+    });
+    console.log(
+      `${s.name.padEnd(15)} | ${String(res.wireBytes).padStart(8)} | ` +
+      `${String(res.wasmBytes).padStart(8)} | ` +
+      `${res.wasmCompileMs.toFixed(0).padStart(7)}ms | ` +
+      `${res.llvmCompileMs.toFixed(0).padStart(7)}ms | ` +
+      `${res.wasmExecNsPerCall.toFixed(0).padStart(14)} | ` +
+      `${res.llvmExecNsPerCall.toFixed(0).padStart(14)}`
+    );
+  }
+}
+
+fs.rmSync(llvmCacheDir, { recursive: true, force: true });

package/tests/test-codecs.mjs

@@ -9,6 +9,8 @@ import * as SDK from "../codecs/runtime/codec-sdk.mjs";
 import * as IntCodec from "../codecs/int.mjs";
 import * as JsonCodec from "../codecs/json.mjs";
 import * as DjsonCodec from "../codecs/djson.mjs";
+import * as DjsonBtrieCodec from "../codecs/djson-btrie.mjs";
+import * as DjsonPtrieCodec from "../codecs/djson-ptrie.mjs";
 import * as Utf8Codec from "../codecs/utf8.mjs";
 import * as Utf16Codec from "../codecs/utf16.mjs";
 import * as IeeeCodec from "../codecs/ieee.mjs";
@@ -55,6 +57,16 @@ for (const [name, codec, sampleInput] of [
   ["int.mjs", IntCodec, "42"],
   ["json.mjs", JsonCodec, '{"x": 1}'],
   ["djson.mjs", DjsonCodec, '{"x": 1, "arr": [true, null, "hi"]}'],
+  [
+    "djson-btrie.mjs",
+    DjsonBtrieCodec,
+    '{"x": 1, "arr": [true, null, "hi"]}'
+  ],
+  [
+    "djson-ptrie.mjs",
+    DjsonPtrieCodec,
+    '{"x": 1, "arr": [true, null, "hi"]}'
+  ],
   ["utf8.mjs", Utf8Codec, "hello"],
   ["utf16.mjs", Utf16Codec, "hello"],
   ["ieee.mjs", IeeeCodec, "3.14"],
@@ -75,6 +87,8 @@ for (const relPath of [
   "codecs/int.mjs",
   "codecs/json.mjs",
   "codecs/djson.mjs",
+  "codecs/djson-btrie.mjs",
+  "codecs/djson-ptrie.mjs",
   "codecs/utf8.mjs",
   "codecs/utf16.mjs",
   "codecs/ieee.mjs",
@@ -314,11 +328,15 @@ console.log("8. Verifying fast string decoding & bounded rendering...");
   );
 }
 
-// 9. DJSON Singleton Pattern Invariant & Round-Trip
-console.log("9. Verifying DJSON singleton pattern invariant...");
+// 9. DJSON Family Singleton Pattern Invariants & Round-Trip
+console.log("9. Verifying DJSON family singleton pattern invariants...");
 {
   assert(Array.isArray(DjsonCodec.DJSON_PATTERN));
   assert.equal(DjsonCodec.DJSON_PATTERN.length, 29);
+  assert(Array.isArray(DjsonBtrieCodec.DJSON_BTRIE_PATTERN));
+  assert.equal(DjsonBtrieCodec.DJSON_BTRIE_PATTERN.length, 27);
+  assert(Array.isArray(DjsonPtrieCodec.DJSON_PTRIE_PATTERN));
+  assert.equal(DjsonPtrieCodec.DJSON_PTRIE_PATTERN.length, 33);
 
   const samples = [
     null,
@@ -332,21 +350,46 @@ console.log("9. Verifying DJSON singleton pattern invariant...");
     { key: "value", nested: [1, 2, { deep: true }] }
   ];
 
-  for (const sample of samples) {
-    const jsonStr = JSON.stringify(sample);
-    const enveloped = DjsonCodec.parse(jsonStr);
-    assert.strictEqual(
-      enveloped.pattern,
-      DjsonCodec.DJSON_PATTERN,
-      "Every DJSON value must share the exact singleton pattern"
-    );
-    const wire = SDK.encodeToWire(enveloped, enveloped.pattern);
-    const decoded = SDK.decodeWire(wire);
-    const restored = DjsonCodec.print(decoded.value);
+  for (const [label, codec, pat, relPath] of [
+    ["djson", DjsonCodec, DjsonCodec.DJSON_PATTERN, "codecs/djson.mjs"],
+    [
+      "djson-btrie",
+      DjsonBtrieCodec,
+      DjsonBtrieCodec.DJSON_BTRIE_PATTERN,
+      "codecs/djson-btrie.mjs"
+    ],
+    [
+      "djson-ptrie",
+      DjsonPtrieCodec,
+      DjsonPtrieCodec.DJSON_PTRIE_PATTERN,
+      "codecs/djson-ptrie.mjs"
+    ]
+  ]) {
+    for (const sample of samples) {
+      const jsonStr = JSON.stringify(sample);
+      const enveloped = codec.parse(jsonStr);
+      assert.strictEqual(
+        enveloped.pattern,
+        pat,
+        `Every ${label} value must share the exact singleton pattern`
+      );
+      const wire = SDK.encodeToWire(enveloped, enveloped.pattern);
+      const decoded = SDK.decodeWire(wire);
+      const restored = codec.print(decoded.value);
+      assert.deepEqual(
+        JSON.parse(restored),
+        sample,
+        `${label} round-trip mismatch for: ${jsonStr}`
+      );
+    }
+    const cliSample = JSON.stringify({ a: 1, b: [true, "ok"] });
+    const parseRes = runCLI(relPath, ["--parse"], cliSample);
+    assert.equal(parseRes.status, 0);
+    const printRes = runCLI(relPath, ["--print"], parseRes.stdout);
+    assert.equal(printRes.status, 0);
     assert.deepEqual(
-      JSON.parse(restored),
-      sample,
-      `DJSON round-trip mismatch for: ${jsonStr}`
+      JSON.parse(printRes.stdout.toString("utf8")),
+      JSON.parse(cliSample)
     );
   }
 }

package/tests/test-named-patterns.mjs

@@ -0,0 +1,189 @@
+// tests/test-named-patterns.mjs
+// Comprehensive test suite for named patterns and type schemes.
+
+import assert from "node:assert/strict";
+import k from "../index.mjs";
+import { Value } from "../Value.mjs";
+
+console.log("==> Running Named Patterns Test Suite");
+
+// Test 1: 0-arity pattern and composite product
+console.log("--> Test 1: 0-arity pattern (bit[]) and product (byte[])");
+{
+  const script = `
+    bit[] = < {}0, {}1 >;
+    byte[] = {
+      bit[] b0, bit[] b1, bit[] b2, bit[] b3,
+      bit[] b4, bit[] b5, bit[] b6, bit[] b7
+    };
+
+    is_byte = ? byte[];
+
+    sample = {
+      {}|0 b0, {}|1 b1, {}|0 b2, {}|1 b3,
+      {}|0 b4, {}|1 b5, {}|0 b6, {}|1 b7
+    };
+
+    sample is_byte
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.type, "{}");
+  assert.equal(out.product.b0.tag, "0");
+  assert.equal(out.product.b1.tag, "1");
+  console.log("    Passed: 0-arity patterns and composition.");
+}
+
+// Test 2: Parameterized list pattern
+console.log("--> Test 2: Parameterized pattern (list[X])");
+{
+  const script = `
+    bit[] = < {}0, {}1 >;
+    list[X] = < {}nil, { X car, Y cdr } cons > = Y;
+
+    is_bit_list = ? list[bit[]];
+
+    empty = {}|nil is_bit_list;
+    one = { {}|1 car, {}|nil cdr }|cons is_bit_list;
+    two = {
+      {}|0 car,
+      { {}|1 car, {}|nil cdr }|cons cdr
+    }|cons is_bit_list;
+
+    { empty empty, one one, two two }
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.product.empty.tag, "nil");
+  assert.equal(out.product.one.tag, "cons");
+  assert.equal(out.product.one.value.product.car.tag, "1");
+  assert.equal(out.product.two.tag, "cons");
+  assert.equal(out.product.two.value.product.car.tag, "0");
+  console.log("    Passed: Parameterized list pattern.");
+}
+
+// Test 3: Multi-parameter templates and composition
+console.log("--> Test 3: Multi-parameter templates (pair, dict)");
+{
+  const script = `
+    bit[] = < {}0, {}1 >;
+    pair[A, B] = { A key, B val };
+    list[X] = < {}nil, { X car, Y cdr } cons > = Y;
+    dict[K, V] = list[pair[K, V]];
+
+    is_dict = ? dict[bit[], bit[]];
+
+    entry = { {}|0 key, {}|1 val };
+    d = { entry car, {}|nil cdr }|cons is_dict;
+
+    d
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.tag, "cons");
+  assert.equal(out.value.product.car.product.key.tag, "0");
+  assert.equal(out.value.product.car.product.val.tag, "1");
+  console.log("    Passed: Multi-parameter template composition.");
+}
+
+// Test 4: Existential internal variables (type unification across fields)
+console.log("--> Test 4: Existential variables (same_pair[])");
+{
+  const scriptOk = `
+    same_pair[] = { T first, T second };
+    check = ? same_pair[];
+    { {}|0 first, {}|1 second } check
+  `;
+  const fnOk = k.compile(scriptOk);
+  const outOk = fnOk(Value.product({}));
+  assert.equal(outOk.product.first.tag, "0");
+  assert.equal(outOk.product.second.tag, "1");
+
+  const scriptBad = `
+    same_pair[] = { T first, T second };
+    check = ? same_pair[];
+    { {} first, {}|0 second } check
+  `;
+  assert.throws(
+    () => k.compile(scriptBad),
+    /Cannot unify/
+  );
+  console.log("    Passed: Existential variables unified across fields.");
+}
+
+// Test 5: Recursive tree with internal knot and list
+console.log("--> Test 5: Recursive tree with knot T (tree[X])");
+{
+  const script = `
+    list[X] = < {}nil, { X car, Y cdr } cons > = Y;
+    tree[X] = < {}nil, { X val, list[T] children } node > = T;
+
+    bit[] = < {}0, {}1 >;
+    is_tree = ? tree[bit[]];
+
+    leaf = { {}|1 val, {}|nil children }|node is_tree;
+    root = {
+      {}|0 val,
+      { leaf car, {}|nil cdr }|cons children
+    }|node is_tree;
+
+    { leaf leaf, root root }
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.product.leaf.tag, "node");
+  assert.equal(out.product.leaf.value.product.val.tag, "1");
+  assert.equal(out.product.root.tag, "node");
+  assert.equal(out.product.root.value.product.val.tag, "0");
+  console.log("    Passed: Recursive tree template with list port.");
+}
+
+// Test 6: Polymorphic relation with shared type variable
+console.log("--> Test 6: Polymorphic relation ({ X car, list[X] cdr })");
+{
+  const script = `
+    list[X] = < {}nil, { X car, Y cdr } cons > = Y;
+    head = ? { X car, list[X] cdr } .car;
+
+    bit[] = < {}0, {}1 >;
+    h1 = { {}|1 car, {}|nil cdr } head;
+
+    h1
+  `;
+  const fn = k.compile(script);
+  const out = fn(Value.product({}));
+  assert.equal(out.tag, "1");
+  console.log("    Passed: Polymorphic relation head with list[X].");
+}
+
+// Test 7: Error handling for templates
+console.log("--> Test 7: Error handling (unknown, arity, cycles, dupes)");
+{
+  assert.throws(
+    () => k.compile("check = ? missing[]; ()"),
+    /Unknown pattern template 'missing\[\]'/
+  );
+
+  assert.throws(
+    () => k.compile("list[X] = {}; check = ? list[]; ()"),
+    /Pattern 'list' expects 1 argument, got 0/
+  );
+
+  assert.throws(
+    () => k.compile("pair[A, B] = {}; check = ? pair[{}]; ()"),
+    /Pattern 'pair' expects 2 arguments, got 1/
+  );
+
+  assert.throws(
+    () => k.compile("a[] = b[]; b[] = a[]; check = ? a[]; ()"),
+    /Cyclic pattern template dependency detected/
+  );
+
+  assert.throws(
+    () => k.compile("dupe[X, X] = {}; ()"),
+    /Duplicate parameter 'X' in pattern 'dupe'/
+  );
+  console.log("    Passed: Error conditions correctly handled.");
+}
+
+console.log("==> All Named Patterns Tests Passed Successfully!");