@fraczak/k 7.0.0 → 7.0.1

package/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 This project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [7.0.1] — 2026-10-10 — Call-Graph Pattern Graph Specialization
+
+### Bug Fixes & Backend Alignments
+
+- **Pattern Graph Specialization Across Call Graphs**:
+  - Implemented `specializeObjectRelations` in `kir.mjs` to propagate input
+    schemas across relation call graphs via monomorphization.
+  - Statically resolves field projection offsets for open product and
+    polymorphic helper relations without dynamic fallback (`@k_product_get_n`).
+  - Fixed WASM predicted field index calculation and aligned product header
+    memory layout (`tagId` at header slots).
+  - Resolved polymorphic list and open product projection alignment across
+    LLVM, WASM, and Web REPL.
+
 ## [7.0.0] — 2026-10-10 — Unified Schemas, Relational Contracts, and Pure Syntax
 
 ### Breaking Language & Syntax Changes

package/backend-api.mjs

@@ -4,7 +4,15 @@ export { decodeWire, encodeToWire } from "./codecs/runtime/prefix-codec.mjs";
 export { exportPatternGraph, NODE_KIND } from "./codecs/runtime/codec.mjs";
 export { patternToPropertyList, propertyListToPattern } from "./codecs/runtime/pattern-json.mjs";
 export { Value, fromObject, isProduct, isVariant, isValue } from "./Value.mjs";
-export { KIR_FORMAT, KIR_VERSION, objectToKIRP, retypeObjectRelation, retypeObjectRelationForBackend } from "./kir.mjs";
+export {
+  KIR_FORMAT,
+  KIR_VERSION,
+  objectToKIRP,
+  relationPatternPropertyList,
+  retypeObjectRelation,
+  retypeObjectRelationForBackend,
+  specializeObjectRelations
+} from "./kir.mjs";
 export { compileLibrary, decodeObject, loadLibrary } from "./object.mjs";
 export { createState, evaluateInput } from "./repl.mjs";
 export { parse as parseFloat64, print as printFloat64 } from "./codecs/ieee.mjs";

package/backends/llvm/scripts/run-tests.mjs

@@ -24,6 +24,11 @@ if (process.argv.includes("-h") || process.argv.includes("--help")) {
 
 const tests = [
   ["tests/test-llvm.mjs", node, ["tests/test-llvm.mjs"]],
+  [
+    "tests/test-open-product-misalignment.mjs",
+    node,
+    ["tests/test-open-product-misalignment.mjs", "--assert"]
+  ],
   ["tests/integration.sh", path.join(root, "tests/integration.sh"), []],
   ["scripts/conformance.mjs", node, ["scripts/conformance.mjs"]]
 ];

package/backends/llvm/src/kvm2llvm.mjs

@@ -678,7 +678,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           const label = ctx.labelRef(inst.label);
           let val;
           if (edgeIndex >= 0 && ctx.runtimeMode !== "compact") {
-            val = lowerProductGetAt(ctx, input, edgeIndex, label);
+            val = lowerProductGetAt(ctx, input, edgeIndex, null);
           } else {
             val = ctx.tempName("field");
             ctx.lines.push(`  ${val} = call ptr @k_product_get_n(ptr ${input}, ptr ${label.pointer}, i64 ${label.length})`);
@@ -831,6 +831,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           }
 
           regValues.set(cleanReg(inst.dest), product);
+          if (inst.pattern) regPatterns.set(cleanReg(inst.dest), inst.pattern);
           break;
         }
         case "union": {

package/backends/llvm/src/llvm.mjs

@@ -1011,8 +1011,7 @@ export function emitLLVMModule(input, options = {}) {
 export function compileObjectToLLVM(object, options = {}) {
   const inputPattern = options.inputPattern ? readPattern(options.inputPattern) : null;
   const relation = options.relation || object.main;
-
-  let retypedKir = null;
+  let targetObject = object;
   let entryInputPattern = inputPattern;
   let outputPattern = null;
 
@@ -1020,43 +1019,37 @@ export function compileObjectToLLVM(object, options = {}) {
     const retyped = retypeObjectRelationForBackend(object, relation, inputPattern, {
       source: options.source || "<k-llvm>"
     });
-    retypedKir = retyped.kir;
+    targetObject = retyped.retypedObject;
     entryInputPattern = retyped.inputPattern;
     outputPattern = retyped.outputPattern;
-  } else {
-    retypedKir = objectToKIRP(object);
   }
 
-  let kvmArtifact = objectToKVMArtifact(object, relation, null, options);
-  let specializedKvm = kvmArtifact;
-  if (inputPattern) {
-    try {
-      specializedKvm = specializeKVM(kvmArtifact, inputPattern);
-    } catch {
-      specializedKvm = {
-        ...kvmArtifact,
-        functions: lowerKIRToKVM(retypedKir),
-        entry: relation
-      };
-    }
-  }
-
-  const entry = specializedKvm.entry || relation;
-  const functions = specializedKvm.functions;
+  const retypedKir = objectToKIRP(targetObject);
+  const functions = lowerKIRToKVM(retypedKir);
+  const entry = relation || targetObject.main || "__main__";
+
+  const specializedKvm = {
+    format: "k-vm",
+    version: 1,
+    entry,
+    functions,
+    inputPattern: entryInputPattern,
+    outputPattern
+  };
 
   const llvm = compileKVMModuleToLLVM(entry, functions, {
     ...options,
     relation,
-    inputPattern: entryInputPattern || specializedKvm.inputPattern,
-    outputPattern: outputPattern || specializedKvm.outputPattern
+    inputPattern: entryInputPattern,
+    outputPattern
   });
 
   return {
     kir: retypedKir,
     kvm: specializedKvm,
     relation,
-    inputPattern: entryInputPattern || specializedKvm.inputPattern,
-    outputPattern: outputPattern || specializedKvm.outputPattern,
+    inputPattern: entryInputPattern,
+    outputPattern,
     llvm
   };
 }

package/backends/llvm/tests/integration.sh

@@ -112,7 +112,7 @@ node --input-type=module -e "import { stdout } from 'node:process'; import { enc
   | node --input-type=module -e "import { stdin } from 'node:process'; import { decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; const chunks = []; stdin.on('data', (chunk) => chunks.push(chunk)); stdin.on('end', () => console.log(JSON.stringify(decodeWire(Buffer.concat(chunks)).pattern)));" \
   | grep -Fqx '[["open-union",[["left",1],["right",1]]],["closed-product",[]]]'
 
-node ./bin/k-llvm-build.mjs '$bits = < {} _, bits 0, bits 1 >; $int = < bits "+", bits "-" >; $int' -o "$TMP_DIR/id-int-exe"
+node ./bin/k-llvm-build.mjs '?< <bits 0, bits 1, {} _>=bits "+", bits "-">' -o "$TMP_DIR/id-int-exe"
 printf '2' \
   | node ../../codecs/int.mjs --parse \
   | "$TMP_DIR/id-int-exe" \
@@ -121,7 +121,7 @@ printf '2' \
 
 node --input-type=module -e "import assert from 'node:assert/strict'; import { spawn } from 'node:child_process'; import { encodeToWire, decodeWire } from '../../codecs/runtime/prefix-codec.mjs'; import { parse, INT_PATTERN } from '../../codecs/int.mjs'; const input = encodeToWire(parse('2'), INT_PATTERN); const header = Buffer.alloc(4); header.writeUInt32BE(input.length); const child = spawn(process.argv[1], ['--server']); const chunks = []; const stderr = []; child.stdout.on('data', (chunk) => chunks.push(chunk)); child.stderr.on('data', (chunk) => stderr.push(chunk)); child.stdin.end(Buffer.concat([header, input])); const status = await new Promise((resolve, reject) => { child.on('error', reject); child.on('close', resolve); }); assert.equal(status, 0, Buffer.concat(stderr).toString('utf8')); const output = Buffer.concat(chunks); const length = output.readUInt32BE(0); assert.equal(output.length, 4 + length); assert.deepEqual(decodeWire(output.subarray(4)).value.toJSON(), parse('2').toJSON());" "$TMP_DIR/id-int-exe"
 
-node ./bin/k-llvm-build.mjs --lib ../../Examples/arithmetics.k --export times 's = {()x, ()y} times; s' -o "$TMP_DIR/square-exe"
+node ./bin/k-llvm-build.mjs --lib ../../Examples/arithmetics.k --export times 's = ?< <bits 0, bits 1, {} _>=bits "+", bits "-" > {()x, ()y} times; s' -o "$TMP_DIR/square-exe"
 printf '987654321' \
   | node ../../codecs/int.mjs --parse \
   | "$TMP_DIR/square-exe" \

package/backends/llvm/tests/test-llvm.mjs

@@ -239,11 +239,11 @@ assert.doesNotMatch(nestedUnionLLVM, /call void @k_product_set_at\(ptr %product\
 assert.doesNotMatch(nestedUnionLLVM, /ptr false/);
 
 const productRecurseObject = decodeObject(compileObjectBuffer(`
-  $ list = < {} nil, { {} car, list cdr } cons >;
-  foo = $list <
+  list = ?< {} nil, { {} car, list cdr } cons >;
+  foo = list <
     /nil |nil,
     /cons { .car car, .cdr foo cdr } |cons
-  > $list;
+  > list;
   foo
 `, { source: "llvm-product-recurse.k" }));
 const { llvm: productRecurseLLVM } = compileObjectToLLVM(productRecurseObject, {

package/backends/llvm/tests/test-open-product-misalignment.mjs

@@ -0,0 +1,140 @@
+import assert from "node:assert/strict";
+import { compileObjectBuffer, decodeObject } from "@fraczak/k/object.mjs";
+import { compileObjectToLLVM } from "../src/llvm.mjs";
+import { compileAndRunLLVM } from "../src/executable.mjs";
+import { Value } from "@fraczak/k/Value.mjs";
+
+console.log("==> LLVM Open Product Field Alignment Test");
+
+// Test expression from user:
+// len_ = ?X <{.list/nil if, .len then} .then,
+//             {.list/cons.cdr list, .len inc len} ?X len_ >;
+const src = `
+0 = {}|0;
+inc = |1;
+len = {()list, 0 len} len_;
+len_ = ?X <{.list/nil if, .len then} .then, {.list/cons.cdr list, .len inc len} ?X len_ >;
+len
+`;
+
+// Input schema for list:
+// cons is a closed product with fields 'car' (index 0) and
+// 'cdr' (index 1).
+const listPattern = [
+  ["closed-union", [["cons", 1], ["nil", 2]]],
+  ["closed-product", [["car", 3], ["cdr", 0]]],
+  ["closed-product", []],
+  ["any", []]
+];
+
+const obj = decodeObject(
+  compileObjectBuffer(src, { source: "open-product-misalignment.k" })
+);
+const { llvm } = compileObjectToLLVM(obj, { inputPattern: listPattern });
+
+// -----------------------------------------------------------------------
+// Test 1: Static IR Field Index for .cdr
+// -----------------------------------------------------------------------
+// In cons payload { car, cdr }, 'car' is index 0 (byte offset 0) and
+// 'cdr' is index 1 (byte offset 24 = 1 * K_FIELD_SIZE).
+// The specialized LLVM IR for projecting .cdr MUST access byte offset 24.
+// When misaligned, it accesses byte offset 0 (which is 'car').
+
+const cdrLabelMatch = llvm.match(
+  /(@k_label_\d+)\s*=\s*private unnamed_addr constant \[4 x i8\] c"cdr\\00"/
+);
+assert.ok(cdrLabelMatch, "LLVM IR should define label constant for 'cdr'");
+const cdrLabelGlobal = cdrLabelMatch[1];
+
+const lines = llvm.split("\n");
+let cdrFieldSlotOffset = null;
+let cdrDynamicFallbackEmitted = false;
+
+for (let i = 0; i < lines.length; i++) {
+  if (
+    lines[i].includes(cdrLabelGlobal) &&
+    lines[i].includes("getelementptr inbounds [4 x i8]")
+  ) {
+    const localLabelVar = lines[i].trim().split("=")[0].trim();
+    for (let j = i; j < Math.min(lines.length, i + 35); j++) {
+      if (
+        lines[j].includes("getelementptr inbounds i8, ptr %product_fields_ptr") &&
+        lines[j].includes(", i64 ")
+      ) {
+        const offsetMatch = lines[j].match(/, i64 (\d+)/);
+        if (offsetMatch) cdrFieldSlotOffset = Number(offsetMatch[1]);
+      }
+      if (
+        lines[j].includes("call ptr @k_product_get_n") &&
+        lines[j].includes(localLabelVar)
+      ) {
+        cdrDynamicFallbackEmitted = true;
+      }
+    }
+    if (cdrFieldSlotOffset !== null) break;
+  }
+}
+
+console.log(`- Detected .cdr field slot byte offset: ${cdrFieldSlotOffset} (expected 24)`);
+console.log(`- Detected dynamic fallback (@k_product_get_n) emitted for .cdr: ${cdrDynamicFallbackEmitted}`);
+
+// -----------------------------------------------------------------------
+// Test 2: Execution without dynamic fallback
+// -----------------------------------------------------------------------
+// When dynamic fallback (@k_product_get_n) is removed from the emitted
+// LLVM IR (forcing runtime to rely on the statically generated index),
+// the misalignment causes .cdr projection to load 'car' (a leaf),
+// causing the next iteration of len_ to fail because 'car' is not a list.
+const llvmNoFallback = llvm.replace(
+  /call ptr @k_product_get_n\([^)]+\)/g,
+  "bitcast ptr null to ptr"
+);
+
+// Build test list: [1, 2] = cons(car: 1, cdr: cons(car: 2, cdr: nil))
+const nil = Value.variant("nil", Value.product({}));
+const cons2 = Value.variant("cons", Value.product({
+  car: Value.variant("1", Value.product({})),
+  cdr: nil
+}));
+const cons1 = Value.variant("cons", Value.product({
+  car: Value.variant("1", Value.product({})),
+  cdr: cons2
+}));
+
+let runtimeStatusNoFallback = null;
+try {
+  const res = compileAndRunLLVM(llvmNoFallback, { input: cons1 });
+  runtimeStatusNoFallback = res.status;
+} catch (err) {
+  runtimeStatusNoFallback = err.status ?? 2;
+}
+
+console.log(`- Runtime exit status without fallback: ${runtimeStatusNoFallback} (expected 0)`);
+
+// -----------------------------------------------------------------------
+// Assertions to expose misalignment
+// -----------------------------------------------------------------------
+const exposeMode = process.argv.includes("--assert");
+
+if (exposeMode) {
+  assert.equal(
+    cdrFieldSlotOffset,
+    24,
+    `Misalignment: .cdr projected at byte offset ${cdrFieldSlotOffset} (car) instead of 24 (cdr)`
+  );
+  assert.equal(
+    cdrDynamicFallbackEmitted,
+    false,
+    "Dynamic fallback: LLVM emits @k_product_get_n fallback to mask misalignment"
+  );
+  assert.equal(
+    runtimeStatusNoFallback,
+    0,
+    `Runtime failure: status ${runtimeStatusNoFallback} when relying on static index`
+  );
+} else {
+  console.log("\nSummary:");
+  console.log(`  Offset misalignment: ${cdrFieldSlotOffset === 24 ? "ALIGNED" : "MISALIGNED (offset 0 instead of 24)"}`);
+  console.log(`  Dynamic fallback used: ${cdrDynamicFallbackEmitted ? "YES (papers over bug at runtime)" : "NO"}`);
+  console.log(`  Status without fallback: ${runtimeStatusNoFallback === 0 ? "OK" : "FAILS (status " + runtimeStatusNoFallback + ")"}`);
+}

package/backends/wasm/demo_ieee.mjs

@@ -184,8 +184,7 @@ function readArenaValue(exports, ptr, pattern, patternNodeId) {
 
     for (let i = 0; i < N; i++) {
       const edge = patternNode.edges[i];
-      const offsetVal = view.getUint32(ptr + 8 + 4 * i, true);
-      const childPtr = view.getUint32(ptr + offsetVal, true);
+      const childPtr = view.getUint32(ptr + 8 + 4 * N + 4 * i, true);
       productObj[edge.label] = readArenaValue(exports, childPtr, pattern, edge.target);
     }
     return Value.product(productObj, pattern);
@@ -231,7 +230,7 @@ function writeValueToArena(value, pattern, patternNodeId) {
 
     for (let i = 0; i < N; i++) {
       const offsetVal = 8 + 4 * N + 4 * i;
-      view.setUint32(ptr + 8 + 4 * i, offsetVal, true);
+      view.setUint32(ptr + 8 + 4 * i, getTagId(keys[i]), true);
       view.setUint32(ptr + offsetVal, childPtrs[i], true);
     }
     return ptr;

package/backends/wasm/runtime.wat

@@ -398,6 +398,14 @@
             i32.ge_u
             br_if $break_prod
 
+            ;; Copy field tagId at offset 8 + 4*i
+            local.get $dest
+            i32.const 8
+            local.get $i
+            i32.const 4
+            i32.mul
+            i32.add
+            i32.add
             local.get $curr
             i32.const 8
             local.get $i
@@ -406,17 +414,19 @@
             i32.add
             i32.add
             i32.load
-            local.set $offsetVal
+            i32.store
 
-            local.get $dest
+            ;; Value slot offset is 8 + 4*N + 4*i
             i32.const 8
-            local.get $i
+            local.get $N
             i32.const 4
             i32.mul
             i32.add
+            local.get $i
+            i32.const 4
+            i32.mul
             i32.add
-            local.get $offsetVal
-            i32.store
+            local.set $offsetVal
 
             local.get $curr
             local.get $offsetVal
@@ -472,4 +482,146 @@
     i32.add
     global.set $arena_free
   )
+
+  ;; Lookup product field by tagId with predictedIndex hint
+  (func $product_get (export "product_get") (param $prod i32) (param $targetTagId i32) (param $predictedIndex i32) (result i32)
+    (local $size i32)
+    (local $N i32)
+    (local $i i32)
+
+    ;; 1. Null check
+    local.get $prod
+    i32.eqz
+    if
+      i32.const 0
+      return
+    end
+
+    ;; 2. Read totalSize at prod + 0
+    local.get $prod
+    i32.load offset=0
+    local.set $size
+
+    ;; 3. Validate product header (not a variant and size >= 8)
+    local.get $size
+    i32.const 12
+    i32.eq
+    if
+      i32.const 0
+      return
+    end
+    local.get $size
+    i32.const 8
+    i32.lt_u
+    if
+      i32.const 0
+      return
+    end
+
+    ;; 4. Read field count N at prod + 4
+    local.get $prod
+    i32.load offset=4
+    local.set $N
+
+    ;; 5. Validate size == 8 + 8 * N
+    local.get $size
+    i32.const 8
+    local.get $N
+    i32.const 8
+    i32.mul
+    i32.add
+    i32.ne
+    if
+      i32.const 0
+      return
+    end
+
+    ;; 6. Fast path: check predictedIndex if in range [0, N)
+    local.get $predictedIndex
+    i32.const 0
+    i32.ge_s
+    if
+      local.get $predictedIndex
+      local.get $N
+      i32.lt_u
+      if
+        ;; Load tagId at prod + 8 + 4 * predictedIndex
+        local.get $prod
+        i32.const 8
+        local.get $predictedIndex
+        i32.const 4
+        i32.mul
+        i32.add
+        i32.add
+        i32.load
+        local.get $targetTagId
+        i32.eq
+        if
+          ;; Match! Return value at prod + 8 + 4*N + 4*predictedIndex
+          local.get $prod
+          i32.const 8
+          local.get $N
+          i32.const 4
+          i32.mul
+          i32.add
+          local.get $predictedIndex
+          i32.const 4
+          i32.mul
+          i32.add
+          i32.add
+          i32.load
+          return
+        end
+      end
+    end
+
+    ;; 7. Scan path: check i = 0 .. N-1
+    i32.const 0
+    local.set $i
+    (block $break_scan
+      (loop $loop_scan
+        local.get $i
+        local.get $N
+        i32.ge_u
+        br_if $break_scan
+
+        ;; Load tagId at prod + 8 + 4 * i
+        local.get $prod
+        i32.const 8
+        local.get $i
+        i32.const 4
+        i32.mul
+        i32.add
+        i32.add
+        i32.load
+        local.get $targetTagId
+        i32.eq
+        if
+          ;; Match! Return value at prod + 8 + 4*N + 4*i
+          local.get $prod
+          i32.const 8
+          local.get $N
+          i32.const 4
+          i32.mul
+          i32.add
+          local.get $i
+          i32.const 4
+          i32.mul
+          i32.add
+          i32.add
+          i32.load
+          return
+        end
+
+        local.get $i
+        i32.const 1
+        i32.add
+        local.set $i
+        br $loop_scan
+      )
+    )
+
+    ;; 8. Not found: return 0
+    i32.const 0
+  )
 )

package/backends/wasm/src/kvm2wasm.mjs

@@ -108,22 +108,28 @@ export function lowerToWasm(relDef, name, options = {}) {
   const getPattern = (rName, inputMap = {}) => registerPatterns.get(mappedReg(rName, inputMap));
 
   const getProductEdges = (inst, inputMap) => {
-    if (typePatternGraph) {
-      const inputPatternId = inst.exp.patterns[0];
-      const inputPatternNodeId = typePatternGraph.find(inputPatternId);
-      const inputPropertyList = patternToPropertyList(exportPatternGraph(typePatternGraph, inputPatternNodeId));
-      return inputPropertyList[0][1];
-    }
-
     const inputPropertyList = getPattern(inst.src, inputMap);
-    const inputRoot = inputPropertyList?.[0];
-    if (!Array.isArray(inputRoot) || !Array.isArray(inputRoot[1])) {
-      throw new Error(`Wasm compiler: cannot infer input pattern for field '${inst.label}'`);
+    if (Array.isArray(inputPropertyList) && inputPropertyList.length > 0) {
+      const inputRoot = inputPropertyList[0];
+      if ((inputRoot[0] === "open-product" || inputRoot[0] === "closed-product") && Array.isArray(inputRoot[1])) {
+        return inputRoot[1];
+      }
     }
-    if (inputRoot[0] !== "open-product" && inputRoot[0] !== "closed-product") {
-      throw new Error(`Wasm compiler: field '${inst.label}' requires a product input pattern`);
+
+    if (typePatternGraph && inst.exp?.patterns?.[0] != null) {
+      try {
+        const inputPatternId = inst.exp.patterns[0];
+        const inputPatternNodeId = typePatternGraph.find(inputPatternId);
+        const inputPropertyList = patternToPropertyList(exportPatternGraph(typePatternGraph, inputPatternNodeId));
+        if (Array.isArray(inputPropertyList?.[0]?.[1])) {
+          return inputPropertyList[0][1];
+        }
+      } catch {
+        // Ignore fallback errors
+      }
     }
-    return inputRoot[1];
+
+    return null;
   };
 
   const registers = new Set();
@@ -205,14 +211,12 @@ export function lowerToWasm(relDef, name, options = {}) {
     const lines = [];
     for (const field of inputProductFields) {
       const fieldIndex = inputProductEdges.findIndex(([label]) => label === field.label);
+      const tagId = getTagId(field.label);
       lines.push(`    ;; cache input field ${field.label} in $${field.local}`);
       lines.push(`    local.get $in`);
-      lines.push(`    local.get $in`);
-      lines.push(`    i32.const ${8 + 4 * fieldIndex}`);
-      lines.push(`    i32.add`);
-      lines.push(`    i32.load`);
-      lines.push(`    i32.add`);
-      lines.push(`    i32.load`);
+      lines.push(`    i32.const ${tagId}`);
+      lines.push(`    i32.const ${fieldIndex}`);
+      lines.push(`    call $product_get`);
       lines.push(`    local.set $${field.local}`);
     }
     return lines.join("\n");
@@ -231,9 +235,10 @@ export function lowerToWasm(relDef, name, options = {}) {
     lines.push(`    i32.const ${inputProductFields.length}`);
     lines.push(`    i32.store offset=4`);
     for (const field of inputProductFields) {
+      const tagId = getTagId(field.label);
       const offsetVal = 8 + 4 * inputProductFields.length + 4 * field.index;
       lines.push(`    local.get $${dest}`);
-      lines.push(`    i32.const ${offsetVal}`);
+      lines.push(`    i32.const ${tagId}`);
       lines.push(`    i32.store offset=${8 + 4 * field.index}`);
       lines.push(`    local.get $${dest}`);
       lines.push(`    local.get $${field.local}`);
@@ -314,14 +319,24 @@ export function lowerToWasm(relDef, name, options = {}) {
             break;
           }
 
-          const edges = getProductEdges(inst, inputMap);
-          const fieldIndex = edges.findIndex(([label]) => label === inst.label);
-          if (fieldIndex === -1) {
-            throw new Error(`Wasm compiler: field '${inst.label}' not found in input pattern`);
+          let predictedIndex = -1;
+          try {
+            const edges = getProductEdges(inst, inputMap);
+            if (Array.isArray(edges)) {
+              predictedIndex = edges.findIndex(([label]) => label === inst.label);
+            }
+          } catch {
+            predictedIndex = -1;
           }
+          const tagId = getTagId(inst.label);
 
-          lines.push(`    ;; project_field ${inst.label} (index ${fieldIndex}) from $${src} to $${dest}`);
+          lines.push(`    ;; project_field ${inst.label} (tagId ${tagId}, hint ${predictedIndex}) from $${src} to $${dest}`);
           lines.push(`    local.get $${src}`);
+          lines.push(`    i32.const ${tagId}`);
+          lines.push(`    i32.const ${predictedIndex}`);
+          lines.push(`    call $product_get`);
+          lines.push(`    local.set $${dest}`);
+          lines.push(`    local.get $${dest}`);
           lines.push(`    i32.eqz`);
           lines.push(`    if`);
           if (failTarget) {
@@ -332,14 +347,6 @@ export function lowerToWasm(relDef, name, options = {}) {
             lines.push(`      return`);
           }
           lines.push(`    end`);
-          lines.push(`    local.get $${src}`);
-          lines.push(`    local.get $${src}`);
-          lines.push(`    i32.const ${8 + 4 * fieldIndex}`);
-          lines.push(`    i32.add`);
-          lines.push(`    i32.load`);
-          lines.push(`    i32.add`);
-          lines.push(`    i32.load`);
-          lines.push(`    local.set $${dest}`);
           setPattern(dest, inst.pattern);
           break;
         }
@@ -443,11 +450,13 @@ export function lowerToWasm(relDef, name, options = {}) {
           lines.push(`    i32.store offset=4`);
 
           for (let i = 0; i < N; i++) {
+            const branch = sortedBranches[i];
+            const tagId = getTagId(branch.label);
             const offsetVal = 8 + 4 * N + 4 * i;
             const fieldTmp = `${dest}_f${i}`;
 
             lines.push(`    local.get $${dest}`);
-            lines.push(`    i32.const ${offsetVal}`);
+            lines.push(`    i32.const ${tagId}`);
             lines.push(`    i32.store offset=${8 + 4 * i}`);
 
             lines.push(`    local.get $${dest}`);
@@ -501,6 +510,20 @@ export function lowerToWasm(relDef, name, options = {}) {
           }
           lines.push(`    end`);
 
+          lines.push(`    local.get $${src}`);
+          lines.push(`    i32.load offset=0`);
+          lines.push(`    i32.const 12`);
+          lines.push(`    i32.ne`);
+          lines.push(`    if`);
+          if (failTarget) {
+            lines.push(`      br ${failTarget}`);
+          } else {
+            lines.push(`      i32.const 0`);
+            lines.push(`      i32.const 0`);
+            lines.push(`      return`);
+          }
+          lines.push(`    end`);
+
           lines.push(`    local.get $${src}`);
           lines.push(`    i32.load offset=4`);
           lines.push(`    i32.const ${tagId}`);