@fraczak/k 7.0.0 → 7.0.2

package/backends/llvm/runtime/krt.c

@@ -1489,6 +1489,39 @@ k_value *k_read_wire(FILE *in, k_rt *rt) {
   return value;
 }
 
+static int is_union_kind(int kind) {
+  return kind == KP_OPEN_UNION || kind == KP_CLOSED_UNION;
+}
+
+static int is_product_kind(int kind) {
+  return kind == KP_OPEN_PRODUCT || kind == KP_CLOSED_PRODUCT;
+}
+
+int k_pattern_compatible(k_pattern *a, k_pattern *b) {
+  if (a == b) return 1;
+  if (a == NULL || b == NULL) return 0;
+  if (a->node_count != b->node_count) return 0;
+  for (size_t i = 0; i < a->node_count; i++) {
+    k_pattern_node *left = &a->nodes[i];
+    k_pattern_node *right = &b->nodes[i];
+    if (left->kind != right->kind) {
+      if (!(is_union_kind(left->kind) && is_union_kind(right->kind)) &&
+          !(is_product_kind(left->kind) && is_product_kind(right->kind))) {
+        return 0;
+      }
+    }
+    if (left->edge_count != right->edge_count) return 0;
+    for (size_t j = 0; j < left->edge_count; j++) {
+      if (left->edges[j].target != right->edges[j].target) return 0;
+      if (!bytes_equal(left->edges[j].label, left->edges[j].label_length,
+                       right->edges[j].label, right->edges[j].label_length)) {
+        return 0;
+      }
+    }
+  }
+  return 1;
+}
+
 int k_pattern_equal(k_pattern *a, k_pattern *b) {
   if (a == b) return 1;
   if (a == NULL || b == NULL) return 0;

package/backends/llvm/runtime/krt.h

@@ -104,6 +104,7 @@ k_wire_input k_read_wire_envelope(FILE *in, k_rt *rt);
 k_wire_input k_decode_wire_envelope(const unsigned char *bytes, size_t length, k_rt *rt);
 void k_wire_input_free(k_wire_input input);
 int k_pattern_equal(k_pattern *a, k_pattern *b);
+int k_pattern_compatible(k_pattern *a, k_pattern *b);
 k_wire_prefix k_wire_prefix_for_pattern(k_pattern *pattern);
 void k_wire_prefix_free(k_wire_prefix prefix);
 k_value *k_decode_wire_value_with_prefix(const unsigned char *bytes, size_t length, k_wire_prefix *prefix, k_pattern *pattern, k_rt *rt);

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/executable.mjs

@@ -292,7 +292,7 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "    k_wire_input_free(input);",
     "    return 2;",
     "  }",
-    "  if (!k_pattern_equal(input.pattern, &compiled_input_pattern)) {",
+    "  if (!k_pattern_compatible(input.pattern, &compiled_input_pattern)) {",
     "    k_wire_input_free(input);",
     "    return 5;",
     "  }",
@@ -350,7 +350,7 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "    k_value *in_val = k_decode_wire_value_with_prefix(payload, length, &input_prefix, &compiled_input_pattern, rt);",
     "    if (in_val == 0) {",
     "      k_wire_input envelope = k_decode_wire_envelope(payload, length, rt);",
-    "      if (envelope.value != 0 && envelope.pattern != 0 && k_pattern_equal(envelope.pattern, &compiled_input_pattern)) {",
+    "      if (envelope.value != 0 && envelope.pattern != 0 && k_pattern_compatible(envelope.pattern, &compiled_input_pattern)) {",
     "        in_val = envelope.value;",
     "      } else {",
     "        k_wire_input_free(envelope);",
@@ -437,7 +437,7 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "    k_rt_free(input_rt);",
     "    return 2;",
     "  }",
-    "  if (!k_pattern_equal(input.pattern, &compiled_input_pattern)) {",
+    "  if (!k_pattern_compatible(input.pattern, &compiled_input_pattern)) {",
     "    k_wire_input_free(input);",
     "    k_rt_free(run_rt);",
     "    k_rt_free(input_rt);",
@@ -478,7 +478,7 @@ export function stdioDriverSource({ inputPattern = null, outputPattern = null }
     "    k_rt_free(rt);",
     "    return 2;",
     "  }",
-    "  if (!k_pattern_equal(input.pattern, &compiled_input_pattern)) {",
+    "  if (!k_pattern_compatible(input.pattern, &compiled_input_pattern)) {",
     "    k_wire_input_free(input);",
     "    k_wire_prefix_free(output_prefix);",
     "    k_rt_free(rt);",

package/backends/llvm/src/kvm2llvm.mjs

@@ -35,15 +35,17 @@ function alignArenaSize(size) {
 }
 
 function cStringBytes(text) {
-  return [...Buffer.from(text, "utf8"), 0]
-    .map((byte) => {
-      if (byte === 10) return "\\0A";
-      if (byte === 34) return "\\22";
-      if (byte === 92) return "\\5C";
-      if (byte >= 32 && byte <= 126) return String.fromCharCode(byte);
-      return `\\${byte.toString(16).padStart(2, "0").toUpperCase()}`;
-    })
-    .join("");
+  const buf = Buffer.from(text, "utf8");
+  let out = "";
+  for (let i = 0; i < buf.length; i++) {
+    const byte = buf[i];
+    if (byte === 10) out += "\\0A";
+    else if (byte === 34) out += "\\22";
+    else if (byte === 92) out += "\\5C";
+    else if (byte >= 32 && byte <= 126) out += String.fromCharCode(byte);
+    else out += `\\${byte.toString(16).padStart(2, "0").toUpperCase()}`;
+  }
+  return out + "\\00";
 }
 
 export function runtimeDeclarations() {
@@ -551,8 +553,7 @@ export function compileKVMModuleToLLVM(entryName, kvmProgram, options = {}) {
   const payload = JSON.stringify({
     format: ARTIFACT_FORMAT,
     version: ARTIFACT_VERSION,
-    relation,
-    kvm: kvmProgram
+    relation
   });
   const payloadBytes = Buffer.byteLength(payload, "utf8") + 1;
   const symbol = llvmIdentifier(options.symbol || relation);
@@ -678,7 +679,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})`);
@@ -815,11 +816,32 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
           storeI64At(ctx, product, K_VALUE_PRODUCT_CAPACITY_OFFSET, N);
           storePtrAt(ctx, product, K_VALUE_PRODUCT_FIELDS_OFFSET, fields);
 
-          const sortedFields = [...fieldValues].sort((a, b) => {
-            if (a.label < b.label) return -1;
-            if (a.label > b.label) return 1;
-            return 0;
-          });
+          let sortedFields;
+          if (Array.isArray(inst.pattern) && inst.pattern.length > 0) {
+            const root = inst.pattern[0];
+            if (
+              (root[0] === "open-product" ||
+                root[0] === "closed-product") &&
+              Array.isArray(root[1])
+            ) {
+              const order = new Map(root[1].map(([l], i) => [l, i]));
+              sortedFields = [...fieldValues].sort((a, b) => {
+                const aI = order.has(a.label)
+                  ? order.get(a.label)
+                  : 999999;
+                const bI = order.has(b.label)
+                  ? order.get(b.label)
+                  : 999999;
+                if (aI !== bI) return aI - bI;
+                return a.label.localeCompare(b.label);
+              });
+            }
+          }
+          if (!sortedFields) {
+            sortedFields = [...fieldValues].sort((a, b) =>
+              a.label.localeCompare(b.label)
+            );
+          }
 
           for (let sIdx = 0; sIdx < N; sIdx++) {
             const { label: fLabel, val: fVal } = sortedFields[sIdx];
@@ -831,13 +853,14 @@ 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": {
           const uInput = getReg(inst.src);
 
           if (!isTopLevel) {
-            // Nested union: synthesize a helper function @k_union_expr_${index}
+            // Nested union: synthesize helper @k_union_expr_${index}
             const exprIndex = moduleCtx.unionExprIndex++;
             const exprName = `@k_union_expr_${exprIndex}`;
             const exprFunc = {
@@ -862,7 +885,7 @@ function lowerKVMFunction(kvmFunc, symbol, funcName, moduleCtx, linkage = "", op
             break;
           }
 
-          // Top-level union: synthesize arm functions @k_union_arm_${index}
+          // Top-level union: synthesize arms @k_union_arm_${index}
           const mark = lowerRtMark(ctx);
           const unionDone = ctx.blockName("union_done");
           const N = inst.branches.length;

package/backends/llvm/src/llvm.mjs

@@ -45,15 +45,17 @@ function alignArenaSize(size) {
 }
 
 function cStringBytes(text) {
-  return [...Buffer.from(text, "utf8"), 0]
-    .map((byte) => {
-      if (byte === 10) return "\\0A";
-      if (byte === 34) return "\\22";
-      if (byte === 92) return "\\5C";
-      if (byte >= 32 && byte <= 126) return String.fromCharCode(byte);
-      return `\\${byte.toString(16).padStart(2, "0").toUpperCase()}`;
-    })
-    .join("");
+  const buf = Buffer.from(text, "utf8");
+  let out = "";
+  for (let i = 0; i < buf.length; i++) {
+    const byte = buf[i];
+    if (byte === 10) out += "\\0A";
+    else if (byte === 34) out += "\\22";
+    else if (byte === 92) out += "\\5C";
+    else if (byte >= 32 && byte <= 126) out += String.fromCharCode(byte);
+    else out += `\\${byte.toString(16).padStart(2, "0").toUpperCase()}`;
+  }
+  return out + "\\00";
 }
 
 function readPattern(inputPattern) {
@@ -986,8 +988,7 @@ export function emitLLVMModule(input, options = {}) {
   const payload = JSON.stringify({
     format: ARTIFACT_FORMAT,
     version: ARTIFACT_VERSION,
-    relation,
-    kir
+    relation
   });
   const payloadBytes = Buffer.byteLength(payload, "utf8") + 1;
   const symbol = llvmIdentifier(options.symbol || relation);
@@ -1011,8 +1012,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 +1020,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/perf-support.mjs

@@ -216,7 +216,7 @@ export function runExecutableMainBench(exePath, inputWire, calls) {
         reject(new Error(`${exePath} --bench-main failed with status ${status}\n${text}`.trim()));
         return;
       }
-      const match = text.match(/K_(?:LLVM|ARM64)_BENCH_MAIN calls=(\d+) total_ns=(\d+) per_call_ns=([0-9.]+)/);
+      const match = text.match(/K_LLVM_BENCH_MAIN calls=(\d+) total_ns=(\d+) per_call_ns=([0-9.]+)/);
       if (!match) {
         reject(new Error(`${exePath} --bench-main did not report timing\n${text}`.trim()));
         return;
@@ -599,61 +599,7 @@ export function llvmLaneName() {
     : "LLVM Executable (persistent)";
 }
 
-export function arm64LaneName(optLevel = "-O2") {
-  const mode = process.env.ARM64_SPAWN_PER_CALL === "1"
-    ? "spawn/call"
-    : (process.env.ARM64_PIPELINE === "1" ? "persistent, pipelined" : "persistent");
-  return `Linux ARM64 ${optLevel} (${mode})`;
-}
-
-export function createARM64Runner(testSuite) {
-  const arm64Cases = testSuite.filter(tc => tc.arm64?.status === "ok");
-  if (process.env.ARM64_SPAWN_PER_CALL === "1") {
-    return {
-      run(iterations) {
-        if (arm64Cases.length === 0) return null;
-        return runTimedIterationsAsync(iterations, async () => {
-          for (const tc of arm64Cases) {
-            await runExecutable(tc.arm64.exePath, tc.inputWire);
-          }
-        });
-      },
-      close() {}
-    };
-  }
 
-  const servers = new Map();
-  function serverFor(exePath) {
-    let server = servers.get(exePath);
-    if (server == null) {
-      server = new PersistentExecutable(exePath);
-      servers.set(exePath, server);
-    }
-    return server;
-  }
-
-  return {
-    async run(iterations) {
-      if (arm64Cases.length === 0) return null;
-      return runTimedIterationsAsync(iterations, async () => {
-        if (process.env.ARM64_PIPELINE === "1") {
-          const pending = [];
-          for (const tc of arm64Cases) {
-            pending.push(serverFor(tc.arm64.exePath).request(tc.inputWire));
-          }
-          await Promise.all(pending);
-          return;
-        }
-        for (const tc of arm64Cases) {
-          await serverFor(tc.arm64.exePath).request(tc.inputWire);
-        }
-      });
-    },
-    close() {
-      for (const server of servers.values()) server.close();
-    }
-  };
-}
 
 export function average(times) {
   return times.reduce((sum, time) => sum + time, 0) / times.length;

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;