@fraczak/k 6.10.6 → 7.0.1

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}`);

package/backends/wasm/src/wasm.mjs

@@ -13,7 +13,8 @@ import {
   patternToPropertyList,
   propertyListToPattern,
   Value,
-  specializeKVM
+  specializeKVM,
+  specializeObjectRelations
 } from "@fraczak/k/backend-api.mjs";
 import { intersectPropertyListPatterns } from "@fraczak/k/codecs/runtime/codec.mjs";
 import { propertyListToFilter } from "@fraczak/k/codecs/runtime/show-value.mjs";
@@ -304,7 +305,8 @@ function compileModule(mainRelName, defs) {
 
     kvmFunc.name = nameMap.get(name) || cleanName(name);
     cleanCallNames(kvmFunc.body, nameMap);
-    wats.push(lowerToWasm(kvmFunc, kvmFunc.name));
+    const wasmText = lowerToWasm(kvmFunc, kvmFunc.name);
+    wats.push(wasmText);
   }
 
   return {
@@ -611,8 +613,10 @@ async function compileWasmArtifactFromObject(object, { entry = null, inputEnvelo
     if (!mainRel) throw new Error(`No main relation (${mainRelName}) defined in object`);
     const inputPattern = getPatternPropertyList(mainRel.typePatternGraph, mainRel.def.patterns[0]);
     const outputPattern = getPatternPropertyList(mainRel.typePatternGraph, mainRel.def.patterns[1]);
-    if (classifyTyping(inputPattern, outputPattern).program === "polymorphic") {
-      defs = annotateObjectWithInputFilter(object, mainRelName, inputPattern, inputEnvelopePattern);
+    const typing = classifyTyping(inputPattern, outputPattern);
+    if (typing.program === "polymorphic") {
+      const specialized = specializeObjectRelations(object, mainRelName, inputEnvelopePattern);
+      defs = { rels: specialized.rels, relAlias: specialized.relAlias, compileStats: specialized.compileStats };
       typingMode = "specialized";
     }
   }
@@ -635,7 +639,9 @@ async function compileWasmArtifact(
     const inputPattern = getPatternPropertyList(mainRel.typePatternGraph, mainRel.def.patterns[0]);
     const outputPattern = getPatternPropertyList(mainRel.typePatternGraph, mainRel.def.patterns[1]);
     if (classifyTyping(inputPattern, outputPattern).program === "polymorphic") {
-      defs = annotateSourceWithInputFilter(fullSource, inputPattern, inputEnvelopePattern, options);
+      const obj = { format: "k-object", rels: defs.rels, relAlias: defs.relAlias, compileStats: defs.compileStats, main: "__main__" };
+      const specialized = specializeObjectRelations(obj, "__main__", inputEnvelopePattern);
+      defs = { rels: specialized.rels, relAlias: specialized.relAlias, compileStats: specialized.compileStats };
       typingMode = "specialized";
     }
   }
@@ -723,20 +729,18 @@ function readArenaValue(exports, ptr, pattern, patternNodeId, patternPropertyLis
 
     if (patternNode.kind === NODE_KIND.OPEN_PRODUCT || patternNode.kind === NODE_KIND.CLOSED_PRODUCT) {
       const N = view.getUint32(frame.ptr + 4, true);
-      if (N !== patternNode.edges.length) {
-        throw new Error(`Cannot decode product pointer ${frame.ptr}: arena field count ${N} does not match output pattern`);
-      }
       const product = {};
       frame.assign(Value.product(product, patternForNode(patternPropertyList, frame.patternNodeId)));
       for (let i = N - 1; i >= 0; i--) {
-        const edge = patternNode.edges[i];
-        const offset = view.getUint32(frame.ptr + 8 + 4 * i, true);
-        const childPtr = view.getUint32(frame.ptr + offset, true);
+        const tagId = view.getUint32(frame.ptr + 8 + 4 * i, true);
+        const label = tags.getTag(tagId) || patternNode.edges[i]?.label;
+        const edge = patternNode.edges.find((candidate) => candidate.label === label);
+        const childPtr = view.getUint32(frame.ptr + 8 + 4 * N + 4 * i, true);
         stack.push({
           ptr: wasmPtr(childPtr),
-          patternNodeId: edge.target,
+          patternNodeId: edge?.target ?? null,
           assign(value) {
-            product[edge.label] = value;
+            product[label] = value;
           }
         });
       }
@@ -787,8 +791,9 @@ function writeValueToArena(exports, value, pattern, patternNodeId, arenaValues,
       view.setUint32(frame.ptr, 8 + 8 * N, true);
       view.setUint32(frame.ptr + 4, N, true);
       for (let i = 0; i < N; i++) {
+        const tagId = tags.getId(frame.fields[i].label);
         const offset = 8 + 4 * N + 4 * i;
-        view.setUint32(frame.ptr + 8 + 4 * i, offset, true);
+        view.setUint32(frame.ptr + 8 + 4 * i, tagId, true);
         view.setUint32(frame.ptr + offset, frame.childPtrs[i], true);
       }
       arenaValues.set(frame.ptr, valueWithPatternNode(frame.value, patternPropertyList, frame.patternNodeId));
@@ -820,6 +825,13 @@ function writeValueToArena(exports, value, pattern, patternNodeId, arenaValues,
         ? Object.keys(frame.value.product)
             .sort()
             .map((label) => ({ label, patternNodeId: frame.patternNodeId }))
+        : isOpenProduct
+        ? Object.keys(frame.value.product)
+            .sort()
+            .map((label) => {
+              const edge = patternNode.edges.find((e) => e.label === label);
+              return { label, patternNodeId: edge ? edge.target : null };
+            })
         : patternNode.edges.map((edge) => ({ label: edge.label, patternNodeId: edge.target }));
       const fieldLabels = new Set(fields.map(({ label }) => label));
       if (isClosedProduct) {
@@ -829,9 +841,17 @@ function writeValueToArena(exports, value, pattern, patternNodeId, arenaValues,
           }
         }
       }
-      for (const { label } of fields) {
-        if (!Object.hasOwn(frame.value.product, label)) {
-          throw new Error(`Product field '${label}' is required by input pattern node ${frame.patternNodeId}`);
+      if (isOpenProduct) {
+        for (const edge of patternNode.edges) {
+          if (!Object.hasOwn(frame.value.product, edge.label)) {
+            throw new Error(`Product field '${edge.label}' is required by input pattern node ${frame.patternNodeId}`);
+          }
+        }
+      } else {
+        for (const { label } of fields) {
+          if (!Object.hasOwn(frame.value.product, label)) {
+            throw new Error(`Product field '${label}' is required by input pattern node ${frame.patternNodeId}`);
+          }
         }
       }
 
@@ -841,6 +861,7 @@ function writeValueToArena(exports, value, pattern, patternNodeId, arenaValues,
         finishProduct: true,
         value: frame.value,
         patternNodeId: frame.patternNodeId,
+        fields,
         ptr,
         childPtrs,
         assign: frame.assign

package/backends/wasm/tests/perf-support.mjs

@@ -200,8 +200,7 @@ export function readArenaValue(exports, rootPtr, pattern, rootPatternNodeId, pat
 
       for (let i = N - 1; i >= 0; 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);
         const label = edge.label;
         stack.push({
           ptr: childPtr,
@@ -253,14 +252,14 @@ export function writeValueToArena(exports, rootValue, pattern, rootPatternNodeId
     const frame = stack.pop();
 
     if (frame.finishProduct) {
-      const { ptr, totalSize, N, childPtrs, assign } = frame;
+      const { ptr, totalSize, N, keys, childPtrs, assign } = frame;
       const view = new DataView(exports.memory.buffer);
       view.setUint32(ptr, totalSize, true);
       view.setUint32(ptr + 4, N, true);
 
       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);
       }
       assign(ptr);
@@ -294,6 +293,7 @@ export function writeValueToArena(exports, rootValue, pattern, rootPatternNodeId
         ptr,
         totalSize,
         N,
+        keys,
         childPtrs,
         assign
       });