// Run-fidelity corpus: a subset program that transpiles must not just compile
// to Zig (conformance.test.ts pins that) — it must RUN with byte-identical
// observable behavior to the same source executing as plain TypeScript. Each
// case here runs twice from one source: the node side imports the module
// directly (type stripping; the A/B shape the spike harness proved), the
// native side runs the emitted Zig against the rt kernel, and the two
// transcripts are compared byte for byte.
//
// Canonical value text (both drivers emit exactly this grammar):
//   n:<16 hex digits>   a number, as its f64 bit pattern (any NaN -> n:nan) —
//                       bit-comparing sidesteps float formatting and makes
//                       -0, precision, and rounding corners first-class
//   b:true / b:false    a boolean
//   null                a null
//   x:<hex bytes>       bytes, strings, and literal-union members (tag name)
//   [v,v,...]           a number array, elementwise
//
// The corpus leans on the JS corners where naive Zig disagrees: NaN through
// comparisons and Math.min/max, signed zeros, Math.round's half-toward-+inf,
// ToInt32 bitwise wrapping, float division/remainder by zero, and null-safe
// optional comparisons. Both halves skip when no zig toolchain is on PATH.

import test from "node:test";
import assert from "node:assert/strict";
import { execFileSync, spawnSync } from "node:child_process";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { transpile, transpileFiles } from "./helpers.ts";

const pkg = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
const hasZig = spawnSync("zig", ["version"], { stdio: "ignore" }).status === 0;

type Arg =
  | { readonly t: "i"; readonly v: number }
  | { readonly t: "f"; readonly v: number | "nan" | "inf" | "-inf" | "-0" }
  | { readonly t: "b"; readonly v: boolean }
  | { readonly t: "null" }
  | { readonly t: "bytes"; readonly v: readonly number[] }
  | { readonly t: "nums"; readonly v: readonly (number | "nan" | "-0")[] }
  | { readonly t: "tag"; readonly v: string }
  | { readonly t: "str"; readonly v: string };

interface Call {
  readonly fn: string;
  readonly args: readonly Arg[];
}

interface RunCase {
  readonly name: string;
  readonly src: string;
  /// Additional modules beside the entry (multi-file cores): filename ->
  /// source. `src` stays the entry (core.ts); every file lands in the
  /// case's own directory, so relative imports spell "./name.ts".
  readonly files?: Record<string, string>;
  /// Primitive probe calls, spelled identically for both drivers.
  readonly calls?: readonly Call[];
  /// Custom driver bodies for shapes the call vocabulary cannot spell
  /// (dispatch loops over Msg unions, the Cmd effects channel). The node
  /// body sees `mod` and pushes formatted lines through `line(tag, value)`;
  /// the zig body sees `m` and the `row(tag, value)` helper. Both must emit
  /// the same tags in the same order.
  readonly node?: string;
  readonly zig?: string;
  /// Transpile options for the native side (kernel capacities — node has a
  /// GC and no arenas, so the same source runs unchanged there; the
  /// transcripts must STILL match byte for byte).
  readonly options?: import("../src/transpile.ts").TranspileOptions;
}

const i = (v: number): Arg => ({ t: "i", v });
const f = (v: number | "nan" | "inf" | "-inf" | "-0"): Arg => ({ t: "f", v });

const runCorpus: RunCase[] = [
  {
    name: "optional numeric comparisons are null-safe (null equals only null)",
    src: `
export function isZero(cls: number | null): boolean {
  return cls === 0;
}
export function nonZero(cls: number | null): boolean {
  return cls !== 0;
}
export function label(cls: number | null): number {
  return cls === 0 ? 1 : cls !== 0 ? 2 : 3;
}
export function gate(cls: number | null, flag: boolean): boolean {
  return flag && cls === 1;
}
export function either(a: number | null, b: number | null): boolean {
  return a === b;
}
`,
    calls: [
      { fn: "isZero", args: [{ t: "null" }] },
      { fn: "isZero", args: [i(0)] },
      { fn: "isZero", args: [i(1)] },
      { fn: "nonZero", args: [{ t: "null" }] },
      { fn: "nonZero", args: [i(0)] },
      { fn: "nonZero", args: [i(5)] },
      { fn: "label", args: [{ t: "null" }] },
      { fn: "label", args: [i(0)] },
      { fn: "label", args: [i(9)] },
      { fn: "gate", args: [{ t: "null" }, { t: "b", v: true }] },
      { fn: "gate", args: [i(1), { t: "b", v: true }] },
      { fn: "gate", args: [{ t: "null" }, { t: "b", v: false }] },
      { fn: "either", args: [{ t: "null" }, { t: "null" }] },
      { fn: "either", args: [{ t: "null" }, f(2)] },
      { fn: "either", args: [f(2), f(2)] },
      { fn: "either", args: [f(2), f(3)] },
    ],
  },
  {
    name: "null flows: orelse fusion, nullish fallback, optional guard in a switch arm",
    src: `
export type Msg = { readonly kind: "set"; readonly v: number } | { readonly kind: "clear" };
export function find(xs: Uint8Array, want: number): number | null {
  for (let idx = 0; idx < xs.length; idx++) {
    if (xs[idx] === want) return idx;
  }
  return null;
}
export function findOrZero(xs: Uint8Array, want: number): number {
  const hit = find(xs, want);
  if (hit === null) return 0;
  return hit;
}
export function fallback(cursor: number | null): number {
  return cursor ?? 7;
}
export function apply(sel: number, v: number, prev: number | null): number {
  const msg: Msg = sel === 0 ? { kind: "set", v: v } : { kind: "clear" };
  switch (msg.kind) {
    case "set": return prev === 0 ? msg.v + 100 : msg.v;
    case "clear": return prev !== 0 ? 1 : 0;
  }
}
`,
    calls: [
      { fn: "find", args: [{ t: "bytes", v: [9, 4, 7] }, i(7)] },
      { fn: "find", args: [{ t: "bytes", v: [9, 4, 7] }, i(5)] },
      { fn: "findOrZero", args: [{ t: "bytes", v: [9, 4, 7] }, i(4)] },
      { fn: "findOrZero", args: [{ t: "bytes", v: [] }, i(4)] },
      { fn: "fallback", args: [{ t: "null" }] },
      { fn: "fallback", args: [i(3)] },
      { fn: "apply", args: [i(0), i(5), i(0)] },
      { fn: "apply", args: [i(0), i(5), { t: "null" }] },
      { fn: "apply", args: [i(1), i(5), { t: "null" }] },
      { fn: "apply", args: [i(1), i(5), i(0)] },
      { fn: "apply", args: [i(1), i(5), i(2)] },
    ],
  },
  {
    name: "orelse fusion over a ternary initializer keeps both arms (parenthesized conditional)",
    src: `
export function low(bytes: Uint8Array): number | null {
  if (bytes.length === 0) return null;
  return bytes[0];
}
export function high(bytes: Uint8Array): number | null {
  if (bytes.length < 2) return null;
  return bytes[1];
}
export function pick(first: boolean, bytes: Uint8Array): number {
  const v = first ? low(bytes) : high(bytes);
  if (v === null) return -1;
  return v;
}
`,
    calls: [
      { fn: "pick", args: [{ t: "b", v: true }, { t: "bytes", v: [9, 4] }] },
      { fn: "pick", args: [{ t: "b", v: false }, { t: "bytes", v: [9, 4] }] },
      { fn: "pick", args: [{ t: "b", v: true }, { t: "bytes", v: [] }] },
      { fn: "pick", args: [{ t: "b", v: false }, { t: "bytes", v: [9] }] },
    ],
  },
  {
    name: "float arithmetic corners: precision, signed zero, division and remainder by zero",
    src: `
export function fadd(a: number, b: number): number {
  return a + b;
}
export function fmul(a: number, b: number): number {
  return a * b;
}
export function fdiv(a: number, b: number): number {
  return a / b;
}
export function fmod(a: number, b: number): number {
  return a % b;
}
export function feq(a: number, b: number): boolean {
  return a === b;
}
export function flt(a: number, b: number): boolean {
  return a < b;
}
export function fge(a: number, b: number): boolean {
  return a >= b;
}
export function halfLen(bytes: Uint8Array): number {
  return bytes.length / 2;
}
`,
    calls: [
      { fn: "fadd", args: [f(0.1), f(0.2)] },
      { fn: "fmul", args: [f(-1), f(0)] },
      { fn: "fmul", args: [f(0.1), f(0.1)] },
      { fn: "fdiv", args: [f(1), f(3)] },
      { fn: "fdiv", args: [f(1), f(0)] },
      { fn: "fdiv", args: [f(-1), f(0)] },
      { fn: "fdiv", args: [f(1), f("-0")] },
      { fn: "fdiv", args: [f(0), f(0)] },
      { fn: "fdiv", args: [f(5), f(2)] },
      { fn: "fmod", args: [f(5.5), f(2)] },
      { fn: "fmod", args: [f(-5.5), f(2)] },
      { fn: "fmod", args: [f(1), f(0)] },
      { fn: "fmod", args: [f("inf"), f(2)] },
      { fn: "fmod", args: [f(3), f("inf")] },
      { fn: "feq", args: [f("nan"), f("nan")] },
      { fn: "feq", args: [f(0), f("-0")] },
      { fn: "flt", args: [f("nan"), f(1)] },
      { fn: "fge", args: [f("nan"), f(1)] },
      { fn: "flt", args: [f("-inf"), f(1)] },
      { fn: "halfLen", args: [{ t: "bytes", v: [1, 2, 3, 4, 5] }] },
      { fn: "halfLen", args: [{ t: "bytes", v: [1, 2, 3] }] },
    ],
  },
  {
    name: "Math corners: min/max NaN propagation and zero order, round half toward +inf",
    src: `
export function lo(a: number, b: number): number {
  return Math.min(a, b);
}
export function hi(a: number, b: number): number {
  return Math.max(a, b);
}
export function nearest(x: number): number {
  return Math.round(x);
}
`,
    calls: [
      { fn: "lo", args: [f("nan"), f(1)] },
      { fn: "lo", args: [f(1), f("nan")] },
      { fn: "lo", args: [f(0), f("-0")] },
      { fn: "lo", args: [f("-0"), f(0)] },
      { fn: "lo", args: [f(2), f(3)] },
      { fn: "hi", args: [f(0), f("-0")] },
      { fn: "hi", args: [f("-0"), f("-0")] },
      { fn: "hi", args: [f("nan"), f("-inf")] },
      { fn: "hi", args: [f(2), f(3)] },
      { fn: "nearest", args: [f(0.5)] },
      { fn: "nearest", args: [f(-0.5)] },
      { fn: "nearest", args: [f(2.5)] },
      { fn: "nearest", args: [f(-2.5)] },
      { fn: "nearest", args: [f(0.49999999999999994)] },
      { fn: "nearest", args: [f(-0.4)] },
      { fn: "nearest", args: [f("-0")] },
      { fn: "nearest", args: [f(4503599627370495.5)] },
      { fn: "nearest", args: [f("nan")] },
      { fn: "nearest", args: [f("inf")] },
      { fn: "nearest", args: [f(1.5)] },
    ],
  },
  {
    name: "bitwise ToInt32: out-of-range and negative operands wrap like the source",
    src: `
export function band(a: number, b: number): number {
  return a & b;
}
export function bor(a: number, b: number): number {
  return a | b;
}
export function bxor(a: number, b: number): number {
  return a ^ b;
}
export function bmask(a: number): number {
  return a & 255;
}
`,
    calls: [
      { fn: "band", args: [i(1099511627776), i(1099511627776)] },
      { fn: "band", args: [i(-1), i(255)] },
      { fn: "bor", args: [i(4294967296), i(1)] },
      { fn: "bor", args: [i(-2), i(1)] },
      { fn: "bxor", args: [i(-1), i(1099511627776)] },
      { fn: "bxor", args: [i(2147483648), i(0)] },
      { fn: "bmask", args: [i(1099511627781)] },
      { fn: "bmask", args: [i(-1)] },
      { fn: "band", args: [i(12), i(10)] },
    ],
  },
  {
    name: "integer paths: counting loops, byte reads, template holes, remainder indexing",
    src: `
import { asciiBytes } from "@native-sdk/core";
export function spaces(bytes: Uint8Array): number {
  let n = 0;
  for (let idx = 0; idx < bytes.length; idx++) {
    if (bytes[idx] === 32) n += 1;
  }
  return n;
}
export function label(n: number, bytes: Uint8Array): Uint8Array {
  const probe = bytes[n];
  return asciiBytes(\`item \${n + probe}\`);
}
export function wrapAt(bytes: Uint8Array, at: number): number {
  return bytes[at % bytes.length];
}
`,
    calls: [
      { fn: "spaces", args: [{ t: "bytes", v: [32, 65, 32, 32, 66] }] },
      { fn: "spaces", args: [{ t: "bytes", v: [] }] },
      { fn: "label", args: [i(1), { t: "bytes", v: [10, 20, 30] }] },
      { fn: "wrapAt", args: [{ t: "bytes", v: [5, 6, 7] }, i(7)] },
      { fn: "wrapAt", args: [{ t: "bytes", v: [5, 6, 7] }, i(2)] },
    ],
  },
  {
    name: "bytes ops: subarray views, slice copies, set stitching",
    src: `
export function tail(bytes: Uint8Array, from: number): Uint8Array {
  return bytes.slice(from, bytes.length);
}
export function head(bytes: Uint8Array, upTo: number): Uint8Array {
  return bytes.subarray(0, upTo);
}
export function stitch(a: Uint8Array, b: Uint8Array): Uint8Array {
  const out = new Uint8Array(a.length + b.length);
  out.set(a, 0);
  out.set(b, a.length);
  return out;
}
`,
    calls: [
      { fn: "tail", args: [{ t: "bytes", v: [1, 2, 3, 4] }, i(2)] },
      { fn: "tail", args: [{ t: "bytes", v: [1, 2] }, i(2)] },
      { fn: "head", args: [{ t: "bytes", v: [9, 8, 7] }, i(2)] },
      { fn: "stitch", args: [{ t: "bytes", v: [1, 2] }, { t: "bytes", v: [3] }] },
      { fn: "stitch", args: [{ t: "bytes", v: [] }, { t: "bytes", v: [] }] },
    ],
  },
  {
    name: "literal unions at runtime: cross-enum equality, optional tags, re-tagging",
    src: `
export type Category = "food" | "travel" | "gear";
export type CategoryFilter = "all" | "food" | "travel" | "gear";
export function matches(category: Category, filter: CategoryFilter | null): boolean {
  return filter === null || category === filter;
}
export function pick(category: Category, everything: boolean): CategoryFilter {
  const filter: CategoryFilter = everything ? "all" : category;
  return filter;
}
export function differs(s: Category, b: CategoryFilter): boolean {
  return s !== b;
}
export function same(s: Category | null, b: CategoryFilter | null): boolean {
  return s === b;
}
`,
    calls: [
      { fn: "matches", args: [{ t: "tag", v: "food" }, { t: "null" }] },
      { fn: "matches", args: [{ t: "tag", v: "food" }, { t: "tag", v: "food" }] },
      { fn: "matches", args: [{ t: "tag", v: "food" }, { t: "tag", v: "gear" }] },
      { fn: "matches", args: [{ t: "tag", v: "food" }, { t: "tag", v: "all" }] },
      { fn: "pick", args: [{ t: "tag", v: "travel" }, { t: "b", v: false }] },
      { fn: "pick", args: [{ t: "tag", v: "food" }, { t: "b", v: true }] },
      { fn: "differs", args: [{ t: "tag", v: "food" }, { t: "tag", v: "food" }] },
      { fn: "differs", args: [{ t: "tag", v: "food" }, { t: "tag", v: "all" }] },
      { fn: "same", args: [{ t: "null" }, { t: "null" }] },
      { fn: "same", args: [{ t: "null" }, { t: "tag", v: "food" }] },
      { fn: "same", args: [{ t: "tag", v: "food" }, { t: "null" }] },
      { fn: "same", args: [{ t: "tag", v: "food" }, { t: "tag", v: "food" }] },
      { fn: "same", args: [{ t: "tag", v: "gear" }, { t: "tag", v: "all" }] },
    ],
  },
  {
    name: "union narrowing through a selector-built value and payload math",
    src: `
export type Ev =
  | { readonly kind: "insert"; readonly text: Uint8Array }
  | { readonly kind: "move"; readonly dx: number; readonly dy: number }
  | { readonly kind: "clear" };
export function weigh(sel: number, payload: Uint8Array, dx: number, dy: number): number {
  const ev: Ev = sel === 0 ? { kind: "insert", text: payload } : sel === 1 ? { kind: "move", dx: dx, dy: dy } : { kind: "clear" };
  switch (ev.kind) {
    case "insert": return ev.text.length;
    case "move": return ev.dx + ev.dy;
    case "clear": return 0;
  }
}
`,
    calls: [
      { fn: "weigh", args: [i(0), { t: "bytes", v: [1, 2, 3] }, f(0), f(0)] },
      { fn: "weigh", args: [i(1), { t: "bytes", v: [] }, f(2.5), f(-1)] },
      { fn: "weigh", args: [i(2), { t: "bytes", v: [] }, f(0), f(0)] },
    ],
  },
  {
    name: "number arrays: map/filter lowering keeps float element math",
    src: `
export function scaled(xs: readonly number[], k: number): readonly number[] {
  return xs.map((x) => x * k);
}
export function bigs(xs: readonly number[], lim: number): readonly number[] {
  return xs.filter((x) => x > lim);
}
`,
    calls: [
      { fn: "scaled", args: [{ t: "nums", v: [1.5, -2, 0.1] }, f(3)] },
      { fn: "scaled", args: [{ t: "nums", v: [] }, f(2)] },
      { fn: "bigs", args: [{ t: "nums", v: [0.5, 2, -3, 7] }, f(1)] },
      { fn: "bigs", args: [{ t: "nums", v: [0.5] }, f(1)] },
    ],
  },
  {
    name: "record model dispatch: spread updates, map toggles, filter purges",
    src: `
export interface Task { readonly id: number; readonly done: boolean; }
export interface Model { readonly tasks: readonly Task[]; readonly nextId: number; }
export type Msg =
  | { readonly kind: "add" }
  | { readonly kind: "toggle"; readonly id: number }
  | { readonly kind: "purge" };
export function initialModel(): Model {
  return { tasks: [], nextId: 1 };
}
export function update(model: Model, msg: Msg): Model {
  switch (msg.kind) {
    case "add":
      return { ...model, tasks: [...model.tasks, { id: model.nextId, done: false }], nextId: model.nextId + 1 };
    case "toggle":
      return { ...model, tasks: model.tasks.map((t) => (t.id === msg.id ? { ...t, done: !t.done } : t)) };
    case "purge":
      return { ...model, tasks: model.tasks.filter((t) => !t.done) };
  }
}
export function doneCount(model: Model): number {
  return model.tasks.filter((t) => t.done).length;
}
export function idSum(model: Model): number {
  let total = 0;
  for (let idx = 0; idx < model.tasks.length; idx++) {
    total += model.tasks[idx].id;
  }
  return total;
}
`,
    node: `
{
  let model = mod.initialModel();
  model = mod.update(model, { kind: "add" });
  model = mod.update(model, { kind: "add" });
  model = mod.update(model, { kind: "add" });
  model = mod.update(model, { kind: "toggle", id: 2 });
  line("s0", mod.doneCount(model));
  line("s1", mod.idSum(model));
  model = mod.update(model, { kind: "purge" });
  line("s2", mod.idSum(model));
  line("s3", model.nextId);
}
`,
    zig: `
    {
        var model = m.initialModel();
        model = m.update(model, .add);
        model = m.update(model, .add);
        model = m.update(model, .add);
        model = m.update(model, .{ .toggle = 2 });
        row("s0", m.doneCount(model));
        row("s1", m.idSum(model));
        model = m.update(model, .purge);
        row("s2", m.idSum(model));
        row("s3", model.nextId);
    }
`,
  },
  {
    name: "Cmd effects channel: encoded command bytes match the SDK factories",
    src: `
import { Cmd } from "@native-sdk/core";
export interface Model { readonly count: number; readonly saved: number; }
export type Msg =
  | { readonly kind: "add" }
  | { readonly kind: "save" }
  | { readonly kind: "stamp" }
  | { readonly kind: "tick"; readonly at: number };
export function initialModel(): Model {
  return { count: 0, saved: 0 };
}
export function update(model: Model, msg: Msg): Model | [Model, Cmd<Msg>] {
  switch (msg.kind) {
    case "add": return { ...model, count: model.count + 1 };
    case "save": return [{ ...model, saved: model.count }, model.count > 2 ? Cmd.persist() : Cmd.none];
    case "stamp": return [model, Cmd.batch([Cmd.now("tick"), Cmd.host("beep", model.count, 0.5)])];
    case "tick": return { ...model, count: msg.at };
  }
}
`,
    node: `
{
  // Msg arm order, for Cmd.now's declaration-order tag byte.
  const kinds = ["add", "save", "stamp", "tick"];
  // Mirror of the rt kernel's Cmd wire format v1 (rt.zig): flat op records,
  // batch = concatenation, args as f64 little-endian.
  const enc = (cmd) => {
    if (cmd.op === "none") return [];
    if (cmd.op === "persist") return [1];
    if (cmd.op === "now") return [2, kinds.indexOf(cmd.msgKind)];
    if (cmd.op === "host") {
      const name = Array.from(new TextEncoder().encode(cmd.name));
      const bytes = [3, name.length, ...name, cmd.args.length];
      for (const a of cmd.args) {
        const dv = new DataView(new ArrayBuffer(8));
        dv.setFloat64(0, a, true);
        for (let idx = 0; idx < 8; idx++) bytes.push(dv.getUint8(idx));
      }
      return bytes;
    }
    return cmd.cmds.flatMap(enc);
  };
  const step = (model, msg) => {
    const r = mod.update(model, msg);
    return Array.isArray(r) ? [r[0], Uint8Array.from(enc(r[1]))] : [r, Uint8Array.from([])];
  };
  let model = mod.initialModel();
  let cmd;
  [model, cmd] = step(model, { kind: "add" });
  line("e0m", model.count);
  line("e0c", cmd);
  [model, cmd] = step(model, { kind: "save" });
  line("e1s", model.saved);
  line("e1c", cmd);
  [model, cmd] = step(model, { kind: "add" });
  [model, cmd] = step(model, { kind: "add" });
  [model, cmd] = step(model, { kind: "save" });
  line("e2s", model.saved);
  line("e2c", cmd);
  [model, cmd] = step(model, { kind: "stamp" });
  line("e3c", cmd);
  [model, cmd] = step(model, { kind: "tick", at: 41 });
  line("e4m", model.count);
  line("e4c", cmd);
}
`,
    zig: `
    {
        var model = m.initialModel();
        var r = m.update(model, .add);
        model = r.model;
        row("e0m", model.count);
        row("e0c", r.cmd);
        r = m.update(model, .save);
        model = r.model;
        row("e1s", model.saved);
        row("e1c", r.cmd);
        r = m.update(model, .add);
        model = r.model;
        r = m.update(model, .add);
        model = r.model;
        r = m.update(model, .save);
        model = r.model;
        row("e2s", model.saved);
        row("e2c", r.cmd);
        r = m.update(model, .stamp);
        model = r.model;
        row("e3c", r.cmd);
        r = m.update(model, .{ .tick = 41 });
        model = r.model;
        row("e4m", model.count);
        row("e4c", r.cmd);
    }
`,
  },
  {
    name: "optional chains: short-circuit and present-value paths behave identically",
    src: `
export interface Sel { readonly at: number; readonly len: number; }
export interface Model { readonly sel: Sel | null; readonly fallback: number; }
export type Msg =
  | { readonly kind: "pick"; readonly at: number; readonly len: number }
  | { readonly kind: "clear" };
export function initialModel(): Model {
  return { sel: null, fallback: 7 };
}
export function update(model: Model, msg: Msg): Model {
  switch (msg.kind) {
    case "pick": return { ...model, sel: { at: msg.at, len: msg.len } };
    case "clear": return { ...model, sel: null };
  }
}
export function selEnd(model: Model): number {
  return (model.sel?.at ?? -1) + (model.sel?.len ?? 0);
}
export function hasWide(model: Model): boolean {
  return (model.sel?.len ?? 0) > 2;
}
export function pickedAtFour(model: Model): number {
  if (model.sel?.at === 4) return 1;
  return 0;
}
export function atOrFallback(model: Model): number {
  return model.sel?.at ?? model.fallback;
}
`,
    node: `
{
  let model = mod.initialModel();
  line("q0", mod.selEnd(model));
  line("q1", mod.hasWide(model));
  line("q2", mod.pickedAtFour(model));
  line("q3", mod.atOrFallback(model));
  model = mod.update(model, { kind: "pick", at: 4, len: 3 });
  line("q4", mod.selEnd(model));
  line("q5", mod.hasWide(model));
  line("q6", mod.pickedAtFour(model));
  line("q7", mod.atOrFallback(model));
  model = mod.update(model, { kind: "clear" });
  line("q8", mod.selEnd(model));
}
`,
    zig: `
    {
        var model = m.initialModel();
        row("q0", m.selEnd(model));
        row("q1", m.hasWide(model));
        row("q2", m.pickedAtFour(model));
        row("q3", m.atOrFallback(model));
        model = m.update(model, .{ .pick = .{ .at = 4, .len = 3 } });
        row("q4", m.selEnd(model));
        row("q5", m.hasWide(model));
        row("q6", m.pickedAtFour(model));
        row("q7", m.atOrFallback(model));
        model = m.update(model, .clear);
        row("q8", m.selEnd(model));
    }
`,
  },
  {
    name: "string equality: content comparison, null table, tag-name against string",
    src: `
export type Filter = "all" | "active" | "done";
export function commandCode(name: string): number {
  if (name === "app.add") return 1;
  if (name !== "app.remove") return 0;
  return 2;
}
export function sameName(a: string, b: string): boolean {
  return a === b;
}
export function pick(name: string | null): number {
  if (name === "left") return 1;
  if (name !== "right") return 2;
  return 3;
}
export function matchesName(f: Filter, name: string): boolean {
  return f === name;
}
`,
    calls: [
      { fn: "commandCode", args: [{ t: "str", v: "app.add" }] },
      { fn: "commandCode", args: [{ t: "str", v: "app.remove" }] },
      { fn: "commandCode", args: [{ t: "str", v: "other" }] },
      { fn: "commandCode", args: [{ t: "str", v: "" }] },
      { fn: "sameName", args: [{ t: "str", v: "a" }, { t: "str", v: "a" }] },
      { fn: "sameName", args: [{ t: "str", v: "a" }, { t: "str", v: "b" }] },
      { fn: "sameName", args: [{ t: "str", v: "" }, { t: "str", v: "" }] },
      { fn: "pick", args: [{ t: "null" }] },
      { fn: "pick", args: [{ t: "str", v: "left" }] },
      { fn: "pick", args: [{ t: "str", v: "right" }] },
      { fn: "pick", args: [{ t: "str", v: "middle" }] },
      { fn: "matchesName", args: [{ t: "tag", v: "all" }, { t: "str", v: "all" }] },
      { fn: "matchesName", args: [{ t: "tag", v: "done" }, { t: "str", v: "all" }] },
      { fn: "matchesName", args: [{ t: "tag", v: "active" }, { t: "str", v: "activex" }] },
    ],
  },
  {
    name: "for...of: sums with break and continue over bytes and number arrays",
    src: `
export function sumBytes(bytes: Uint8Array, stop: number): number {
  let total = 0;
  for (const b of bytes) {
    if (b === stop) break;
    if (b === 0) continue;
    total += b;
  }
  return total;
}
export function product(xs: readonly number[]): number {
  let p = 1;
  for (const x of xs) {
    p = p * x;
  }
  return p;
}
`,
    calls: [
      { fn: "sumBytes", args: [{ t: "bytes", v: [1, 0, 2, 9, 5] }, i(9)] },
      { fn: "sumBytes", args: [{ t: "bytes", v: [] }, i(9)] },
      { fn: "sumBytes", args: [{ t: "bytes", v: [3, 0, 4] }, i(9)] },
      { fn: "product", args: [{ t: "nums", v: [1.5, -2, 0.1] }] },
      { fn: "product", args: [{ t: "nums", v: [] }] },
    ],
  },
  {
    name: "predicate scans: find/findIndex/some/every hits, misses, and empties",
    src: `
export function firstOver(xs: readonly number[], lim: number): number {
  return xs.find((x) => x > lim) ?? -1;
}
export function overAt(xs: readonly number[], lim: number): number {
  return xs.findIndex((x) => x > lim);
}
export function anyOver(xs: readonly number[], lim: number): boolean {
  return xs.some((x) => x > lim);
}
export function allOver(xs: readonly number[], lim: number): boolean {
  return xs.every((x) => x > lim);
}
export function tenfoldHit(xs: readonly number[], lim: number): number {
  const hit = xs.find((x) => x > lim);
  if (hit === undefined) return -1;
  return hit * 10;
}
`,
    calls: [
      { fn: "firstOver", args: [{ t: "nums", v: [0.5, 2, -3, 7] }, f(1)] },
      { fn: "firstOver", args: [{ t: "nums", v: [0.5] }, f(1)] },
      { fn: "firstOver", args: [{ t: "nums", v: [] }, f(1)] },
      { fn: "firstOver", args: [{ t: "nums", v: ["nan", 4] }, f(1)] },
      { fn: "overAt", args: [{ t: "nums", v: [0.5, 2, -3, 7] }, f(1)] },
      { fn: "overAt", args: [{ t: "nums", v: [0.5] }, f(9)] },
      { fn: "anyOver", args: [{ t: "nums", v: [0.5, 2] }, f(1)] },
      { fn: "anyOver", args: [{ t: "nums", v: [] }, f(1)] },
      { fn: "allOver", args: [{ t: "nums", v: [2, 3] }, f(1)] },
      { fn: "allOver", args: [{ t: "nums", v: [2, 0.5] }, f(1)] },
      { fn: "allOver", args: [{ t: "nums", v: [] }, f(1)] },
      { fn: "tenfoldHit", args: [{ t: "nums", v: [0.5, 2] }, f(1)] },
      { fn: "tenfoldHit", args: [{ t: "nums", v: [0.5] }, f(1)] },
    ],
  },
  {
    name: "mixed-class optional equality widens null-safely; miss-first ternaries narrow",
    src: `
export interface Entry { readonly at: number; }
const ENTRIES: readonly Entry[] = [{ at: 0 }, { at: 2 }, { at: 7 }];
export function pickOrFlag(bytes: Uint8Array, key: number, frac: number): number {
  const hit = ENTRIES.find((e) => e.at === key);
  const sel = hit === undefined ? null : hit.at;
  const half = frac * 0.5;
  if (sel === half) return -1;
  if (sel !== null && sel < bytes.length) return bytes[sel];
  return -2;
}
export function offHalf(sel: number | null, frac: number): boolean {
  const half = frac * 0.5;
  return sel !== half;
}
export function missTernary(xs: readonly number[], lim: number): number {
  const hit = xs.find((x) => x > lim);
  return hit === undefined ? -1 : hit * 2;
}
export function selTernary(sel: number | null): number {
  return sel === null ? 0 : sel + 1;
}
`,
    calls: [
      // sel is an INTERNAL optional integer slot (table id through a find
      // miss-ternary, index-demanded); half is float: the 2 === 2.0 hit
      // must agree with node through the null-safe widening.
      { fn: "pickOrFlag", args: [{ t: "bytes", v: [5, 6, 7] }, f(2), f(4)] },
      { fn: "pickOrFlag", args: [{ t: "bytes", v: [5, 6, 7] }, f(0), f(5)] },
      { fn: "pickOrFlag", args: [{ t: "bytes", v: [5, 6, 7] }, f(9), f(4)] },
      { fn: "pickOrFlag", args: [{ t: "bytes", v: [] }, f(7), f(1)] },
      { fn: "offHalf", args: [{ t: "null" }, f(0)] },
      { fn: "offHalf", args: [{ t: "null" }, f("nan")] },
      { fn: "missTernary", args: [{ t: "nums", v: [0.5, 2] }, f(1)] },
      { fn: "missTernary", args: [{ t: "nums", v: [0.5] }, f(1)] },
      { fn: "selTernary", args: [{ t: "null" }] },
      { fn: "selTernary", args: [f(4.5)] },
    ],
  },
  {
    name: "reduce: float accumulation, seeds, and the empty-array initial",
    src: `
export function total(xs: readonly number[]): number {
  return xs.reduce((sum, x) => sum + x, 0);
}
export function totalFrom(xs: readonly number[], seed: number): number {
  return xs.reduce((sum, x) => sum + x, seed);
}
export function countBig(xs: readonly number[], lim: number): number {
  return xs.reduce((n, x) => (x > lim ? n + 1 : n), 0);
}
`,
    calls: [
      { fn: "total", args: [{ t: "nums", v: [0.1, 0.2] }] },
      { fn: "total", args: [{ t: "nums", v: [] }] },
      { fn: "total", args: [{ t: "nums", v: [1, 2, 3] }] },
      { fn: "totalFrom", args: [{ t: "nums", v: [1, 2] }, f(0.5)] },
      { fn: "totalFrom", args: [{ t: "nums", v: [] }, f("-0")] },
      { fn: "countBig", args: [{ t: "nums", v: [0.5, 2, -3, 7] }, f(1)] },
    ],
  },
  {
    name: "slice and concat: negative, clamped, and crossed indices copy like JS",
    src: `
export function sliced(xs: readonly number[], from: number, to: number): readonly number[] {
  return xs.slice(from, to);
}
export function tailFrom(xs: readonly number[], from: number): readonly number[] {
  return xs.slice(from);
}
export function wholeCopy(xs: readonly number[]): readonly number[] {
  return xs.slice();
}
export function stitched(a: readonly number[], b: readonly number[]): readonly number[] {
  return a.concat(b);
}
`,
    calls: [
      { fn: "sliced", args: [{ t: "nums", v: [1, 2, 3] }, i(-2), i(99)] },
      { fn: "sliced", args: [{ t: "nums", v: [1, 2, 3] }, i(1), i(-1)] },
      { fn: "sliced", args: [{ t: "nums", v: [1, 2, 3] }, i(2), i(1)] },
      { fn: "sliced", args: [{ t: "nums", v: [1, 2, 3] }, i(5), i(9)] },
      { fn: "sliced", args: [{ t: "nums", v: [1, 2, 3] }, i(0), i(99)] },
      { fn: "tailFrom", args: [{ t: "nums", v: [1, 2, 3] }, i(-99)] },
      { fn: "tailFrom", args: [{ t: "nums", v: [1, 2, 3] }, i(2)] },
      { fn: "wholeCopy", args: [{ t: "nums", v: [0.5, -0.5] }] },
      { fn: "wholeCopy", args: [{ t: "nums", v: [] }] },
      { fn: "stitched", args: [{ t: "nums", v: [1] }, { t: "nums", v: [2, 3] }] },
      { fn: "stitched", args: [{ t: "nums", v: [] }, { t: "nums", v: [] }] },
    ],
  },
  {
    name: "indexOf and includes: strict equality vs SameValueZero (NaN, signed zero)",
    src: `
export function whereIs(xs: readonly number[], v: number): number {
  return xs.indexOf(v);
}
export function has(xs: readonly number[], v: number): boolean {
  return xs.includes(v);
}
`,
    calls: [
      { fn: "whereIs", args: [{ t: "nums", v: [1, "nan", 3] }, f("nan")] },
      { fn: "has", args: [{ t: "nums", v: [1, "nan", 3] }, f("nan")] },
      { fn: "whereIs", args: [{ t: "nums", v: [0] }, f("-0")] },
      { fn: "has", args: [{ t: "nums", v: [0] }, f("-0")] },
      { fn: "whereIs", args: [{ t: "nums", v: ["-0"] }, f(0)] },
      { fn: "whereIs", args: [{ t: "nums", v: [5, 6, 7] }, f(6)] },
      { fn: "whereIs", args: [{ t: "nums", v: [5] }, f(9)] },
      { fn: "has", args: [{ t: "nums", v: [] }, f(1)] },
    ],
  },
  {
    name: "bytes join: separators fold, empties and single elements match JS ToString",
    src: `
export function dashed(bytes: Uint8Array): string {
  return bytes.join("-");
}
export function commas(bytes: Uint8Array): string {
  return bytes.join();
}
export function bare(bytes: Uint8Array): string {
  return bytes.join("");
}
`,
    calls: [
      { fn: "dashed", args: [{ t: "bytes", v: [1, 255, 0] }] },
      { fn: "dashed", args: [{ t: "bytes", v: [] }] },
      { fn: "dashed", args: [{ t: "bytes", v: [9] }] },
      { fn: "commas", args: [{ t: "bytes", v: [1, 2] }] },
      { fn: "bare", args: [{ t: "bytes", v: [1, 2, 3] }] },
    ],
  },
  {
    name: "record model dispatch through the scan and copy methods",
    src: `
export interface Task { readonly id: number; readonly done: boolean; }
export interface Model { readonly tasks: readonly Task[]; readonly nextId: number; }
export type Msg =
  | { readonly kind: "add" }
  | { readonly kind: "toggle"; readonly id: number };
export function initialModel(): Model {
  return { tasks: [], nextId: 1 };
}
export function update(model: Model, msg: Msg): Model {
  switch (msg.kind) {
    case "add":
      return { ...model, tasks: [...model.tasks, { id: model.nextId, done: false }], nextId: model.nextId + 1 };
    case "toggle":
      return { ...model, tasks: model.tasks.map((t) => (t.id === msg.id ? { ...t, done: !t.done } : t)) };
  }
}
export function firstDoneId(model: Model): number {
  const hit = model.tasks.find((t) => t.done);
  if (hit === undefined) return -1;
  return hit.id;
}
export function doneAt(model: Model): number {
  return model.tasks.findIndex((t) => t.done);
}
export function anyDone(model: Model): boolean {
  return model.tasks.some((t) => t.done);
}
export function allDone(model: Model): boolean {
  return model.tasks.every((t) => t.done);
}
export function idTotal(model: Model): number {
  return model.tasks.reduce((sum, t) => sum + t.id, 0);
}
export function keptCount(model: Model): number {
  return model.tasks.slice(0, 2).length;
}
`,
    node: `
{
  let model = mod.initialModel();
  line("g0", mod.firstDoneId(model));
  line("g1", mod.anyDone(model));
  line("g2", mod.allDone(model));
  model = mod.update(model, { kind: "add" });
  model = mod.update(model, { kind: "add" });
  model = mod.update(model, { kind: "add" });
  model = mod.update(model, { kind: "toggle", id: 2 });
  line("g3", mod.firstDoneId(model));
  line("g4", mod.doneAt(model));
  line("g5", mod.anyDone(model));
  line("g6", mod.allDone(model));
  line("g7", mod.idTotal(model));
  line("g8", mod.keptCount(model));
}
`,
    zig: `
    {
        var model = m.initialModel();
        row("g0", m.firstDoneId(model));
        row("g1", m.anyDone(model));
        row("g2", m.allDone(model));
        model = m.update(model, .add);
        model = m.update(model, .add);
        model = m.update(model, .add);
        model = m.update(model, .{ .toggle = 2 });
        row("g3", m.firstDoneId(model));
        row("g4", m.doneAt(model));
        row("g5", m.anyDone(model));
        row("g6", m.allDone(model));
        row("g7", m.idTotal(model));
        row("g8", m.keptCount(model));
    }
`,
  },
  {
    name: "toSorted: sign comparators over floats, duplicates, signed zeros, and empties",
    src: `
export function asc(xs: readonly number[]): readonly number[] {
  return xs.toSorted((a, b) => a - b);
}
export function desc(xs: readonly number[]): readonly number[] {
  return xs.toSorted((a, b) => b - a);
}
export function keepOrder(xs: readonly number[]): readonly number[] {
  return xs.toSorted((a, b) => 0);
}
export function fractional(xs: readonly number[]): readonly number[] {
  return xs.toSorted((a, b) => (a - b) * 0.5);
}
`,
    calls: [
      { fn: "asc", args: [{ t: "nums", v: [3, 1, 2, 1, 3, 0.5] }] },
      { fn: "asc", args: [{ t: "nums", v: [0, "-0", 0] }] },
      { fn: "asc", args: [{ t: "nums", v: [] }] },
      { fn: "asc", args: [{ t: "nums", v: [5] }] },
      { fn: "asc", args: [{ t: "nums", v: [2, -1, "-0", 7, -1] }] },
      { fn: "desc", args: [{ t: "nums", v: [3, 1, 2, 1, 3] }] },
      { fn: "desc", args: [{ t: "nums", v: [0.25, 0.5, 0.125] }] },
      { fn: "keepOrder", args: [{ t: "nums", v: [3, 1, 2] }] },
      { fn: "fractional", args: [{ t: "nums", v: [3, 1, 2, 1] }] },
    ],
  },
  {
    name: "toSorted stability: equal-key records keep declaration order, byte for byte",
    src: `
export interface Task { readonly id: number; readonly streak: number; }
export interface Model { readonly tasks: readonly Task[]; readonly nextId: number; }
export type Msg = { readonly kind: "seed"; readonly streak: number } | { readonly kind: "noop" };
export function initialModel(): Model {
  return { tasks: [], nextId: 1 };
}
export function update(model: Model, msg: Msg): Model {
  switch (msg.kind) {
    case "seed":
      return { tasks: [...model.tasks, { id: model.nextId, streak: msg.streak }], nextId: model.nextId + 1 };
    case "noop": return model;
  }
}
export function sortedIds(model: Model): readonly number[] {
  const out: number[] = [];
  for (const t of model.tasks.toSorted((a, b) => a.streak - b.streak)) {
    out.push(t.id);
  }
  return out;
}
export function groupedIds(model: Model): readonly number[] {
  const out: number[] = [];
  for (const t of model.tasks.toSorted((a, b) => {
    if (a.streak === b.streak) return 0;
    return b.streak - a.streak;
  })) {
    out.push(t.id);
  }
  return out;
}
`,
    node: `
{
  let model = mod.initialModel();
  for (const s of [2, 1, 2, 1, 2, 0]) model = mod.update(model, { kind: "seed", streak: s });
  line("t0", mod.sortedIds(model));
  line("t1", mod.groupedIds(model));
  line("t2", mod.sortedIds(mod.initialModel()));
}
`,
    zig: `
    {
        var model = m.initialModel();
        for ([_]f64{ 2, 1, 2, 1, 2, 0 }) |s| model = m.update(model, .{ .seed = s });
        row("t0", m.sortedIds(model));
        row("t1", m.groupedIds(model));
        row("t2", m.sortedIds(m.initialModel()));
    }
`,
  },
  {
    name: "push-builder: growth past the seed capacity, conditional pushes, prefix reads",
    src: `
export function keptDoubled(xs: readonly number[], lim: number): readonly number[] {
  const out: number[] = [];
  for (const x of xs) {
    if (x > lim) {
      out.push(x * 2);
    } else if (x === lim) {
      out.push(x);
    }
  }
  return out;
}
export function countdown(n: number): readonly number[] {
  const out: number[] = [];
  let left = n;
  while (left > 0) {
    out.push(left);
    left -= 1;
  }
  return out;
}
export function firstOrMinusOne(xs: readonly number[], lim: number): number {
  const out: number[] = [];
  for (const x of xs) {
    if (x > lim) out.push(x);
  }
  if (out.length === 0) return -1;
  return out[0];
}
`,
    calls: [
      { fn: "keptDoubled", args: [{ t: "nums", v: [1, 5, 3, 5, 9, 0.5] }, f(3)] },
      { fn: "keptDoubled", args: [{ t: "nums", v: [] }, f(3)] },
      { fn: "keptDoubled", args: [{ t: "nums", v: [1, 2] }, f(9)] },
      { fn: "countdown", args: [i(10)] },
      { fn: "countdown", args: [i(0)] },
      { fn: "firstOrMinusOne", args: [{ t: "nums", v: [1, 7, 9] }, f(5)] },
      { fn: "firstOrMinusOne", args: [{ t: "nums", v: [1] }, f(5)] },
    ],
  },
  {
    name: "local mutation: a push/pop parser-stack helper is byte-identical to node",
    src: `
export function maxDepth(bytes: Uint8Array): number {
  const stack: number[] = [];
  let max = 0;
  for (const b of bytes) {
    if (b === 40) stack.push(b);
    if (b === 41) stack.pop();
    if (stack.length > max) max = stack.length;
  }
  return max;
}
export function balance(bytes: Uint8Array): number {
  const stack: number[] = [];
  for (const b of bytes) {
    if (b === 40 || b === 91) stack.push(b);
    if (b === 41 || b === 93) {
      const open = stack.pop();
      if (open === undefined) return -1;
      if (b === 41 && open !== 40) return -2;
      if (b === 93 && open !== 91) return -2;
    }
  }
  return stack.length;
}
`,
    calls: [
      // "(()(()))" nests to 3; "(]" mismatches; ")" underflows (pop on empty).
      { fn: "maxDepth", args: [{ t: "bytes", v: [40, 40, 41, 40, 40, 41, 41, 41] }] },
      { fn: "maxDepth", args: [{ t: "bytes", v: [] }] },
      { fn: "maxDepth", args: [{ t: "bytes", v: [41, 41, 40] }] },
      { fn: "balance", args: [{ t: "bytes", v: [40, 91, 93, 41] }] },
      { fn: "balance", args: [{ t: "bytes", v: [40, 93] }] },
      { fn: "balance", args: [{ t: "bytes", v: [41] }] },
      { fn: "balance", args: [{ t: "bytes", v: [40, 40] }] },
    ],
  },
  {
    name: "local mutation: splice corners (negative start, over-delete, insert-larger, past-end)",
    src: `
export function cutAt(xs: readonly number[], start: number, count: number): readonly number[] {
  const work = xs.slice();
  const removed = work.splice(start, count);
  return removed.concat([-99], work);
}
export function cutRest(xs: readonly number[], start: number): readonly number[] {
  const work = xs.slice();
  const removed = work.splice(start);
  return removed.concat([-99], work);
}
export function inject(xs: readonly number[], start: number, count: number): readonly number[] {
  const work = xs.slice();
  const removed = work.splice(start, count, 91, 92, 93);
  return removed.concat([-99], work);
}
`,
    calls: [
      { fn: "cutAt", args: [{ t: "nums", v: [1, 2, 3, 4, 5] }, i(-2), i(1)] },
      { fn: "cutAt", args: [{ t: "nums", v: [1, 2, 3] }, i(1), i(99)] },
      { fn: "cutAt", args: [{ t: "nums", v: [1, 2, 3] }, i(1), i(-5)] },
      { fn: "cutAt", args: [{ t: "nums", v: [1, 2, 3] }, i(99), i(1)] },
      { fn: "cutAt", args: [{ t: "nums", v: [] }, i(0), i(1)] },
      { fn: "cutRest", args: [{ t: "nums", v: [1, 2, 3] }, i(1)] },
      { fn: "cutRest", args: [{ t: "nums", v: [1, 2, 3] }, i(-1)] },
      { fn: "inject", args: [{ t: "nums", v: [1, 2, 3] }, i(1), i(1)] },
      { fn: "inject", args: [{ t: "nums", v: [1, 2, 3] }, i(0), i(0)] },
      { fn: "inject", args: [{ t: "nums", v: [1, 2] }, i(99), i(1)] },
      { fn: "inject", args: [{ t: "nums", v: [] }, i(-3), i(2)] },
    ],
  },
  {
    name: "local mutation: shift/unshift ordering and their growth past the seed capacity",
    src: `
export function rotate(xs: readonly number[]): readonly number[] {
  const q = xs.slice();
  const head = q.shift();
  if (head === undefined) return q;
  q.push(head);
  q.unshift(-1, -2);
  return q;
}
export function frontLoad(n: number): readonly number[] {
  const q: number[] = [];
  for (let i = 0; i < n; i++) q.unshift(i);
  return q;
}
`,
    calls: [
      { fn: "rotate", args: [{ t: "nums", v: [1, 2, 3] }] },
      { fn: "rotate", args: [{ t: "nums", v: [7] }] },
      { fn: "rotate", args: [{ t: "nums", v: [] }] },
      { fn: "frontLoad", args: [i(10)] },
      { fn: "frontLoad", args: [i(0)] },
    ],
  },
  {
    name: "local mutation: in-place sort is stable and equals toSorted, byte for byte",
    src: `
export interface Rec { readonly key: number; readonly seq: number; }
export function stableIds(keys: readonly number[]): readonly number[] {
  const recs: Rec[] = [];
  for (let i = 0; i < keys.length; i++) recs.push({ key: keys[i], seq: i });
  recs.sort((a, b) => a.key - b.key);
  return recs.map((r) => r.seq);
}
export function sortedBoth(xs: readonly number[]): readonly number[] {
  const inPlace = xs.slice();
  inPlace.sort((a, b) => a - b);
  const copied = xs.toSorted((a, b) => a - b);
  return inPlace.concat([-99], copied);
}
`,
    calls: [
      { fn: "stableIds", args: [{ t: "nums", v: [2, 1, 2, 1, 1] }] },
      { fn: "stableIds", args: [{ t: "nums", v: [] }] },
      { fn: "sortedBoth", args: [{ t: "nums", v: [3, 1, 2, 1] }] },
      { fn: "sortedBoth", args: [{ t: "nums", v: [1, "-0", 0, 0.5] }] },
      { fn: "sortedBoth", args: [{ t: "nums", v: [] }] },
    ],
  },
  {
    name: "local mutation: pop on empty flows through the optional machinery",
    src: `
export function drainSum(xs: readonly number[], extraPops: number): number {
  const work = xs.slice();
  let total = 0;
  while (work.length > 0) {
    total += work.pop() ?? 0;
  }
  for (let i = 0; i < extraPops; i++) {
    const gone = work.pop();
    if (gone !== undefined) return -1;
  }
  return total + work.length;
}
export function lastOr(xs: readonly number[], fallback: number): number {
  const work = xs.slice();
  return work.pop() ?? fallback;
}
`,
    calls: [
      { fn: "drainSum", args: [{ t: "nums", v: [1, 2, 3.5] }, i(2)] },
      { fn: "drainSum", args: [{ t: "nums", v: [] }, i(3)] },
      { fn: "lastOr", args: [{ t: "nums", v: [1, 9] }, f(-1)] },
      { fn: "lastOr", args: [{ t: "nums", v: [] }, f(-1)] },
    ],
  },
  {
    name: "local mutation: interleaved mutation and reads (length, elements, fill, reverse, writes)",
    src: `
export function churn(xs: readonly number[], lim: number): readonly number[] {
  const work = xs.slice();
  work.push(lim);
  if (work.length > 3) work.splice(0, work.length - 3);
  work.reverse();
  work.fill(0, 1, -1);
  if (work.length > 0) work[0] = work[work.length - 1] + work.length;
  work.unshift(work.length);
  const dropped = work.pop();
  if (dropped === undefined) return work;
  work.push(dropped * 2);
  return work;
}
export function pushSelfRef(xs: readonly number[]): readonly number[] {
  const out: number[] = [];
  out.push(7);
  // JS evaluates both arguments before the first append: both read len 1.
  out.push(out.length, out.length);
  return out;
}
export function writeDuringForOf(xs: readonly number[]): readonly number[] {
  const work = xs.slice();
  const seen: number[] = [];
  for (const x of work) {
    seen.push(x);
    if (work.length > 2) work[2] = 99;
  }
  return seen.concat([-99], work);
}
`,
    calls: [
      { fn: "churn", args: [{ t: "nums", v: [1, 2, 3, 4, 5] }, f(6)] },
      { fn: "churn", args: [{ t: "nums", v: [] }, f(1)] },
      { fn: "churn", args: [{ t: "nums", v: [2] }, f(0.5)] },
      { fn: "pushSelfRef", args: [{ t: "nums", v: [] }] },
      { fn: "writeDuringForOf", args: [{ t: "nums", v: [1, 2, 3, 4] }] },
      { fn: "writeDuringForOf", args: [{ t: "nums", v: [1] }] },
    ],
  },
  {
    name: "prepend and multi-spread literals copy every segment in order",
    src: `
export function pre(xs: readonly number[], x: number): readonly number[] {
  return [x, ...xs];
}
export function stitch(a: readonly number[], b: readonly number[], x: number): readonly number[] {
  return [...a, x, ...b];
}
export function wrap(xs: readonly number[], lo: number, hi: number): readonly number[] {
  return [lo, ...xs, hi];
}
`,
    calls: [
      { fn: "pre", args: [{ t: "nums", v: [1, 2] }, f(9)] },
      { fn: "pre", args: [{ t: "nums", v: [] }, f(9)] },
      { fn: "stitch", args: [{ t: "nums", v: [1, 2] }, { t: "nums", v: [3] }, f(9)] },
      { fn: "stitch", args: [{ t: "nums", v: [] }, { t: "nums", v: [] }, f(9)] },
      { fn: "wrap", args: [{ t: "nums", v: [5, 6] }, f(0), f(7)] },
      { fn: "wrap", args: [{ t: "nums", v: [] }, f(0), f(7)] },
    ],
  },
  {
    name: "bytes slice clamps out-of-range and negative bounds exactly like JS",
    src: `
export function window(bytes: Uint8Array, from: number, to: number): Uint8Array {
  return bytes.slice(from, to);
}
export function tail(bytes: Uint8Array, from: number): Uint8Array {
  return bytes.slice(from);
}
`,
    calls: [
      { fn: "window", args: [{ t: "bytes", v: [1, 2, 3] }, i(1), i(99)] },
      { fn: "window", args: [{ t: "bytes", v: [1, 2, 3] }, i(-2), i(99)] },
      { fn: "window", args: [{ t: "bytes", v: [1, 2, 3] }, i(2), i(1)] },
      { fn: "window", args: [{ t: "bytes", v: [1, 2, 3] }, i(-99), i(99)] },
      { fn: "window", args: [{ t: "bytes", v: [1, 2, 3] }, i(5), i(9)] },
      { fn: "tail", args: [{ t: "bytes", v: [1, 2, 3] }, i(5)] },
      { fn: "tail", args: [{ t: "bytes", v: [1, 2, 3] }, i(-1)] },
      { fn: "tail", args: [{ t: "bytes", v: [] }, i(-1)] },
    ],
  },
  {
    name: "comptime division folds to the JS f64 value, signed zero and NaN included",
    src: `
export function nanv(): number { return 0 / 0; }
export function posInf(): number { return 1 / 0; }
export function negInf(): number { return -1 / 0; }
export function negZero(): number { return 0 / -1; }
export function half(): number { return 5 / 2; }
`,
    calls: [
      { fn: "nanv", args: [] },
      { fn: "posInf", args: [] },
      { fn: "negInf", args: [] },
      { fn: "negZero", args: [] },
      { fn: "half", args: [] },
    ],
  },
  {
    name: "block-body callbacks behave like their JS bodies, early returns included",
    src: `
export function bigMargins(xs: readonly number[], lim: number): readonly number[] {
  return xs.filter((x) => {
    if (x < 0) return false;
    const margin = x - lim;
    return margin > 0.5;
  });
}
export function firstSpecial(xs: readonly number[], want: number): number {
  const hit = xs.find((x) => {
    if (x === want) return true;
    return x > want * 2;
  });
  return hit ?? -1;
}
export function skewedTotal(xs: readonly number[], lim: number): number {
  return xs.reduce((sum, x) => {
    if (x > lim) return sum + x * 0.5;
    return sum + x;
  }, 0);
}
`,
    calls: [
      { fn: "bigMargins", args: [{ t: "nums", v: [-1, 2, 2.4, 3, 0.5] }, f(1.5)] },
      { fn: "bigMargins", args: [{ t: "nums", v: [] }, f(1.5)] },
      { fn: "firstSpecial", args: [{ t: "nums", v: [1, 9, 4] }, f(4)] },
      { fn: "firstSpecial", args: [{ t: "nums", v: [1, 2] }, f(4)] },
      { fn: "skewedTotal", args: [{ t: "nums", v: [0.1, 0.2, 10] }, f(1)] },
      { fn: "skewedTotal", args: [{ t: "nums", v: [] }, f(1)] },
    ],
  },
  {
    name: "Math floor/ceil/trunc corners: signed zeros, halves, NaN, infinities, big values",
    src: `
export function flo(x: number): number { return Math.floor(x); }
export function cei(x: number): number { return Math.ceil(x); }
export function tru(x: number): number { return Math.trunc(x); }
export function floInt(bytes: Uint8Array): number { return Math.floor(bytes.length); }
export function truInt(bytes: Uint8Array): number { return Math.trunc(bytes.length - 7); }
`,
    calls: [
      { fn: "flo", args: [f("-0")] },
      { fn: "flo", args: [f(0.5)] },
      { fn: "flo", args: [f(-0.5)] },
      { fn: "flo", args: [f("nan")] },
      { fn: "flo", args: [f("inf")] },
      { fn: "flo", args: [f("-inf")] },
      { fn: "flo", args: [f(4503599627370495.5)] },
      { fn: "cei", args: [f("-0")] },
      { fn: "cei", args: [f(-0.5)] },
      { fn: "cei", args: [f(0.5)] },
      { fn: "cei", args: [f("nan")] },
      { fn: "cei", args: [f(-4503599627370495.5)] },
      { fn: "tru", args: [f(-0.5)] },
      { fn: "tru", args: [f("-0")] },
      { fn: "tru", args: [f(2.9)] },
      { fn: "tru", args: [f(-2.9)] },
      { fn: "tru", args: [f("nan")] },
      { fn: "tru", args: [f("inf")] },
      { fn: "floInt", args: [{ t: "bytes", v: [1, 2, 3] }] },
      { fn: "truInt", args: [{ t: "bytes", v: [1, 2, 3] }] },
    ],
  },
  {
    name: "Math abs/sign/sqrt corners: -0 keeps or clears its sign exactly like JS",
    src: `
export function ab(x: number): number { return Math.abs(x); }
export function sg(x: number): number { return Math.sign(x); }
export function sq(x: number): number { return Math.sqrt(x); }
export function abInt(bytes: Uint8Array): number { return Math.abs(bytes.length - 10); }
export function sgInt(bytes: Uint8Array): number { return Math.sign(bytes.length - 2); }
`,
    calls: [
      { fn: "ab", args: [f("-0")] },
      { fn: "ab", args: [f(-5.5)] },
      { fn: "ab", args: [f("nan")] },
      { fn: "ab", args: [f("-inf")] },
      { fn: "sg", args: [f("-0")] },
      { fn: "sg", args: [f(0)] },
      { fn: "sg", args: [f("nan")] },
      { fn: "sg", args: [f(-3.5)] },
      { fn: "sg", args: [f("inf")] },
      { fn: "sg", args: [f("-inf")] },
      { fn: "sq", args: [f("-0")] },
      { fn: "sq", args: [f(-1)] },
      { fn: "sq", args: [f(2)] },
      { fn: "sq", args: [f("nan")] },
      { fn: "sq", args: [f("inf")] },
      { fn: "sq", args: [f(0)] },
      { fn: "abInt", args: [{ t: "bytes", v: [1, 2, 3] }] },
      { fn: "sgInt", args: [{ t: "bytes", v: [1] }] },
      { fn: "sgInt", args: [{ t: "bytes", v: [1, 2] }] },
      { fn: "sgInt", args: [{ t: "bytes", v: [1, 2, 3] }] },
    ],
  },
  {
    name: "Math min/max arities and comptime Math/% folds match node exactly",
    src: `
export const HALF = Math.floor(5 / 2);
export const ROOT = Math.sqrt(2);
export function noArgMin(): number { return Math.min(); }
export function noArgMax(): number { return Math.max(); }
export function oneArg(x: number): number { return Math.max(x); }
export function three(a: number, b: number, c: number): number { return Math.min(a, b, c); }
export function halfConst(): number { return HALF; }
export function rootConst(): number { return ROOT; }
export function floorDown(): number { return Math.floor(-5 / 2); }
export function ceilNegHalf(): number { return Math.ceil(-0.5); }
export function signNegZero(): number { return Math.sign(-0); }
export function remNan(): number { return 5 % 0; }
export function remNegZero(): number { return -5 % 5; }
export function remFrac(): number { return 5.5 % 2; }
`,
    calls: [
      { fn: "noArgMin", args: [] },
      { fn: "noArgMax", args: [] },
      { fn: "oneArg", args: [f("nan")] },
      { fn: "oneArg", args: [f("-0")] },
      { fn: "three", args: [f(2), f("nan"), f(1)] },
      { fn: "three", args: [f(2), f(0.5), f(1)] },
      { fn: "three", args: [f(0), f("-0"), f(0)] },
      { fn: "halfConst", args: [] },
      { fn: "rootConst", args: [] },
      { fn: "floorDown", args: [] },
      { fn: "ceilNegHalf", args: [] },
      { fn: "signNegZero", args: [] },
      { fn: "remNan", args: [] },
      { fn: "remNegZero", args: [] },
      { fn: "remFrac", args: [] },
    ],
  },
  {
    name: "Number classifiers agree with node over every float class",
    src: `
export function isInt(x: number): boolean { return Number.isInteger(x); }
export function isFin(x: number): boolean { return Number.isFinite(x); }
export function isNan(x: number): boolean { return Number.isNaN(x); }
export function intAlways(bytes: Uint8Array): boolean { return Number.isInteger(bytes.length); }
export function intNever(bytes: Uint8Array): boolean { return Number.isNaN(bytes.length); }
export function nanLit(): number { return NaN; }
export function negInfLit(): number { return -Infinity; }
export function isMax(x: number): boolean { return x === Infinity; }
`,
    calls: [
      { fn: "isInt", args: [f("-0")] },
      { fn: "isInt", args: [f(5)] },
      { fn: "isInt", args: [f(5.5)] },
      { fn: "isInt", args: [f("nan")] },
      { fn: "isInt", args: [f("inf")] },
      { fn: "isInt", args: [f(9007199254740992)] },
      { fn: "isFin", args: [f("nan")] },
      { fn: "isFin", args: [f("inf")] },
      { fn: "isFin", args: [f("-0")] },
      { fn: "isNan", args: [f("nan")] },
      { fn: "isNan", args: [f(1)] },
      { fn: "isNan", args: [f("inf")] },
      { fn: "intAlways", args: [{ t: "bytes", v: [7] }] },
      { fn: "intNever", args: [{ t: "bytes", v: [7] }] },
      { fn: "nanLit", args: [] },
      { fn: "negInfLit", args: [] },
      { fn: "isMax", args: [f("inf")] },
      { fn: "isMax", args: [f(1)] },
    ],
  },
  {
    name: "subarray resolves negative, crossed, and out-of-range bounds like JS (views, chained)",
    src: `
export function window(bytes: Uint8Array, from: number, to: number): Uint8Array {
  return bytes.subarray(from, to);
}
export function tail(bytes: Uint8Array, from: number): Uint8Array {
  return bytes.subarray(from);
}
export function whole(bytes: Uint8Array): Uint8Array {
  return bytes.subarray();
}
export function chained(bytes: Uint8Array, from: number): Uint8Array {
  return bytes.subarray(from).subarray(-2);
}
`,
    calls: [
      { fn: "window", args: [{ t: "bytes", v: [1, 2, 3] }, i(1), i(99)] },
      { fn: "window", args: [{ t: "bytes", v: [1, 2, 3] }, i(-2), i(99)] },
      { fn: "window", args: [{ t: "bytes", v: [1, 2, 3] }, i(2), i(1)] },
      { fn: "window", args: [{ t: "bytes", v: [1, 2, 3] }, i(-99), i(99)] },
      { fn: "window", args: [{ t: "bytes", v: [1, 2, 3] }, i(5), i(9)] },
      { fn: "window", args: [{ t: "bytes", v: [1, 2, 3] }, i(1), i(-1)] },
      { fn: "tail", args: [{ t: "bytes", v: [1, 2, 3] }, i(5)] },
      { fn: "tail", args: [{ t: "bytes", v: [1, 2, 3] }, i(-1)] },
      { fn: "tail", args: [{ t: "bytes", v: [] }, i(-1)] },
      { fn: "whole", args: [{ t: "bytes", v: [9, 8] }] },
      { fn: "chained", args: [{ t: "bytes", v: [1, 2, 3, 4] }, i(1)] },
      { fn: "chained", args: [{ t: "bytes", v: [1] }, i(0)] },
    ],
  },
  {
    name: "module const tables read identically: arrays, records, enums, derived scans",
    src: `
import { asciiBytes } from "@native-sdk/core";
export type Filter = "all" | "active" | "done";
export const WEEKDAYS = [3, 5, 2, 8];
export const FACTORS: readonly number[] = [0.5, 1, 2];
export const ORDER: readonly Filter[] = ["done", "active", "all"];
export const DEFAULT_FILTER: Filter = "active";
export interface Limits { readonly lo: number; readonly hi: number; }
export const LIMITS: Limits = { lo: 1, hi: 9 };
export const BAND: Limits = { lo: 0.75, hi: 9.5 };
export interface Task { readonly id: number; readonly title: Uint8Array; readonly done: boolean; }
export const SEEDS: readonly Task[] = [
  { id: 1, title: asciiBytes("Ship"), done: false },
  { id: 2, title: asciiBytes("Test"), done: true },
];
export function weekdayAt(i: number): number { return WEEKDAYS[i]; }
export function weekdayCount(): number { return WEEKDAYS.length; }
export function weekdayTotal(): number {
  let t = 0;
  for (const w of WEEKDAYS) t += w;
  return t;
}
export function bigWeekdays(lim: number): readonly number[] { return WEEKDAYS.filter((w) => w > lim); }
export function factorAt(i: number): number { return FACTORS[i]; }
export function orderAt(i: number): Filter { return ORDER[i]; }
export function fallbackFilter(): Filter { return DEFAULT_FILTER; }
export function inRange(n: Uint8Array): boolean { return n.length >= LIMITS.lo && n.length <= LIMITS.hi; }
export function inBand(x: number): boolean { return x >= BAND.lo && x <= BAND.hi; }
export function seedTitle(i: number): Uint8Array { return SEEDS[i].title; }
export function doneSeedIds(): readonly number[] {
  return SEEDS.filter((s) => s.done).map((s) => s.id);
}
`,
    calls: [
      { fn: "weekdayAt", args: [i(0)] },
      { fn: "weekdayAt", args: [i(3)] },
      { fn: "weekdayCount", args: [] },
      { fn: "weekdayTotal", args: [] },
      { fn: "bigWeekdays", args: [f(3)] },
      { fn: "bigWeekdays", args: [f(99)] },
      { fn: "factorAt", args: [i(0)] },
      { fn: "orderAt", args: [i(0)] },
      { fn: "orderAt", args: [i(2)] },
      { fn: "fallbackFilter", args: [] },
      { fn: "inRange", args: [{ t: "bytes", v: [1, 2, 3] }] },
      { fn: "inRange", args: [{ t: "bytes", v: [] }] },
      { fn: "inBand", args: [f(5)] },
      { fn: "inBand", args: [f(0.5)] },
      { fn: "inBand", args: [f(0.75)] },
      { fn: "seedTitle", args: [i(0)] },
      { fn: "seedTitle", args: [i(1)] },
      { fn: "doneSeedIds", args: [] },
    ],
  },
  {
    name: "type-changing map: scalars out of records, bytes out, optional results, block bodies",
    src: `
export interface Task { readonly id: number; readonly title: Uint8Array; readonly streak: number; }
export interface Model { readonly tasks: readonly Task[]; }
export type Msg = { readonly kind: "seed"; readonly streak: number } | { readonly kind: "noop" };
export function initialModel(): Model { return { tasks: [] }; }
export function update(model: Model, msg: Msg): Model {
  switch (msg.kind) {
    case "seed": {
      const id = model.tasks.length + 1;
      const task: Task = { id: id, title: new Uint8Array(0), streak: msg.streak };
      return { tasks: [...model.tasks, task] };
    }
    case "noop": return model;
  }
}
export function ids(model: Model): readonly number[] { return model.tasks.map((t) => t.id); }
export function doubled(model: Model): readonly number[] { return model.tasks.map((t) => t.streak * 2); }
export function capped(model: Model, lim: number): readonly number[] {
  return model.tasks.map((t) => {
    if (t.streak > lim) return lim;
    return t.streak;
  });
}
export function mappedCount(model: Model): number { return model.tasks.map((t) => t.id).length; }
export function orNull(xs: readonly number[]): readonly (number | null)[] {
  return xs.map((x) => (x > 0 ? x : null));
}
`,
    node: `
{
  let model = mod.initialModel();
  for (const s of [2, 0.5, 7]) model = mod.update(model, { kind: "seed", streak: s });
  line("m0", mod.ids(model));
  line("m1", mod.doubled(model));
  line("m2", mod.capped(model, 2));
  line("m3", mod.mappedCount(model));
  line("m4", mod.orNull([1, -1, 0, 2.5]));
  line("m5", mod.orNull([]));
}
`,
    zig: `
    {
        var model = m.initialModel();
        for ([_]f64{ 2, 0.5, 7 }) |s| model = m.update(model, .{ .seed = s });
        row("m0", m.ids(model));
        row("m1", m.doubled(model));
        row("m2", m.capped(model, 2));
        row("m3", m.mappedCount(model));
        row("m4", m.orNull(&[_]f64{ 1, -1, 0, 2.5 }));
        row("m5", m.orNull(&[_]f64{}));
    }
`,
  },
  {
    name: "callback index parameters count exactly like JS across map/filter/scans",
    src: `
export function weighted(xs: readonly number[]): readonly number[] { return xs.map((x, i) => x * i); }
export function evenSlots(xs: readonly number[]): readonly number[] { return xs.filter((x, i) => i % 2 === 0); }
export function lateBig(xs: readonly number[], at: number): number {
  return xs.find((x, i) => i > at && x > 0) ?? -1;
}
export function lateAt(xs: readonly number[], at: number): number {
  return xs.findIndex((x, i) => i >= at && x > 0);
}
export function anyLate(xs: readonly number[], at: number): boolean {
  return xs.some((x, i) => i > at);
}
export function frontLoaded(xs: readonly number[]): boolean {
  return xs.every((x, i) => x >= i);
}
`,
    calls: [
      { fn: "weighted", args: [{ t: "nums", v: [5, 6, 7] }] },
      { fn: "weighted", args: [{ t: "nums", v: ["-0", 2] }] },
      { fn: "weighted", args: [{ t: "nums", v: [] }] },
      { fn: "evenSlots", args: [{ t: "nums", v: [5, 6, 7, 8] }] },
      { fn: "evenSlots", args: [{ t: "nums", v: [] }] },
      { fn: "lateBig", args: [{ t: "nums", v: [9, -1, 4] }, i(0)] },
      { fn: "lateBig", args: [{ t: "nums", v: [9, -1] }, i(0)] },
      { fn: "lateAt", args: [{ t: "nums", v: [9, -1, 4] }, i(1)] },
      { fn: "lateAt", args: [{ t: "nums", v: [9] }, i(1)] },
      { fn: "anyLate", args: [{ t: "nums", v: [1, 2] }, i(0)] },
      { fn: "anyLate", args: [{ t: "nums", v: [1] }, i(5)] },
      { fn: "frontLoaded", args: [{ t: "nums", v: [0, 1, 2] }] },
      { fn: "frontLoaded", args: [{ t: "nums", v: [0, 0.5] }] },
      { fn: "frontLoaded", args: [{ t: "nums", v: [] }] },
    ],
  },
  {
    name: "array-method calls in if/else-if and ternary conditions behave identically",
    src: `
export function grade(xs: readonly number[], flag: boolean): number {
  if (flag) return -1;
  else if (xs.some((x) => x > 3)) return 1;
  else if (xs.every((x) => x < 0)) return 2;
  return 0;
}
export function countIf(xs: readonly number[], lim: number): number {
  if (xs.filter((x) => x > lim).length > 1) return 2;
  return xs.findIndex((x) => x > lim) >= 0 ? 1 : 0;
}
`,
    calls: [
      { fn: "grade", args: [{ t: "nums", v: [1, 5] }, { t: "b", v: true }] },
      { fn: "grade", args: [{ t: "nums", v: [1, 5] }, { t: "b", v: false }] },
      { fn: "grade", args: [{ t: "nums", v: [-1, -2] }, { t: "b", v: false }] },
      { fn: "grade", args: [{ t: "nums", v: [1, 2] }, { t: "b", v: false }] },
      { fn: "grade", args: [{ t: "nums", v: [] }, { t: "b", v: false }] },
      { fn: "countIf", args: [{ t: "nums", v: [5, 6, 1] }, f(4)] },
      { fn: "countIf", args: [{ t: "nums", v: [5, 1] }, f(4)] },
      { fn: "countIf", args: [{ t: "nums", v: [1] }, f(4)] },
    ],
  },
  {
    name: "switch on a literal-union value matches JS clause selection exactly",
    src: `
export type Filter = "all" | "active" | "done";
export type Bit = 0 | 1;
export function label(f: Filter): number {
  switch (f) {
    case "all": return 0;
    case "active": return 1;
    case "done": return 2;
  }
}
export function sharedBody(f: Filter): number {
  switch (f) {
    case "active":
    case "done":
      return 1;
    default:
      return 0;
  }
}
export function partial(f: Filter): number {
  let n = 0;
  switch (f) {
    case "done":
      n = 5;
      break;
    case "active": {
      n = 2;
      break;
    }
  }
  return n;
}
export function flip(b: Bit): number {
  switch (b) {
    case 0: return 1;
    case 1: return 0;
  }
}
`,
    calls: [
      { fn: "label", args: [{ t: "tag", v: "all" }] },
      { fn: "label", args: [{ t: "tag", v: "active" }] },
      { fn: "label", args: [{ t: "tag", v: "done" }] },
      { fn: "sharedBody", args: [{ t: "tag", v: "active" }] },
      { fn: "sharedBody", args: [{ t: "tag", v: "done" }] },
      { fn: "sharedBody", args: [{ t: "tag", v: "all" }] },
      { fn: "partial", args: [{ t: "tag", v: "done" }] },
      { fn: "partial", args: [{ t: "tag", v: "active" }] },
      { fn: "partial", args: [{ t: "tag", v: "all" }] },
      { fn: "flip", args: [i(0)] },
      { fn: "flip", args: [i(1)] },
    ],
  },
  {
    name: "model union arm churn: alternating arms with deep payloads across committed dispatches",
    // A tiny heap makes the two-space flip fire DURING arm churn: every arm
    // switch kills the old payload, and compaction must copy only through
    // the live arm — a stale-pointer chase would trap or diverge here.
    options: { frameCap: 32768, heapCap: 4096 },
    src: `
import { asciiBytes } from "@native-sdk/core";
export interface Note { readonly id: number; readonly title: Uint8Array; }
export type View =
  | { readonly kind: "list"; readonly scroll: number }
  | { readonly kind: "detail"; readonly note: Note; readonly tags: readonly number[] }
  | { readonly kind: "compose"; readonly draft: Uint8Array };
export interface Model { readonly view: View; readonly visits: number; }
export type Msg =
  | { readonly kind: "open"; readonly id: number }
  | { readonly kind: "compose_new" }
  | { readonly kind: "back" };
export function initialModel(): Model {
  return { view: { kind: "list", scroll: 0 }, visits: 0 };
}
export function update(model: Model, msg: Msg): Model {
  switch (msg.kind) {
    case "open":
      return {
        view: { kind: "detail", note: { id: msg.id, title: asciiBytes(\`note \${msg.id & 255}\`) }, tags: [msg.id, msg.id * 2] },
        visits: model.visits + 1,
      };
    case "compose_new":
      return { view: { kind: "compose", draft: asciiBytes("draft") }, visits: model.visits + 1 };
    case "back":
      return { view: { kind: "list", scroll: model.visits }, visits: model.visits + 1 };
  }
}
export function summary(model: Model): number {
  switch (model.view.kind) {
    case "list": return model.view.scroll;
    case "detail": return model.view.note.id + model.view.tags.length;
    case "compose": return model.view.draft.length;
  }
}
export function title(model: Model): Uint8Array {
  if (model.view.kind === "detail") return model.view.note.title;
  return new Uint8Array(0);
}
export function tagSum(model: Model): number {
  if (model.view.kind === "detail") return model.view.tags.reduce((s, t) => s + t, 0);
  return -1;
}
`,
    node: `
{
  let model = mod.initialModel();
  line("a0", mod.summary(model));
  const script = [
    { kind: "open", id: 7 }, { kind: "compose_new" }, { kind: "back" },
    { kind: "open", id: 40 }, { kind: "open", id: 3 }, { kind: "back" },
    { kind: "compose_new" }, { kind: "open", id: 12 },
  ];
  for (const msg of script) {
    model = mod.update(model, msg);
    line("st", mod.summary(model));
    line("ti", mod.title(model));
    line("tg", mod.tagSum(model));
  }
  line("a1", model.visits);
  for (let r = 0; r < 90; r++) {
    const msg = r % 3 === 0 ? { kind: "open", id: r } : r % 3 === 1 ? { kind: "compose_new" } : { kind: "back" };
    model = mod.update(model, msg);
    if (r % 15 === 0) {
      line("cs", mod.summary(model));
      line("ct", mod.title(model));
    }
  }
  line("cmp", true);
  line("a2", mod.summary(model));
}
`,
    zig: `
    {
        m.rt.resetAll();
        var model = m.commitModelRoot(m.initialModel());
        m.rt.frameReset();
        row("a0", m.summary(model));
        const script = [_]m.Msg{
            .{ .open = 7 }, .compose_new, .back,
            .{ .open = 40 }, .{ .open = 3 }, .back,
            .compose_new, .{ .open = 12 },
        };
        for (script) |msg| {
            model = m.commitModelRoot(m.update(model, msg));
            m.rt.frameReset();
            row("st", m.summary(model));
            row("ti", m.title(model));
            row("tg", m.tagSum(model));
        }
        row("a1", model.visits);
        var r: i64 = 0;
        while (r < 90) : (r += 1) {
            const msg: m.Msg = if (@rem(r, 3) == 0) .{ .open = r } else if (@rem(r, 3) == 1) .compose_new else .back;
            model = m.commitModelRoot(m.update(model, msg));
            m.rt.frameReset();
            if (@rem(r, 15) == 0) {
                row("cs", m.summary(model));
                row("ct", m.title(model));
            }
        }
        row("cmp", m.rt.stat_compactions > 0);
        row("a2", m.summary(model));
    }
`,
  },
  {
    name: "primitive arrays in the model: grow/shrink/replace churn and structural sharing",
    src: `
export interface Model { readonly xs: readonly number[]; readonly flags: readonly boolean[]; readonly ticks: number; }
export type Msg =
  | { readonly kind: "push"; readonly v: number }
  | { readonly kind: "double" }
  | { readonly kind: "drop_first" }
  | { readonly kind: "mark"; readonly on: boolean }
  | { readonly kind: "replace" }
  | { readonly kind: "noop" };
export function initialModel(): Model { return { xs: [], flags: [], ticks: 0 }; }
export function update(model: Model, msg: Msg): Model {
  switch (msg.kind) {
    case "push": return { ...model, xs: [...model.xs, msg.v], ticks: model.ticks + 1 };
    case "double": return { ...model, xs: model.xs.map((x) => x * 2), ticks: model.ticks + 1 };
    case "drop_first": return { ...model, xs: model.xs.slice(1), ticks: model.ticks + 1 };
    case "mark": return { ...model, flags: [...model.flags, msg.on], ticks: model.ticks + 1 };
    case "replace": return { ...model, xs: [0.5, -0.5, 3], ticks: model.ticks + 1 };
    case "noop": return { ...model, ticks: model.ticks + 1 };
  }
}
export function xsNow(model: Model): readonly number[] { return model.xs; }
export function trueCount(model: Model): number { return model.flags.filter((f) => f).length; }
`,
    node: `
{
  let model = mod.initialModel();
  const script = [
    { kind: "push", v: 1.5 }, { kind: "push", v: 2 }, { kind: "push", v: 3 },
    { kind: "double" }, { kind: "mark", on: true }, { kind: "drop_first" },
    { kind: "push", v: 4 }, { kind: "replace" }, { kind: "mark", on: false }, { kind: "double" },
  ];
  for (const msg of script) {
    model = mod.update(model, msg);
    line("xs", mod.xsNow(model));
    line("tc", mod.trueCount(model));
  }
  model = mod.update(model, { kind: "noop" });
  line("shr", true);
  line("xs2", mod.xsNow(model));
}
`,
    zig: `
    {
        m.rt.resetAll();
        var model = m.commitModelRoot(m.initialModel());
        m.rt.frameReset();
        const script = [_]m.Msg{
            .{ .push = 1.5 }, .{ .push = 2 }, .{ .push = 3 },
            .double, .{ .mark = true }, .drop_first,
            .{ .push = 4 }, .replace, .{ .mark = false }, .double,
        };
        for (script) |msg| {
            model = m.commitModelRoot(m.update(model, msg));
            m.rt.frameReset();
            row("xs", m.xsNow(model));
            row("tc", m.trueCount(model));
        }
        // Structural sharing: a dispatch that reuses every array commits
        // only the model struct itself (pointer-shared slices copy nothing).
        model = m.commitModelRoot(m.update(model, .noop));
        m.rt.frameReset();
        row("shr", m.rt.stat_commit_last <= @sizeOf(m.Model) + 16);
        row("xs2", m.xsNow(model));
    }
`,
  },
  {
    name: "optional model fields: set/clear cycles over records, bytes, and numbers",
    src: `
import { asciiBytes } from "@native-sdk/core";
export interface Sel { readonly at: number; readonly len: number; }
export interface Model { readonly sel: Sel | null; readonly note: Uint8Array | null; readonly last: number | null; }
export type Msg =
  | { readonly kind: "pick"; readonly at: number; readonly len: number }
  | { readonly kind: "annotate" }
  | { readonly kind: "clear" };
export function initialModel(): Model { return { sel: null, note: null, last: null }; }
export function update(model: Model, msg: Msg): Model {
  switch (msg.kind) {
    case "pick": return { sel: { at: msg.at, len: msg.len }, note: model.note, last: msg.at };
    case "annotate":
      return { ...model, note: model.sel !== null && model.sel.len > 0 ? asciiBytes("picked") : null };
    case "clear": return { sel: null, note: null, last: model.last };
  }
}
export function selWidth(model: Model): number {
  return model.sel !== null && model.sel.len > 2 ? model.sel.len : 0;
}
export function noteLen(model: Model): number {
  return model.note === null || model.note.length === 0 ? -1 : model.note.length;
}
export function hasSel(model: Model): boolean {
  return model.sel !== null && model.sel.at >= 0;
}
export function lastOr(model: Model): number {
  return model.last ?? -7;
}
`,
    node: `
{
  let model = mod.initialModel();
  const script = [
    { kind: "annotate" }, { kind: "pick", at: 4, len: 3 }, { kind: "annotate" },
    { kind: "clear" }, { kind: "pick", at: 1, len: 9 }, { kind: "annotate" },
    { kind: "pick", at: -2, len: 0 }, { kind: "annotate" }, { kind: "clear" },
  ];
  for (const msg of script) {
    model = mod.update(model, msg);
    line("w", mod.selWidth(model));
    line("n", mod.noteLen(model));
    line("h", mod.hasSel(model));
    line("l", mod.lastOr(model));
  }
}
`,
    zig: `
    {
        m.rt.resetAll();
        var model = m.commitModelRoot(m.initialModel());
        m.rt.frameReset();
        const script = [_]m.Msg{
            .annotate, .{ .pick = .{ .at = 4, .len = 3 } }, .annotate,
            .clear, .{ .pick = .{ .at = 1, .len = 9 } }, .annotate,
            .{ .pick = .{ .at = -2, .len = 0 } }, .annotate, .clear,
        };
        for (script) |msg| {
            model = m.commitModelRoot(m.update(model, msg));
            m.rt.frameReset();
            row("w", m.selWidth(model));
            row("n", m.noteLen(model));
            row("h", m.hasSel(model));
            row("l", m.lastOr(model));
        }
    }
`,
  },
  {
    name: "null-guarded chains: && / || narrowing over optionals, both orders, loops",
    src: `
export interface Box { readonly items: readonly number[]; readonly tag: number; }
export function hasBig(box: Box | null, lim: number): boolean {
  return box !== null && box.items.length > 0 && box.tag > lim;
}
export function emptyish(box: Box | null): boolean {
  return box === null || box.items.length === 0;
}
export function pickTag(box: Box | null): number {
  return box !== null && box.tag > 0 ? box.tag : -1;
}
export function guardRight(box: Box | null): number {
  if (null !== box && box.tag >= 0) return box.tag + 100;
  return -100;
}
export function below(cls: number | null, lim: number): boolean {
  return cls !== null && cls < lim;
}
export function clamp(cls: number | null): number {
  if (cls === null || cls < 0) return 0;
  return cls;
}
export function walkDown(seed: number): number {
  let cur: Box | null = { items: [seed], tag: seed };
  let hops = 0;
  while (cur !== null && cur.tag > 0) {
    hops += 1;
    cur = cur.tag > 1 ? { items: cur.items, tag: cur.tag - 1 } : null;
  }
  return hops;
}
`,
    node: `
{
  line("d0", mod.hasBig(null, 1));
  line("d1", mod.hasBig({ items: [1, 2], tag: 5 }, 1));
  line("d2", mod.hasBig({ items: [], tag: 5 }, 1));
  line("d3", mod.hasBig({ items: [1], tag: 0 }, 1));
  line("d4", mod.emptyish(null));
  line("d5", mod.emptyish({ items: [], tag: 1 }));
  line("d6", mod.emptyish({ items: [2], tag: 1 }));
  line("d7", mod.pickTag(null));
  line("d8", mod.pickTag({ items: [], tag: 9 }));
  line("d9", mod.pickTag({ items: [], tag: -9 }));
  line("d10", mod.guardRight(null));
  line("d11", mod.guardRight({ items: [], tag: 4 }));
  line("d12", mod.below(null, 5));
  line("d13", mod.below(3, 5));
  line("d14", mod.below(7, 5));
  line("d15", mod.clamp(null));
  line("d16", mod.clamp(-3));
  line("d17", mod.clamp(6));
  line("d18", mod.walkDown(4));
  line("d19", mod.walkDown(0));
}
`,
    zig: `
    {
        row("d0", m.hasBig(null, 1));
        row("d1", m.hasBig(.{ .items = &.{ 1, 2 }, .tag = 5 }, 1));
        row("d2", m.hasBig(.{ .items = &.{}, .tag = 5 }, 1));
        row("d3", m.hasBig(.{ .items = &.{1}, .tag = 0 }, 1));
        row("d4", m.emptyish(null));
        row("d5", m.emptyish(.{ .items = &.{}, .tag = 1 }));
        row("d6", m.emptyish(.{ .items = &.{2}, .tag = 1 }));
        row("d7", m.pickTag(null));
        row("d8", m.pickTag(.{ .items = &.{}, .tag = 9 }));
        row("d9", m.pickTag(.{ .items = &.{}, .tag = -9 }));
        row("d10", m.guardRight(null));
        row("d11", m.guardRight(.{ .items = &.{}, .tag = 4 }));
        row("d12", m.below(null, 5));
        row("d13", m.below(3, 5));
        row("d14", m.below(7, 5));
        row("d15", m.clamp(null));
        row("d16", m.clamp(-3));
        row("d17", m.clamp(6));
        row("d18", m.walkDown(4));
        row("d19", m.walkDown(0));
    }
`,
  },
  {
    name: "-0 literals and -0-producing arithmetic keep the signed zero end to end",
    src: `
export function negZero(): number { return -0; }
export function prodNegZero(): number { return 0 * -1; }
export function viaConst(): number { const z = -0; return z; }
export function timesNeg(x: number): number { return x * -1; }
export function plusZero(x: number): number { return -0 + x; }
`,
    calls: [
      { fn: "negZero", args: [] },
      { fn: "prodNegZero", args: [] },
      { fn: "viaConst", args: [] },
      { fn: "timesNeg", args: [f(0)] },
      { fn: "timesNeg", args: [f("-0")] },
      { fn: "timesNeg", args: [f(2.5)] },
      { fn: "plusZero", args: [f(0)] },
      { fn: "plusZero", args: [f("-0")] },
    ],
  },
  {
    name: "nested callbacks with shared element/index names fold identically",
    src: `
export function weights(xs: readonly number[]): number {
  return xs.map((x, i) => xs.map((y, i2) => y * i2 + i).reduce((acc, v) => acc + v, 0) + x * i).reduce((acc, v) => acc + v, 0);
}
export function pairs(xs: readonly number[]): number {
  return xs.map((x, i) => xs.map((x2, j) => x2 * x + j * i).reduce((a, v) => a + v, 0)).reduce((a, v) => a + v, 0);
}
`,
    calls: [
      { fn: "weights", args: [{ t: "nums", v: [1.5, 2, -3] }] },
      { fn: "weights", args: [{ t: "nums", v: [] }] },
      { fn: "pairs", args: [{ t: "nums", v: [2, 3] }] },
      { fn: "pairs", args: [{ t: "nums", v: [0.5] }] },
    ],
  },
  {
    name: "host-boundary params stay f64: fractional host values compare exactly",
    // Regression (round 2C): comparison against an i64-classed value (a
    // length read, a byte read) must NOT claim an exported parameter to
    // i64 — the host may pass a fraction there, and node compares it
    // exactly. The 2.5/7.5 calls fail to even compile if the claim comes
    // back (the native driver would pass a fraction to an i64 parameter).
    src: `
export function lenIs(bytes: Uint8Array, want: number): boolean {
  return bytes.length === want;
}
export function badge(bytes: Uint8Array, want: number): number {
  return bytes.length === want ? 1 : 0;
}
export function firstIs(bytes: Uint8Array, want: number): boolean {
  return bytes[0] === want;
}
export function pastEnd(bytes: Uint8Array, cursor: number): boolean {
  return cursor >= bytes.length;
}
`,
    calls: [
      { fn: "lenIs", args: [{ t: "bytes", v: [1, 2, 3] }, f(3)] },
      { fn: "lenIs", args: [{ t: "bytes", v: [1, 2, 3] }, f(2.5)] },
      { fn: "lenIs", args: [{ t: "bytes", v: [] }, f(0)] },
      { fn: "lenIs", args: [{ t: "bytes", v: [] }, f("-0")] },
      { fn: "lenIs", args: [{ t: "bytes", v: [1] }, f("nan")] },
      { fn: "badge", args: [{ t: "bytes", v: [1, 2] }, f(2)] },
      { fn: "badge", args: [{ t: "bytes", v: [1, 2] }, f(1.5)] },
      { fn: "firstIs", args: [{ t: "bytes", v: [7, 8] }, f(7)] },
      { fn: "firstIs", args: [{ t: "bytes", v: [7, 8] }, f(7.5)] },
      { fn: "pastEnd", args: [{ t: "bytes", v: [1, 2] }, f(1.5)] },
      { fn: "pastEnd", args: [{ t: "bytes", v: [1, 2] }, f(2)] },
      { fn: "pastEnd", args: [{ t: "bytes", v: [] }, f("-0")] },
    ],
  },
  {
    name: "Cmd v2 host payloads: bytes (empty, large, non-ASCII) and derived records",
    src: `
import { Cmd, asciiBytes } from "@native-sdk/core";
export interface Model { readonly count: number; }
export type Msg =
  | { readonly kind: "put"; readonly blob: Uint8Array }
  | { readonly kind: "empty" }
  | { readonly kind: "cfg"; readonly gain: number; readonly on: boolean };
export function initialModel(): Model { return { count: 0 }; }
export function update(model: Model, msg: Msg): Model | [Model, Cmd<Msg>] {
  switch (msg.kind) {
    case "put": return [{ count: model.count + 1 }, Cmd.host("blob.write", msg.blob)];
    case "empty": return [model, Cmd.host("blob.write", new Uint8Array(0))];
    case "cfg": return [model, Cmd.host("cfg.save", { gain: msg.gain, on: msg.on, tag: asciiBytes("v2") })];
  }
}
`,
    node: `
{
  // Mirror of the rt kernel's Cmd wire format v2 host_bytes record:
  // [0x04][name_len u8][name][payload_len u32 LE][payload].
  const enc = (cmd) => {
    if (cmd.op === "none") return [];
    if (cmd.op === "host_bytes") {
      const name = Array.from(new TextEncoder().encode(cmd.name));
      const len = cmd.payload.length;
      return [4, name.length, ...name, len & 255, (len >> 8) & 255, (len >> 16) & 255, (len >>> 24) & 255, ...cmd.payload];
    }
    return cmd.cmds.flatMap(enc);
  };
  const step = (model, msg) => {
    const r = mod.update(model, msg);
    return Array.isArray(r) ? [r[0], Uint8Array.from(enc(r[1]))] : [r, new Uint8Array(0)];
  };
  let model = mod.initialModel();
  let cmd;
  const big = Uint8Array.from({ length: 300 }, (_, i) => (i * 7) % 251);
  [model, cmd] = step(model, { kind: "put", blob: big });
  line("h0", cmd);
  [model, cmd] = step(model, { kind: "put", blob: Uint8Array.from([0, 255, 128, 10]) });
  line("h1", cmd);
  [model, cmd] = step(model, { kind: "empty" });
  line("h2", cmd);
  [model, cmd] = step(model, { kind: "cfg", gain: 2.5, on: true });
  line("h3", cmd);
  [model, cmd] = step(model, { kind: "cfg", gain: -0, on: false });
  line("h4", cmd);
  line("h5", model.count);
}
`,
    zig: `
    {
        var model = m.initialModel();
        var big: [300]u8 = undefined;
        for (&big, 0..) |*b, i| b.* = @intCast((i * 7) % 251);
        var r = m.update(model, .{ .put = &big });
        model = r.model;
        row("h0", r.cmd);
        r = m.update(model, .{ .put = &[_]u8{ 0, 255, 128, 10 } });
        model = r.model;
        row("h1", r.cmd);
        r = m.update(model, .empty);
        model = r.model;
        row("h2", r.cmd);
        r = m.update(model, .{ .cfg = .{ .gain = 2.5, .on = true } });
        model = r.model;
        row("h3", r.cmd);
        r = m.update(model, .{ .cfg = .{ .gain = -0.0, .on = false } });
        model = r.model;
        row("h4", r.cmd);
        row("h5", model.count);
    }
`,
  },
  {
    name: "Cmd v2 routed requests: init command, ok and err arms delivered as Msgs, cancel",
    src: `
import { Cmd, asciiBytes } from "@native-sdk/core";
export interface Model { readonly data: Uint8Array; readonly errs: number; }
export type Msg =
  | { readonly kind: "load" }
  | { readonly kind: "bad" }
  | { readonly kind: "stop" }
  | { readonly kind: "loaded"; readonly body: Uint8Array }
  | { readonly kind: "failed"; readonly why: Uint8Array };
export function initialModel(): [Model, Cmd<Msg>] {
  return [
    { data: new Uint8Array(0), errs: 0 },
    Cmd.request("store.read", asciiBytes("boot.bin"), { key: "boot", ok: "loaded", err: "failed" }),
  ];
}
export function update(model: Model, msg: Msg): Model | [Model, Cmd<Msg>] {
  switch (msg.kind) {
    case "load": return [model, Cmd.request("store.read", asciiBytes("notes.json"), { key: "load", ok: "loaded", err: "failed" })];
    case "bad": return [model, Cmd.request("store.read", asciiBytes("missing.bin"), { ok: "loaded", err: "failed" })];
    case "stop": return [model, Cmd.cancel("load")];
    case "loaded": return { ...model, data: msg.body };
    case "failed": return { ...model, errs: model.errs + 1 };
  }
}
export function dataLen(model: Model): number { return model.data.length; }
`,
    node: `
{
  const kinds = ["load", "bad", "stop", "loaded", "failed"];
  // Mirror of the v2 request/cancel records:
  //   request [0x05][name_len][name][key_len][key][ok][err][len u32 LE][payload]
  //   cancel  [0x06][key_len][key]
  const enc = (cmd) => {
    if (cmd.op === "none") return [];
    if (cmd.op === "cancel") {
      const key = Array.from(new TextEncoder().encode(cmd.key));
      return [6, key.length, ...key];
    }
    if (cmd.op === "request") {
      const name = Array.from(new TextEncoder().encode(cmd.name));
      const key = Array.from(new TextEncoder().encode(cmd.key));
      const p = cmd.payload;
      return [5, name.length, ...name, key.length, ...key, kinds.indexOf(cmd.okKind), kinds.indexOf(cmd.errKind), p.length & 255, (p.length >> 8) & 255, (p.length >> 16) & 255, (p.length >>> 24) & 255, ...p];
    }
    return cmd.cmds.flatMap(enc);
  };
  const step = (model, msg) => {
    const r = mod.update(model, msg);
    return Array.isArray(r) ? [r[0], Uint8Array.from(enc(r[1]))] : [r, new Uint8Array(0)];
  };
  // A scripted host: read the routing tags off the wire and answer with an
  // ordinary Msg built from the named arm's declared shape.
  const routeTags = (bytes) => {
    let at = 1;
    at += 1 + bytes[at];
    at += 1 + bytes[at];
    return [bytes[at], bytes[at + 1]];
  };
  const respond = (model, bytes, okBody, errWhy) => {
    const [ok, err] = routeTags(bytes);
    const msg = okBody !== null ? { kind: kinds[ok], body: okBody } : { kind: kinds[err], why: errWhy };
    return step(model, msg);
  };
  const bytesOf = (s) => new TextEncoder().encode(s);
  const boot = mod.initialModel();
  let model = boot[0];
  let cmd = Uint8Array.from(enc(boot[1]));
  line("r0", cmd);
  [model, cmd] = respond(model, cmd, bytesOf("boot bytes"), null);
  line("r1", cmd);
  line("r2", model.data);
  [model, cmd] = step(model, { kind: "load" });
  line("r3", cmd);
  [model, cmd] = respond(model, cmd, Uint8Array.from([1, 2, 3]), null);
  line("r4", model.data);
  [model, cmd] = step(model, { kind: "bad" });
  line("r5", cmd);
  [model, cmd] = respond(model, cmd, null, bytesOf("not found"));
  line("r6", model.errs);
  line("r7", model.data);
  [model, cmd] = step(model, { kind: "stop" });
  line("r8", cmd);
  line("r9", mod.dataLen(model));
}
`,
    zig: `
    {
        const Host = struct {
            // Read [ok_tag, err_tag] off a wire request record.
            fn routeTags(bytes: []const u8) [2]u8 {
                var at: usize = 1;
                at += 1 + bytes[at];
                at += 1 + bytes[at];
                return .{ bytes[at], bytes[at + 1] };
            }
        };
        const loaded_tag: u8 = @intFromEnum(std.meta.Tag(m.Msg).loaded);
        const boot = m.initialModel();
        var model = boot.model;
        row("r0", boot.cmd);
        var t = Host.routeTags(boot.cmd);
        var r = m.update(model, if (t[0] == loaded_tag) m.Msg{ .loaded = "boot bytes" } else m.Msg{ .failed = "?" });
        model = r.model;
        row("r1", r.cmd);
        row("r2", model.data);
        r = m.update(model, .load);
        model = r.model;
        row("r3", r.cmd);
        t = Host.routeTags(r.cmd);
        r = m.update(model, if (t[0] == loaded_tag) m.Msg{ .loaded = &[_]u8{ 1, 2, 3 } } else m.Msg{ .failed = "?" });
        model = r.model;
        row("r4", model.data);
        r = m.update(model, .bad);
        model = r.model;
        row("r5", r.cmd);
        t = Host.routeTags(r.cmd);
        r = m.update(model, if (t[1] == @intFromEnum(std.meta.Tag(m.Msg).failed)) m.Msg{ .failed = "not found" } else m.Msg{ .loaded = "?" });
        model = r.model;
        row("r6", model.errs);
        row("r7", model.data);
        r = m.update(model, .stop);
        model = r.model;
        row("r8", r.cmd);
        row("r9", m.dataLen(model));
    }
`,
  },
  {
    name: "subscriptions under virtual time: reconcile-by-key, re-arm on interval change, pause and resume",
    src: `
import { Sub } from "@native-sdk/core";
export interface Model { readonly running: boolean; readonly fast: boolean; readonly ticks: number; readonly blinks: number; readonly lastAt: number; }
export type Msg =
  | { readonly kind: "toggle" }
  | { readonly kind: "speed" }
  | { readonly kind: "tick"; readonly at: number }
  | { readonly kind: "blink"; readonly at: number };
export function initialModel(): Model {
  return { running: true, fast: false, ticks: 0, blinks: 0, lastAt: -1 };
}
export function update(model: Model, msg: Msg): Model {
  switch (msg.kind) {
    case "toggle": return { ...model, running: !model.running };
    case "speed": return { ...model, fast: !model.fast };
    case "tick": return { ...model, ticks: model.ticks + 1, lastAt: msg.at };
    case "blink": return { ...model, blinks: model.blinks + 1, lastAt: msg.at };
  }
}
export function subscriptions(model: Model): Sub<Msg> {
  if (!model.running) return Sub.none;
  return Sub.batch([
    Sub.timer("tick", model.fast ? 40 : 100, "tick"),
    Sub.timer("blink", 250, "blink"),
  ]);
}
`,
    node: `
{
  const kinds = ["toggle", "speed", "tick", "blink"];
  // Mirror of the v2 timer record: [0x01][key_len][key][every f64 LE][tag].
  const encSub = (s) => {
    if (s.op === "none") return [];
    if (s.op === "timer") {
      const key = Array.from(new TextEncoder().encode(s.key));
      const dv = new DataView(new ArrayBuffer(8));
      dv.setFloat64(0, s.everyMs, true);
      const every = [];
      for (let i = 0; i < 8; i++) every.push(dv.getUint8(i));
      return [1, key.length, ...key, ...every, kinds.indexOf(s.msgKind)];
    }
    return s.subs.flatMap(encSub);
  };
  const parseSubs = (bytes) => {
    const out = [];
    let at = 0;
    while (at < bytes.length) {
      at += 1;
      const keyLen = bytes[at]; at += 1;
      let key = "";
      for (let i = 0; i < keyLen; i++) key += String.fromCharCode(bytes[at + i]);
      at += keyLen;
      const dv = new DataView(Uint8Array.from(bytes.slice(at, at + 8)).buffer);
      out.push({ key, every: dv.getFloat64(0, true), tag: bytes[at + 8] });
      at += 9;
    }
    return out;
  };
  let model = mod.initialModel();
  let now = 0;
  // Four fixed timer slots, reconciled by key: same algorithm as the zig
  // driver, so firing order is identical by construction.
  const timers = [null, null, null, null];
  const reconcile = () => {
    const bytes = encSub(mod.subscriptions(model));
    const want = parseSubs(bytes);
    const seen = [false, false, false, false];
    for (const w of want) {
      let slot = -1;
      for (let i = 0; i < 4; i++) if (timers[i] !== null && timers[i].key === w.key) slot = i;
      if (slot >= 0) {
        seen[slot] = true;
        if (timers[slot].every !== w.every) {
          timers[slot].every = w.every;
          timers[slot].next = now + w.every;
        }
        timers[slot].tag = w.tag;
      } else {
        for (let i = 0; i < 4; i++) {
          if (timers[i] === null) {
            timers[i] = { key: w.key, every: w.every, next: now + w.every, tag: w.tag };
            seen[i] = true;
            break;
          }
        }
      }
    }
    for (let i = 0; i < 4; i++) if (timers[i] !== null && !seen[i]) timers[i] = null;
    return bytes;
  };
  line("v0", Uint8Array.from(reconcile()));
  const inject = { 8: "speed", 14: "toggle", 20: "toggle" };
  for (let step = 1; step <= 26; step++) {
    now += 25;
    for (;;) {
      let idx = -1;
      for (let i = 0; i < 4; i++) {
        if (timers[i] !== null && timers[i].next <= now) { idx = i; break; }
      }
      if (idx < 0) break;
      timers[idx].next += timers[idx].every;
      model = mod.update(model, { kind: kinds[timers[idx].tag], at: now });
      reconcile();
    }
    if (inject[step] !== undefined) {
      model = mod.update(model, { kind: inject[step] });
      line("vr" + step, Uint8Array.from(reconcile()));
    }
  }
  line("v1", model.ticks);
  line("v2", model.blinks);
  line("v3", model.lastAt);
  line("v4", Uint8Array.from(encSub(mod.subscriptions(model))));
}
`,
    zig: `
    {
        const Timer = struct { key: [16]u8, key_len: usize, every: f64, next: f64, tag: u8, live: bool };
        const Host = struct {
            // Reconcile the four fixed slots against a wire descriptor set:
            // match by key, re-arm on interval change, cancel the missing.
            fn reconcile(timers: []Timer, now: f64, subs: []const u8) void {
                var seen = [_]bool{false} ** 4;
                var at: usize = 0;
                while (at < subs.len) {
                    at += 1; // timer op
                    const key_len: usize = subs[at];
                    at += 1;
                    const key = subs[at .. at + key_len];
                    at += key_len;
                    const every: f64 = @bitCast(std.mem.readInt(u64, subs[at..][0..8], .little));
                    at += 8;
                    const tag = subs[at];
                    at += 1;
                    var slot: ?usize = null;
                    for (timers, 0..) |t, i| {
                        if (t.live and std.mem.eql(u8, t.key[0..t.key_len], key)) slot = i;
                    }
                    if (slot) |i| {
                        seen[i] = true;
                        if (timers[i].every != every) {
                            timers[i].every = every;
                            timers[i].next = now + every;
                        }
                        timers[i].tag = tag;
                    } else {
                        for (timers, 0..) |t, i| {
                            if (!t.live) {
                                seen[i] = true;
                                timers[i] = .{ .key = undefined, .key_len = key_len, .every = every, .next = now + every, .tag = tag, .live = true };
                                @memcpy(timers[i].key[0..key_len], key);
                                break;
                            }
                        }
                    }
                }
                for (timers, 0..) |t, i| {
                    if (t.live and !seen[i]) timers[i].live = false;
                }
            }
        };
        var timers = [1]Timer{.{ .key = undefined, .key_len = 0, .every = 0, .next = 0, .tag = 0, .live = false }} ** 4;
        var model = m.initialModel();
        var now: f64 = 0;
        {
            const subs = m.subscriptions(model);
            Host.reconcile(&timers, now, subs);
            row("v0", subs);
        }
        const tick_tag: u8 = @intFromEnum(std.meta.Tag(m.Msg).tick);
        var step: i64 = 1;
        while (step <= 26) : (step += 1) {
            now += 25;
            while (true) {
                var idx: ?usize = null;
                for (timers, 0..) |t, i| {
                    if (t.live and t.next <= now) {
                        idx = i;
                        break;
                    }
                }
                const i = idx orelse break;
                timers[i].next += timers[i].every;
                const msg: m.Msg = if (timers[i].tag == tick_tag) .{ .tick = now } else .{ .blink = now };
                model = m.update(model, msg);
                Host.reconcile(&timers, now, m.subscriptions(model));
            }
            if (step == 8 or step == 14 or step == 20) {
                model = m.update(model, if (step == 8) m.Msg.speed else m.Msg.toggle);
                const subs = m.subscriptions(model);
                Host.reconcile(&timers, now, subs);
                if (step == 8) row("vr8", subs) else if (step == 14) row("vr14", subs) else row("vr20", subs);
            }
        }
        row("v1", model.ticks);
        row("v2", model.blinks);
        row("v3", model.lastAt);
        row("v4", m.subscriptions(model));
    }
`,
  },
  {
    name: "walker determinism under forced compaction: tiny heap, sustained churn",
    options: { frameCap: 32768, heapCap: 8192 },
    src: `
import { asciiBytes } from "@native-sdk/core";
export interface Entry { readonly id: number; readonly label: Uint8Array; }
export interface Model { readonly entries: readonly Entry[]; readonly total: number; }
export type Msg =
  | { readonly kind: "note"; readonly id: number }
  | { readonly kind: "trim" };
export function initialModel(): Model { return { entries: [], total: 0 }; }
export function update(model: Model, msg: Msg): Model {
  switch (msg.kind) {
    case "note": {
      const label = asciiBytes(\`entry \${msg.id & 1023}\`);
      return { entries: [...model.entries, { id: msg.id, label: label }], total: model.total + label.length };
    }
    case "trim": return { ...model, entries: model.entries.slice(1) };
  }
}
export function idSum(model: Model): number {
  let t = 0;
  for (const e of model.entries) t += e.id;
  return t;
}
export function labelBytes(model: Model): number {
  let t = 0;
  for (const e of model.entries) t += e.label.length;
  return t;
}
export function count(model: Model): number { return model.entries.length; }
`,
    node: `
{
  let model = mod.initialModel();
  for (let r = 0; r < 120; r++) {
    model = mod.update(model, { kind: "note", id: r });
    model = mod.update(model, { kind: "note", id: r + 500 });
    model = mod.update(model, { kind: "trim" });
    if (r % 20 === 0) {
      line("c", mod.count(model));
      line("s", mod.idSum(model));
      line("b", mod.labelBytes(model));
    }
  }
  line("cmp", true);
  line("fin", mod.idSum(model));
  line("tot", model.total);
}
`,
    zig: `
    {
        m.rt.resetAll();
        var model = m.commitModelRoot(m.initialModel());
        m.rt.frameReset();
        var r: i64 = 0;
        while (r < 120) : (r += 1) {
            model = m.commitModelRoot(m.update(model, .{ .note = r }));
            m.rt.frameReset();
            model = m.commitModelRoot(m.update(model, .{ .note = r + 500 }));
            m.rt.frameReset();
            model = m.commitModelRoot(m.update(model, .trim));
            m.rt.frameReset();
            if (@rem(r, 20) == 0) {
                row("c", m.count(model));
                row("s", m.idSum(model));
                row("b", m.labelBytes(model));
            }
        }
        // The tiny heap makes the two-space flip fire for real: silence here
        // would mean the case stopped proving compaction determinism.
        row("cmp", m.rt.stat_compactions > 0);
        row("fin", m.idSum(model));
        row("tot", model.total);
    }
`,
  },
  {
    name: "named file/clipboard ops: wire records and ok/void/err arms under a virtual host",
    src: `
import { Cmd, asciiBytes } from "@native-sdk/core";
export interface Model { readonly data: Uint8Array; readonly saved: number; readonly errs: number; readonly lastErr: Uint8Array; }
export type Msg =
  | { readonly kind: "load" }
  | { readonly kind: "save" }
  | { readonly kind: "copy" }
  | { readonly kind: "paste" }
  | { readonly kind: "loaded"; readonly body: Uint8Array }
  | { readonly kind: "wrote" }
  | { readonly kind: "failed"; readonly why: Uint8Array };
export function initialModel(): Model { return { data: new Uint8Array(0), saved: 0, errs: 0, lastErr: new Uint8Array(0) }; }
export function update(model: Model, msg: Msg): Model | [Model, Cmd<Msg>] {
  switch (msg.kind) {
    case "load": return [model, Cmd.readFile(asciiBytes("store.bin"), { key: "io", ok: "loaded", err: "failed" })];
    case "save": return [model, Cmd.writeFile(asciiBytes("store.bin"), model.data, { key: "io", ok: "wrote", err: "failed" })];
    case "copy": return [model, Cmd.clipboardWrite(model.data)];
    case "paste": return [model, Cmd.clipboardRead({ key: "clip", ok: "loaded", err: "failed" })];
    case "loaded": return { ...model, data: msg.body };
    case "wrote": return { ...model, saved: model.saved + 1 };
    case "failed": return { ...model, errs: model.errs + 1, lastErr: msg.why };
  }
}
`,
    node: `
{
  const kinds = ["load", "save", "copy", "paste", "loaded", "wrote", "failed"];
  const te = new TextEncoder();
  // Mirrors of the named-op wire records (rt.zig): routed head =
  // [op][key_len][key][ok][err]; long fields = [len u32 LE][bytes].
  const long = (b) => [b.length & 255, (b.length >> 8) & 255, (b.length >> 16) & 255, (b.length >>> 24) & 255, ...b];
  const head = (op, c) => { const k = Array.from(te.encode(c.key)); return [op, k.length, ...k, kinds.indexOf(c.okKind), kinds.indexOf(c.errKind)]; };
  const enc = (cmd) => {
    if (cmd.op === "none") return [];
    if (cmd.op === "read_file") return [...head(7, cmd), ...long(Array.from(cmd.path))];
    if (cmd.op === "write_file") return [...head(8, cmd), ...long(Array.from(cmd.path)), ...long(Array.from(cmd.bytes))];
    if (cmd.op === "clip_write") return [10, ...long(Array.from(cmd.bytes))];
    if (cmd.op === "clip_read") return head(11, cmd);
    return cmd.cmds.flatMap(enc);
  };
  const step = (model, msg) => { const r = mod.update(model, msg); return Array.isArray(r) ? [r[0], Uint8Array.from(enc(r[1]))] : [r, new Uint8Array(0)]; };
  // ok/err tags sit right after the key on every routed head.
  const routeTags = (bytes) => { let at = 1; at += 1 + bytes[at]; return [bytes[at], bytes[at + 1]]; };
  let model = mod.initialModel();
  let cmd;
  [model, cmd] = step(model, { kind: "load" });
  line("f0", cmd);
  let t = routeTags(cmd);
  [model, cmd] = step(model, { kind: kinds[t[0]], body: te.encode("disk!") });
  line("f1", model.data);
  [model, cmd] = step(model, { kind: "save" });
  line("f2", cmd);
  t = routeTags(cmd);
  [model, cmd] = step(model, { kind: kinds[t[0]] });
  line("f3", model.saved);
  [model, cmd] = step(model, { kind: "save" });
  t = routeTags(cmd);
  [model, cmd] = step(model, { kind: kinds[t[1]], why: te.encode("io_failed") });
  line("f4", model.errs);
  line("f5", model.lastErr);
  [model, cmd] = step(model, { kind: "copy" });
  line("f6", cmd);
  [model, cmd] = step(model, { kind: "paste" });
  line("f7", cmd);
  t = routeTags(cmd);
  [model, cmd] = step(model, { kind: kinds[t[0]], body: new Uint8Array(0) });
  line("f8", model.data);
  [model, cmd] = step(model, { kind: "paste" });
  t = routeTags(cmd);
  [model, cmd] = step(model, { kind: kinds[t[1]], why: te.encode("failed") });
  line("f9", model.errs);
  line("f10", model.lastErr);
}
`,
    zig: `
    {
        const Host = struct {
            // ok/err tags sit right after the key on every routed head.
            fn routeTags(bytes: []const u8) [2]u8 {
                var at: usize = 1;
                at += 1 + bytes[at];
                return .{ bytes[at], bytes[at + 1] };
            }
        };
        const loaded_tag: u8 = @intFromEnum(std.meta.Tag(m.Msg).loaded);
        const wrote_tag: u8 = @intFromEnum(std.meta.Tag(m.Msg).wrote);
        var model = m.initialModel();
        var r = m.update(model, .load);
        model = r.model;
        row("f0", r.cmd);
        var t = Host.routeTags(r.cmd);
        r = m.update(model, if (t[0] == loaded_tag) m.Msg{ .loaded = "disk!" } else m.Msg{ .failed = "?" });
        model = r.model;
        row("f1", model.data);
        r = m.update(model, .save);
        model = r.model;
        row("f2", r.cmd);
        t = Host.routeTags(r.cmd);
        r = m.update(model, if (t[0] == wrote_tag) m.Msg.wrote else m.Msg{ .failed = "?" });
        model = r.model;
        row("f3", model.saved);
        r = m.update(model, .save);
        model = r.model;
        t = Host.routeTags(r.cmd);
        r = m.update(model, if (t[1] == @intFromEnum(std.meta.Tag(m.Msg).failed)) m.Msg{ .failed = "io_failed" } else m.Msg.wrote);
        model = r.model;
        row("f4", model.errs);
        row("f5", model.lastErr);
        r = m.update(model, .copy);
        model = r.model;
        row("f6", r.cmd);
        r = m.update(model, .paste);
        model = r.model;
        row("f7", r.cmd);
        t = Host.routeTags(r.cmd);
        r = m.update(model, if (t[0] == loaded_tag) m.Msg{ .loaded = "" } else m.Msg{ .failed = "?" });
        model = r.model;
        row("f8", model.data);
        r = m.update(model, .paste);
        model = r.model;
        t = Host.routeTags(r.cmd);
        r = m.update(model, if (t[1] == @intFromEnum(std.meta.Tag(m.Msg).failed)) m.Msg{ .failed = "failed" } else m.Msg.wrote);
        model = r.model;
        row("f9", model.errs);
        row("f10", model.lastErr);
    }
`,
  },
  {
    name: "fetch {status, body} records and one-shot delays under virtual time",
    src: `
import { Cmd, asciiBytes } from "@native-sdk/core";
export interface Model { readonly code: number; readonly body: Uint8Array; readonly errs: number; readonly lastErr: Uint8Array; readonly fires: number; readonly lastAt: number; }
export type Msg =
  | { readonly kind: "get" }
  | { readonly kind: "ping" }
  | { readonly kind: "secure" }
  | { readonly kind: "wait" }
  | { readonly kind: "wait_fast" }
  | { readonly kind: "stop" }
  | { readonly kind: "fetched"; readonly status: number; readonly body: Uint8Array }
  | { readonly kind: "fired"; readonly at: number }
  | { readonly kind: "failed"; readonly why: Uint8Array };
export function initialModel(): Model { return { code: -1, body: new Uint8Array(0), errs: 0, lastErr: new Uint8Array(0), fires: 0, lastAt: -1 }; }
export function update(model: Model, msg: Msg): Model | [Model, Cmd<Msg>] {
  switch (msg.kind) {
    case "get": return [model, Cmd.fetch({ url: asciiBytes("https://api.test/items"), method: "POST", headers: { "x-b": "2", "x-a": "1" }, body: asciiBytes("q=1"), timeoutMs: 750 }, { key: "get", ok: "fetched", err: "failed" })];
    case "ping": return [model, Cmd.fetch({ url: model.body }, { ok: "fetched", err: "failed" })];
    case "secure": return [model, Cmd.fetch({ url: asciiBytes("https://api.test/private"), headers: { authorization: model.body, "x-static": "yes" } }, { key: "auth", ok: "fetched", err: "failed" })];
    case "wait": return [model, Cmd.delay("tick", 100, "fired")];
    case "wait_fast": return [model, Cmd.delay("tick", 40, "fired")];
    case "stop": return [model, Cmd.cancel("tick")];
    case "fetched": return { ...model, code: msg.status, body: msg.body };
    case "fired": return { ...model, fires: model.fires + 1, lastAt: msg.at };
    case "failed": return { ...model, errs: model.errs + 1, lastErr: msg.why };
  }
}
`,
    node: `
{
  const kinds = ["get", "ping", "secure", "wait", "wait_fast", "stop", "fetched", "fired", "failed"];
  const te = new TextEncoder();
  const methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"];
  // Mirrors of the fetch/delay/cancel wire records (rt.zig). A header
  // value is compile-time text (string) or runtime bytes (Uint8Array);
  // both encode as the same length-prefixed value field.
  const long = (b) => [b.length & 255, (b.length >> 8) & 255, (b.length >> 16) & 255, (b.length >>> 24) & 255, ...b];
  const f64le = (v) => { const dv = new DataView(new ArrayBuffer(8)); dv.setFloat64(0, v, true); const out = []; for (let i = 0; i < 8; i++) out.push(dv.getUint8(i)); return out; };
  const enc = (cmd) => {
    if (cmd.op === "none") return [];
    if (cmd.op === "fetch") {
      const k = Array.from(te.encode(cmd.key));
      const t = cmd.timeoutMs;
      const out = [9, k.length, ...k, kinds.indexOf(cmd.okKind), kinds.indexOf(cmd.errKind), methods.indexOf(cmd.method), t & 255, (t >> 8) & 255, (t >> 16) & 255, (t >>> 24) & 255, ...long(Array.from(cmd.url)), cmd.headers.length];
      for (const h of cmd.headers) { const n = Array.from(te.encode(h.name)); const v = typeof h.value === "string" ? Array.from(te.encode(h.value)) : Array.from(h.value); out.push(n.length, ...n, ...long(v)); }
      out.push(...long(Array.from(cmd.body)));
      return out;
    }
    if (cmd.op === "delay") { const k = Array.from(te.encode(cmd.key)); return [12, k.length, ...k, ...f64le(cmd.afterMs), kinds.indexOf(cmd.msgKind)]; }
    if (cmd.op === "cancel") { const k = Array.from(te.encode(cmd.key)); return [6, k.length, ...k]; }
    return cmd.cmds.flatMap(enc);
  };
  const step = (model, msg) => { const r = mod.update(model, msg); return Array.isArray(r) ? [r[0], Uint8Array.from(enc(r[1]))] : [r, new Uint8Array(0)]; };
  const routeTags = (bytes) => { let at = 1; at += 1 + bytes[at]; return [bytes[at], bytes[at + 1]]; };
  let model = mod.initialModel();
  let cmd;
  [model, cmd] = step(model, { kind: "get" });
  line("g0", cmd);
  let t = routeTags(cmd);
  [model, cmd] = step(model, { kind: kinds[t[0]], status: 200, body: te.encode("hello") });
  line("g1", model.code);
  line("g2", model.body);
  // A RUNTIME Authorization header value (model.body) rides the same
  // record as the literal x-static header, in name-sort order —
  // byte-identical under node and native.
  [model, cmd] = step(model, { kind: "secure" });
  line("s0", cmd);
  t = routeTags(cmd);
  [model, cmd] = step(model, { kind: kinds[t[0]], status: 201, body: te.encode("hello") });
  line("s1", model.code);
  line("s2", model.body);
  // A dynamic bytes URL flows through the same record.
  [model, cmd] = step(model, { kind: "ping" });
  line("g3", cmd);
  t = routeTags(cmd);
  [model, cmd] = step(model, { kind: kinds[t[0]], status: 204, body: new Uint8Array(0) });
  line("g4", model.code);
  line("g5", model.body);
  [model, cmd] = step(model, { kind: "get" });
  t = routeTags(cmd);
  [model, cmd] = step(model, { kind: kinds[t[1]], why: te.encode("timed_out") });
  line("g6", model.errs);
  line("g7", model.lastErr);
  // Delay under virtual time: arm at now=0 for 100ms, re-arm the live
  // key for 40ms (replace), fire once at 40 with the delay's own tag.
  [model, cmd] = step(model, { kind: "wait" });
  line("d0", cmd);
  const tag0 = cmd[cmd.length - 1];
  [model, cmd] = step(model, { kind: "wait_fast" });
  line("d1", cmd);
  const tag1 = cmd[cmd.length - 1];
  line("d2", tag0 === tag1);
  [model, cmd] = step(model, { kind: kinds[tag1], at: 40 });
  line("d3", model.fires);
  line("d4", model.lastAt);
  // Re-arm then cancel: the delay never fires, nothing routes.
  [model, cmd] = step(model, { kind: "wait" });
  [model, cmd] = step(model, { kind: "stop" });
  line("d5", cmd);
  line("d6", model.fires);
}
`,
    zig: `
    {
        const Host = struct {
            fn routeTags(bytes: []const u8) [2]u8 {
                var at: usize = 1;
                at += 1 + bytes[at];
                return .{ bytes[at], bytes[at + 1] };
            }
        };
        const fetched_tag: u8 = @intFromEnum(std.meta.Tag(m.Msg).fetched);
        var model = m.initialModel();
        var r = m.update(model, .get);
        model = r.model;
        row("g0", r.cmd);
        var t = Host.routeTags(r.cmd);
        r = m.update(model, if (t[0] == fetched_tag) m.Msg{ .fetched = .{ .status = 200, .body = "hello" } } else m.Msg{ .failed = "?" });
        model = r.model;
        row("g1", model.code);
        row("g2", model.body);
        r = m.update(model, .secure);
        model = r.model;
        row("s0", r.cmd);
        t = Host.routeTags(r.cmd);
        r = m.update(model, if (t[0] == fetched_tag) m.Msg{ .fetched = .{ .status = 201, .body = "hello" } } else m.Msg{ .failed = "?" });
        model = r.model;
        row("s1", model.code);
        row("s2", model.body);
        r = m.update(model, .ping);
        model = r.model;
        row("g3", r.cmd);
        t = Host.routeTags(r.cmd);
        r = m.update(model, if (t[0] == fetched_tag) m.Msg{ .fetched = .{ .status = 204, .body = "" } } else m.Msg{ .failed = "?" });
        model = r.model;
        row("g4", model.code);
        row("g5", model.body);
        r = m.update(model, .get);
        model = r.model;
        t = Host.routeTags(r.cmd);
        r = m.update(model, if (t[1] == @intFromEnum(std.meta.Tag(m.Msg).failed)) m.Msg{ .failed = "timed_out" } else m.Msg{ .failed = "?" });
        model = r.model;
        row("g6", model.errs);
        row("g7", model.lastErr);
        r = m.update(model, .wait);
        model = r.model;
        row("d0", r.cmd);
        const tag0 = r.cmd[r.cmd.len - 1];
        r = m.update(model, .wait_fast);
        model = r.model;
        row("d1", r.cmd);
        const tag1 = r.cmd[r.cmd.len - 1];
        row("d2", tag0 == tag1);
        r = m.update(model, if (tag1 == @intFromEnum(std.meta.Tag(m.Msg).fired)) m.Msg{ .fired = 40 } else m.Msg{ .failed = "?" });
        model = r.model;
        row("d3", model.fires);
        row("d4", model.lastAt);
        r = m.update(model, .wait);
        model = r.model;
        r = m.update(model, .stop);
        model = r.model;
        row("d5", r.cmd);
        row("d6", model.fires);
    }
`,
  },
  {
    name: "spawn streams and audio events under the virtual host: ordering, cancel mid-stream, collect",
    src: `
import { Cmd, asciiBytes } from "@native-sdk/core";
export type AudioState = "loaded" | "position" | "completed" | "failed" | "rejected" | "spectrum";
export interface Model {
  readonly lines: number; readonly last: Uint8Array; readonly code: number; readonly out: Uint8Array;
  readonly errs: number; readonly lastErr: Uint8Array;
  readonly state: AudioState; readonly pos: number; readonly dur: number; readonly playing: boolean;
  readonly bands: Uint8Array; readonly events: number;
}
export type Msg =
  | { readonly kind: "sample" }
  | { readonly kind: "gather" }
  | { readonly kind: "halt" }
  | { readonly kind: "play" }
  | { readonly kind: "drive" }
  | { readonly kind: "line"; readonly text: Uint8Array }
  | { readonly kind: "done"; readonly code: number }
  | { readonly kind: "sampled"; readonly code: number; readonly output: Uint8Array }
  | { readonly kind: "audio_evt"; readonly state: AudioState; readonly positionMs: number; readonly durationMs: number; readonly playing: boolean; readonly buffering: boolean; readonly bands: Uint8Array }
  | { readonly kind: "failed"; readonly why: Uint8Array };
export function initialModel(): Model {
  return { lines: 0, last: new Uint8Array(0), code: -1, out: new Uint8Array(0), errs: 0, lastErr: new Uint8Array(0), state: "rejected", pos: -1, dur: -1, playing: false, bands: new Uint8Array(0), events: 0 };
}
export function update(model: Model, msg: Msg): Model | [Model, Cmd<Msg>] {
  switch (msg.kind) {
    case "sample": return [model, Cmd.spawn([asciiBytes("/bin/probe"), asciiBytes("--cpu")], { key: "job", stdin: model.last, line: "line", exit: "done", err: "failed" })];
    case "gather": return [model, Cmd.spawn([asciiBytes("/bin/gather")], { key: "job", collect: true, exit: "sampled", err: "failed" })];
    case "halt": return [model, Cmd.cancel("job")];
    case "play": return [model, Cmd.audioPlay("track", { path: asciiBytes("a.mp3"), url: asciiBytes("https://c.test/a.mp3"), cachePath: asciiBytes("cache/a"), expectedBytes: 2048 }, { event: "audio_evt" })];
    case "drive": return [model, Cmd.batch([Cmd.audioPause("track"), Cmd.audioSeek("track", 30000), Cmd.audioSetVolume("track", 0.5), Cmd.audioStop("track")])];
    case "line": return { ...model, lines: model.lines + 1, last: msg.text };
    case "done": return { ...model, code: msg.code };
    case "sampled": return { ...model, code: msg.code, out: msg.output };
    case "audio_evt": return { ...model, state: msg.state, pos: msg.positionMs, dur: msg.durationMs, playing: msg.playing, bands: msg.bands, events: model.events + 1 };
    case "failed": return { ...model, errs: model.errs + 1, lastErr: msg.why };
  }
}
`,
    node: `
{
  const kinds = ["sample", "gather", "halt", "play", "drive", "line", "done", "sampled", "audio_evt", "failed"];
  const states = ["loaded", "position", "completed", "failed", "rejected", "spectrum"];
  const te = new TextEncoder();
  // Mirrors of the streaming wire records (rt.zig).
  const long = (b) => [b.length & 255, (b.length >> 8) & 255, (b.length >> 16) & 255, (b.length >>> 24) & 255, ...b];
  const f64le = (v) => { const dv = new DataView(new ArrayBuffer(8)); dv.setFloat64(0, v, true); const out = []; for (let i = 0; i < 8; i++) out.push(dv.getUint8(i)); return out; };
  const verbs = ["pause", "resume", "stop", "seek", "volume"];
  const enc = (cmd) => {
    if (cmd.op === "none") return [];
    if (cmd.op === "cancel") { const k = Array.from(te.encode(cmd.key)); return [6, k.length, ...k]; }
    if (cmd.op === "spawn") {
      const k = Array.from(te.encode(cmd.key));
      const lineTag = cmd.lineKind === "" ? 0xff : kinds.indexOf(cmd.lineKind);
      const out = [13, k.length, ...k, lineTag, kinds.indexOf(cmd.exitKind), kinds.indexOf(cmd.errKind), cmd.collect ? 1 : 0, cmd.argv.length];
      for (const arg of cmd.argv) out.push(...long(Array.from(arg)));
      out.push(...long(Array.from(cmd.stdin)));
      return out;
    }
    if (cmd.op === "audio_play") {
      const k = Array.from(te.encode(cmd.key));
      return [14, k.length, ...k, kinds.indexOf(cmd.eventKind), ...long(Array.from(cmd.path)), ...long(Array.from(cmd.url)), ...long(Array.from(cmd.cachePath)), ...f64le(cmd.expectedBytes)];
    }
    if (cmd.op === "audio_ctl") {
      const k = Array.from(te.encode(cmd.key));
      return [15, k.length, ...k, verbs.indexOf(cmd.verb), ...f64le(cmd.value)];
    }
    return cmd.cmds.flatMap(enc);
  };
  const step = (model, msg) => { const r = mod.update(model, msg); return Array.isArray(r) ? [r[0], Uint8Array.from(enc(r[1]))] : [r, new Uint8Array(0)]; };
  // The virtual host reads a spawn record's routing tags off the wire:
  // [op][key][line][exit][err] — the canned scripts below dispatch arms
  // built from exactly these bytes, mirroring the zig driver.
  const spawnTags = (bytes) => { let at = 1; at += 1 + bytes[at]; return { line: bytes[at], exit: bytes[at + 1], err: bytes[at + 2] }; };
  const audioTag = (bytes) => { let at = 1; at += 1 + bytes[at]; return bytes[at]; };
  let model = mod.initialModel();
  let cmd;

  // Audio stream: play opens it; a canned event script drives the arm.
  [model, cmd] = step(model, { kind: "play" });
  line("a0", cmd);
  const evTag = audioTag(cmd);
  const bands0 = new Uint8Array(32);
  const ev = (state, positionMs, durationMs, playing, buffering, bands) => ({ kind: kinds[evTag], state, positionMs, durationMs, playing, buffering, bands });
  [model, cmd] = step(model, ev("loaded", 0, 180000, true, false, bands0));
  line("a1", model.state);
  line("a2", model.dur);
  line("a3", model.playing);
  [model, cmd] = step(model, ev("position", 500, 180000, true, false, bands0));
  line("a4", model.pos);
  const bands = Uint8Array.from({ length: 32 }, (_, i) => i * 5);
  [model, cmd] = step(model, ev("spectrum", 750, 180000, true, false, bands));
  line("a5", model.bands);
  line("a6", model.events);
  [model, cmd] = step(model, { kind: "drive" });
  line("a7", cmd);

  // Line spawn: lines route across dispatches in order, then cancel
  // mid-stream delivers the err arm — never silent.
  [model, cmd] = step(model, { kind: "sample" });
  line("s0", cmd);
  const t = spawnTags(cmd);
  [model, cmd] = step(model, { kind: kinds[t.line], text: te.encode("cpu 40") });
  line("s1", model.lines);
  line("s2", model.last);
  [model, cmd] = step(model, { kind: kinds[t.line], text: te.encode("cpu 7") });
  line("s3", model.lines);
  [model, cmd] = step(model, { kind: "halt" });
  line("s4", cmd);
  [model, cmd] = step(model, { kind: kinds[t.err], why: te.encode("cancelled") });
  line("s5", model.errs);
  line("s6", model.lastErr);

  // The key is free again: a fresh stream exits cleanly with its code.
  [model, cmd] = step(model, { kind: "sample" });
  line("s7", cmd);
  [model, cmd] = step(model, { kind: kinds[t.exit], code: 3 });
  line("s8", model.code);

  // Collect spawn: the exit carries { code, output } whole.
  [model, cmd] = step(model, { kind: "gather" });
  line("g0", cmd);
  const tc = spawnTags(cmd);
  [model, cmd] = step(model, { kind: kinds[tc.exit], code: 0, output: te.encode("PID CPU\\n17 99.0\\n") });
  line("g1", model.code);
  line("g2", model.out);
}
`,
    zig: `
    {
        const Host = struct {
            fn spawnTags(bytes: []const u8) [3]u8 {
                var at: usize = 1;
                at += 1 + bytes[at];
                return .{ bytes[at], bytes[at + 1], bytes[at + 2] };
            }
            fn audioTag(bytes: []const u8) u8 {
                var at: usize = 1;
                at += 1 + bytes[at];
                return bytes[at];
            }
        };
        const line_tag: u8 = @intFromEnum(std.meta.Tag(m.Msg).line);
        const done_tag: u8 = @intFromEnum(std.meta.Tag(m.Msg).done);
        const sampled_tag: u8 = @intFromEnum(std.meta.Tag(m.Msg).sampled);
        const audio_tag: u8 = @intFromEnum(std.meta.Tag(m.Msg).audio_evt);
        const failed_tag: u8 = @intFromEnum(std.meta.Tag(m.Msg).failed);
        var model = m.initialModel();

        var r = m.update(model, .play);
        model = r.model;
        row("a0", r.cmd);
        const ev_tag = Host.audioTag(r.cmd);
        const bands0 = [_]u8{0} ** 32;
        r = m.update(model, if (ev_tag == audio_tag) m.Msg{ .audio_evt = .{ .state = .loaded, .positionMs = 0, .durationMs = 180000, .playing = true, .buffering = false, .bands = &bands0 } } else m.Msg{ .failed = "?" });
        model = r.model;
        row("a1", model.state);
        row("a2", model.dur);
        row("a3", model.playing);
        r = m.update(model, .{ .audio_evt = .{ .state = .position, .positionMs = 500, .durationMs = 180000, .playing = true, .buffering = false, .bands = &bands0 } });
        model = r.model;
        row("a4", model.pos);
        var bands: [32]u8 = undefined;
        for (&bands, 0..) |*b, i| b.* = @intCast(i * 5);
        r = m.update(model, .{ .audio_evt = .{ .state = .spectrum, .positionMs = 750, .durationMs = 180000, .playing = true, .buffering = false, .bands = &bands } });
        model = r.model;
        row("a5", model.bands);
        row("a6", model.events);
        r = m.update(model, .drive);
        model = r.model;
        row("a7", r.cmd);

        r = m.update(model, .sample);
        model = r.model;
        row("s0", r.cmd);
        const t = Host.spawnTags(r.cmd);
        r = m.update(model, if (t[0] == line_tag) m.Msg{ .line = "cpu 40" } else m.Msg{ .failed = "?" });
        model = r.model;
        row("s1", model.lines);
        row("s2", model.last);
        r = m.update(model, if (t[0] == line_tag) m.Msg{ .line = "cpu 7" } else m.Msg{ .failed = "?" });
        model = r.model;
        row("s3", model.lines);
        r = m.update(model, .halt);
        model = r.model;
        row("s4", r.cmd);
        r = m.update(model, if (t[2] == failed_tag) m.Msg{ .failed = "cancelled" } else m.Msg{ .failed = "?" });
        model = r.model;
        row("s5", model.errs);
        row("s6", model.lastErr);

        r = m.update(model, .sample);
        model = r.model;
        row("s7", r.cmd);
        r = m.update(model, if (t[1] == done_tag) m.Msg{ .done = 3 } else m.Msg{ .failed = "?" });
        model = r.model;
        row("s8", model.code);

        r = m.update(model, .gather);
        model = r.model;
        row("g0", r.cmd);
        const tc = Host.spawnTags(r.cmd);
        r = m.update(model, if (tc[1] == sampled_tag) m.Msg{ .sampled = .{ .code = 0, .output = "PID CPU\\n17 99.0\\n" } } else m.Msg{ .failed = "?" });
        model = r.model;
        row("g1", model.code);
        row("g2", model.out);
    }
`,
  },
  {
    name: "declared text-input mirror union: payload arms, stacked verbs, byte-splice reducer",
    src: `
export type TextCaretDirection = "previous" | "next" | "previous_word" | "next_word" | "start" | "end";
export interface TextCaretMove { readonly direction: TextCaretDirection; readonly extend: boolean; }
export interface TextSelection { readonly anchor: number; readonly focus: number; }
export type TextInputEvent =
  | { readonly kind: "insert_text"; readonly text: Uint8Array }
  | { readonly kind: "delete_backward" }
  | { readonly kind: "delete_forward" }
  | { readonly kind: "delete_word_backward" }
  | { readonly kind: "delete_word_forward" }
  | { readonly kind: "clear" }
  | { readonly kind: "move_caret"; readonly move: TextCaretMove }
  | { readonly kind: "set_selection"; readonly selection: TextSelection }
  | { readonly kind: "set_composition"; readonly text: Uint8Array; readonly cursor: number | null }
  | { readonly kind: "commit_composition" }
  | { readonly kind: "cancel_composition" };
export interface Model { readonly draft: Uint8Array; readonly moves: number; }
export type Msg =
  | { readonly kind: "draft_edit"; readonly edit: TextInputEvent }
  | { readonly kind: "reset" };
function applyDraftEdit(draft: Uint8Array, edit: TextInputEvent): Uint8Array {
  switch (edit.kind) {
    case "insert_text": {
      const out = new Uint8Array(draft.length + edit.text.length);
      out.set(draft, 0);
      out.set(edit.text, draft.length);
      return out;
    }
    case "delete_backward":
      return draft.length === 0 ? draft : draft.subarray(0, draft.length - 1);
    case "clear":
      return new Uint8Array(0);
    case "delete_forward":
    case "delete_word_backward":
    case "delete_word_forward":
    case "move_caret":
    case "set_selection":
    case "set_composition":
    case "commit_composition":
    case "cancel_composition":
      return draft;
  }
}
export function update(model: Model, msg: Msg): Model {
  switch (msg.kind) {
    case "draft_edit":
      return { draft: applyDraftEdit(model.draft, msg.edit), moves: model.moves + 1 };
    case "reset":
      return { draft: new Uint8Array(0), moves: 0 };
  }
}
export function initialModel(): Model { return { draft: new Uint8Array(0), moves: 0 }; }
`,
    node: `
{
  const te = new TextEncoder();
  let model = mod.initialModel();
  const edits = [
    { kind: "insert_text", text: te.encode("hi") },
    { kind: "insert_text", text: te.encode(" there") },
    { kind: "delete_backward" },
    { kind: "move_caret", move: { direction: "previous_word", extend: true } },
    { kind: "set_selection", selection: { anchor: 1, focus: 3 } },
    { kind: "set_composition", text: te.encode("x"), cursor: null },
    { kind: "delete_forward" },
    { kind: "clear" },
    { kind: "insert_text", text: te.encode("z") },
  ];
  for (const edit of edits) {
    model = mod.update(model, { kind: "draft_edit", edit: edit });
    line("d", model.draft);
    line("m", model.moves);
  }
  model = mod.update(model, { kind: "reset" });
  line("d2", model.draft);
  line("m2", model.moves);
}
`,
    zig: `
    {
        m.rt.resetAll();
        var model = m.commitModelRoot(m.initialModel());
        m.rt.frameReset();
        const edits = [_]m.TextInputEvent{
            .{ .insert_text = "hi" },
            .{ .insert_text = " there" },
            .delete_backward,
            .{ .move_caret = .{ .direction = .previous_word, .extend = true } },
            .{ .set_selection = .{ .anchor = 1, .focus = 3 } },
            .{ .set_composition = .{ .text = "x", .cursor = null } },
            .delete_forward,
            .clear,
            .{ .insert_text = "z" },
        };
        for (edits) |edit| {
            model = m.commitModelRoot(m.update(model, .{ .draft_edit = edit }));
            m.rt.frameReset();
            row("d", model.draft);
            row("m", model.moves);
        }
        model = m.commitModelRoot(m.update(model, .reset));
        m.rt.frameReset();
        row("d2", model.draft);
        row("m2", model.moves);
    }
`,
  },
  {
    name: "multi-file core: cross-file helpers/consts and the SDK text engine agree with node",
    src: `
import { applyTextInputEvent, containsIgnoreCase, trimAsciiSpaces, type TextEditState, type TextInputEvent } from "@native-sdk/core/text";
import { STEP, scaled, splitPoint } from "./util.ts";

export function typed(seed: Uint8Array, insert: Uint8Array, caret: number): Uint8Array {
  const state: TextEditState = { text: seed, selection: { anchor: caret, focus: caret }, composition: null };
  const event: TextInputEvent = { kind: "insert_text", text: insert };
  const next = applyTextInputEvent(state, event, 16);
  if (next === null) return seed;
  return next.text;
}
export function wordDeleted(seed: Uint8Array, caret: number): Uint8Array {
  const state: TextEditState = { text: seed, selection: { anchor: caret, focus: caret }, composition: null };
  const event: TextInputEvent = { kind: "delete_word_backward" };
  const next = applyTextInputEvent(state, event, 64);
  if (next === null) return seed;
  return next.text;
}
export function caretAfterHome(seed: Uint8Array, caret: number): number {
  const state: TextEditState = { text: seed, selection: { anchor: caret, focus: caret }, composition: null };
  const event: TextInputEvent = { kind: "move_caret", move: { direction: "start", extend: false } };
  const next = applyTextInputEvent(state, event, 64);
  if (next === null) return caret;
  return next.selection.focus;
}
export function matches(hay: Uint8Array, needle: Uint8Array): boolean {
  return containsIgnoreCase(trimAsciiSpaces(hay), needle);
}
export function stepped(n: number): number {
  return scaled(n) + STEP;
}
export function pivot(xs: Uint8Array): number {
  return splitPoint(xs);
}
`,
    files: {
      "util.ts": `
export const STEP = 7;
export function scaled(n: number): number {
  return n * 3;
}
export function splitPoint(bytes: Uint8Array): number {
  let i = 0;
  while (i < bytes.length && bytes[i] !== 0x2c) i += 1;
  return i;
}
`,
    },
    calls: [
      // Insert mid-text (caret 2 of "hello"), and an over-capacity refusal.
      { fn: "typed", args: [{ t: "bytes", v: [0x68, 0x65, 0x6c, 0x6c, 0x6f] }, { t: "bytes", v: [0x2d, 0x2d] }, i(2)] },
      { fn: "typed", args: [{ t: "bytes", v: [0x68, 0x65, 0x6c, 0x6c, 0x6f] }, { t: "bytes", v: [0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61] }, i(5)] },
      // Word-delete from the end of "one two", and from inside a word.
      { fn: "wordDeleted", args: [{ t: "bytes", v: [0x6f, 0x6e, 0x65, 0x20, 0x74, 0x77, 0x6f] }, i(7)] },
      { fn: "wordDeleted", args: [{ t: "bytes", v: [0x6f, 0x6e, 0x65, 0x20, 0x74, 0x77, 0x6f] }, i(5)] },
      { fn: "caretAfterHome", args: [{ t: "bytes", v: [0x61, 0x62, 0x63] }, i(2)] },
      // ASCII case-insensitive contains over a trimmed haystack.
      { fn: "matches", args: [{ t: "bytes", v: [0x20, 0x48, 0x65, 0x4c, 0x6c, 0x4f, 0x20] }, { t: "bytes", v: [0x65, 0x6c, 0x6c] }] },
      { fn: "matches", args: [{ t: "bytes", v: [0x20, 0x48, 0x65, 0x4c, 0x6c, 0x4f, 0x20] }, { t: "bytes", v: [0x7a] }] },
      // Cross-file const + helper, and a cross-file byte scan.
      { fn: "stepped", args: [i(5)] },
      { fn: "pivot", args: [{ t: "bytes", v: [0x61, 0x62, 0x2c, 0x63] }] },
      { fn: "pivot", args: [{ t: "bytes", v: [0x61, 0x62] }] },
    ],
  },
  {
    name: "do-while runs its body before the first test; continue jumps to the test",
    src: `
export function runsOnce(n: number): number {
  let i = 0;
  let total = 0;
  do { total += 1; i += 1; } while (i < n);
  return total;
}
export function evenHits(limit: number): number {
  let m = 0;
  let hits = 0;
  do {
    m += 1;
    if (m % 2 === 1) continue;
    hits += 1;
  } while (m < limit);
  return hits;
}
export function drains(xs: Uint8Array): number {
  let idx = 0;
  let total = 0;
  do {
    if (idx >= xs.length) break;
    total += xs[idx];
    idx += 1;
  } while (true);
  return total;
}`,
    calls: [
      { fn: "runsOnce", args: [i(0)] }, // body-first: runs once even when the test is false
      { fn: "runsOnce", args: [i(3)] },
      { fn: "evenHits", args: [i(5)] },
      { fn: "evenHits", args: [i(0)] },
      { fn: "drains", args: [{ t: "bytes", v: [3, 4, 5] }] },
      { fn: "drains", args: [{ t: "bytes", v: [] }] },
    ],
  },
  {
    name: "labeled continue re-enters the labeled loop; labeled break exits it; labeled blocks break forward",
    src: `
export function grid(): number {
  let acc = 0;
  outer: for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
      if (j === 1) continue outer;
      acc += i * 10 + j;
    }
  }
  return acc;
}
export function firstPair(xs: Uint8Array, ys: Uint8Array, want: number): number {
  let found = -1;
  scan: for (const x of xs) {
    for (const y of ys) {
      if (x + y === want) { found = x * 100 + y; break scan; }
    }
  }
  return found;
}
export function gated(b: boolean): number {
  let acc = 0;
  work: {
    acc += 1;
    if (b) break work;
    acc += 10;
  }
  return acc;
}
export function labeledWhile(n: number): number {
  let m = 0;
  let spins = 0;
  pump: while (spins < 50) {
    spins += 1;
    if (m >= n) break pump;
    m += 2;
    continue pump;
  }
  return m + spins;
}`,
    calls: [
      { fn: "grid", args: [] },
      { fn: "firstPair", args: [{ t: "bytes", v: [1, 2, 3] }, { t: "bytes", v: [7, 5] }, i(8)] },
      { fn: "firstPair", args: [{ t: "bytes", v: [1, 2] }, { t: "bytes", v: [1] }, i(99)] },
      { fn: "gated", args: [{ t: "b", v: true }] },
      { fn: "gated", args: [{ t: "b", v: false }] },
      { fn: "labeledWhile", args: [i(5)] },
      { fn: "labeledWhile", args: [i(0)] },
    ],
  },
  {
    name: "** matches JS pow exactly: right-associativity, the NaN-exponent and +-1**Infinity corners, fractional results",
    src: `
export function pow(a: number, b: number): number { return a ** b; }
export function towers(): number { return 2 ** 3 ** 2; }
export function squared(x: number): number { let v = x; v **= 2; return v; }`,
    calls: [
      { fn: "pow", args: [f(3), f(4)] },
      { fn: "pow", args: [f(2), f(-2)] }, // 0.25 — float always
      { fn: "pow", args: [f(1), f("nan")] }, // JS: NaN (libm says 1)
      { fn: "pow", args: [f("nan"), f(0)] }, // JS: 1
      { fn: "pow", args: [f(1), f("inf")] }, // JS: NaN
      { fn: "pow", args: [f(-1), f("-inf")] }, // JS: NaN
      { fn: "pow", args: [f(0), f(-1)] }, // Infinity
      { fn: "pow", args: [f("-0"), f(-1)] }, // -Infinity
      { fn: "pow", args: [f(-2), f(0.5)] }, // NaN
      { fn: "pow", args: [f(-2), f(3)] }, // -8
      { fn: "towers", args: [] }, // 512, not 64
      { fn: "squared", args: [f(3)] },
      { fn: "squared", args: [f(-0.5)] },
    ],
  },
  {
    name: "shifts wrap to 32 bits with the count masked, >>> is unsigned, ~ is ToInt32 not",
    src: `
export function shl(a: number, b: number): number {
  let x = 0; let n = 0;
  x = a | 0; n = b | 0;
  return x << n;
}
export function shr(a: number, b: number): number {
  let x = 0; let n = 0;
  x = a | 0; n = b | 0;
  return x >> n;
}
export function ushr(a: number, b: number): number {
  let x = 0; let n = 0;
  x = a | 0; n = b | 0;
  return x >>> n;
}
export function bitNot(a: number): number {
  let x = 0;
  x = a | 0;
  return ~x;
}
export function shiftCompound(a: number): number {
  let v = 0;
  v = a | 0;
  v <<= 3;
  v >>= 1;
  v >>>= 1;
  return v;
}`,
    calls: [
      { fn: "shl", args: [i(1), i(35)] }, // count masked & 31 -> 8
      { fn: "shl", args: [i(5), i(31)] }, // wraps to -2147483648
      { fn: "shl", args: [i(5), i(-1)] }, // count -1 & 31 = 31
      { fn: "shr", args: [i(-9), i(1)] }, // arithmetic: -5
      { fn: "ushr", args: [i(-1), i(0)] }, // 4294967295
      { fn: "ushr", args: [i(-9), i(1)] }, // 2147483643
      { fn: "bitNot", args: [i(5)] }, // -6
      { fn: "bitNot", args: [i(-1)] }, // 0
      { fn: "shiftCompound", args: [i(-3)] },
      { fn: "shiftCompound", args: [i(1000)] },
    ],
  },
  {
    name: "compound assignments equal their x = x op v spellings; logical forms guard the assignment",
    src: `
export function arith(a: number): number {
  let v = a;
  v *= 3;
  v -= 1;
  v %= 7;
  return v;
}
export function floaty(a: number): number {
  let v = a;
  v /= 4;
  v *= 0.5;
  return v;
}
export function bitwise(a: number): number {
  let v = 0;
  v = a | 0;
  v &= 255;
  v |= 16;
  v ^= 3;
  return v;
}
export function logicals(a: boolean, b: boolean): boolean {
  let x = a;
  x &&= b;
  x ||= !b;
  return x;
}
export function nullish(n: number | null): number {
  let v = n;
  v ??= 42;
  return v ?? -1;
}`,
    calls: [
      { fn: "arith", args: [f(6)] },
      { fn: "arith", args: [f(-6)] }, // (-17) % 7 = -3 (truncated, keeps sign)
      { fn: "floaty", args: [f(3)] }, // 0.375
      { fn: "floaty", args: [f("-0")] }, // -0 preserved
      { fn: "bitwise", args: [i(300)] },
      { fn: "bitwise", args: [i(-2)] },
      { fn: "logicals", args: [{ t: "b", v: true }, { t: "b", v: false }] },
      { fn: "logicals", args: [{ t: "b", v: false }, { t: "b", v: true }] },
      { fn: "logicals", args: [{ t: "b", v: true }, { t: "b", v: true }] },
      { fn: "nullish", args: [{ t: "null" }] },
      { fn: "nullish", args: [f(7)] },
      { fn: "nullish", args: [f(0)] }, // 0 is NOT nullish: stays 0
    ],
  },
  {
    name: "a default arm on a union-kind switch matches exactly the uncovered kinds",
    src: `
export type Msg =
  | { readonly kind: "add"; readonly v: number }
  | { readonly kind: "sub"; readonly v: number }
  | { readonly kind: "reset" }
  | { readonly kind: "noop" };
export function apply(sel: number, v: number, acc: number): number {
  const msg: Msg =
    sel === 0 ? { kind: "add", v: v } : sel === 1 ? { kind: "sub", v: v } : sel === 2 ? { kind: "reset" } : { kind: "noop" };
  switch (msg.kind) {
    case "add": return acc + msg.v;
    default: return -1000;
  }
}
function pickSmall(sel: number): Msg {
  return sel === 0 ? { kind: "reset" } : { kind: "noop" };
}
export function applyCovered(sel: number, acc: number): number {
  const msg = pickSmall(sel);
  // Every kind written out plus a default: the default is JS dead code.
  switch (msg.kind) {
    case "add": return acc + 1;
    case "sub": return acc - 1;
    case "reset": return 0;
    case "noop": return acc;
    default: return -1000;
  }
}`,
    calls: [
      { fn: "apply", args: [i(0), f(5), f(10)] },
      { fn: "apply", args: [i(1), f(5), f(10)] },
      { fn: "apply", args: [i(2), f(5), f(10)] },
      { fn: "apply", args: [i(3), f(5), f(10)] },
      { fn: "applyCovered", args: [i(0), f(9)] },
      { fn: "applyCovered", args: [i(1), f(9)] },
    ],
  },
  {
    name: "multi-declaration for-inits and comma incrementors step every counter per iteration",
    src: `
export function meet(n: number): number {
  let acc = 0;
  for (let lo = 0, hi = n; lo < hi; lo++, hi--) {
    acc += 1;
  }
  return acc;
}
export function weave(xs: Uint8Array): number {
  let sum = 0;
  for (let a = 0, b = xs.length - 1; a < b; a += 1, b -= 1) {
    sum += xs[a] * 10 + xs[b];
  }
  return sum;
}
export function countdown(n: number): number {
  let acc = 0;
  for (let i = n; i > 0; i--) acc += i;
  return acc;
}`,
    calls: [
      { fn: "meet", args: [i(6)] },
      { fn: "meet", args: [i(7)] },
      { fn: "meet", args: [i(0)] },
      { fn: "weave", args: [{ t: "bytes", v: [1, 2, 3, 4] }] },
      { fn: "weave", args: [{ t: "bytes", v: [5] }] },
      { fn: "countdown", args: [i(4)] },
      { fn: "countdown", args: [i(0)] },
    ],
  },
  {
    name: "const record destructuring aliases fields exactly (renames, bytes, optionals, float classes)",
    src: `
export interface Stats {
  readonly total: number;
  readonly done: number;
  readonly ratio: number;
  readonly label: Uint8Array;
  readonly last: number | null;
}
function build(total: number, done: number, ratio: number, label: Uint8Array, last: number | null): Stats {
  return { total: total, done: done, ratio: ratio, label: label, last: last };
}
export function summary(total: number, done: number, ratio: number, label: Uint8Array, last: number | null): number {
  const stats = build(total, done, ratio, label, last);
  const { total: totalCount, done: doneCount, ratio: r, last: l } = stats;
  if (totalCount === 0) return -1;
  return doneCount + r * 2 + (l ?? 0) * 100 + totalCount;
}
export function tagByte(label: Uint8Array): number {
  const stats = build(1, 0, 0, label, null);
  const { label: tag } = stats;
  if (tag.length === 0) return -1;
  return tag[0];
}`,
    calls: [
      { fn: "summary", args: [f(4), f(2), f(0.25), { t: "bytes", v: [7] }, f(3)] },
      { fn: "summary", args: [f(0), f(2), f(0.25), { t: "bytes", v: [7] }, { t: "null" }] },
      { fn: "summary", args: [f(4), f(2), f(0.25), { t: "bytes", v: [7] }, { t: "null" }] },
      { fn: "tagByte", args: [{ t: "bytes", v: [65, 66] }] },
      { fn: "tagByte", args: [{ t: "bytes", v: [] }] },
    ],
  },
  {
    name: "unary plus is the identity on numbers (NaN and -0 included); ; is a no-op",
    src: `
export function idPlus(x: number): number { return +x; }
export function stepped(x: number): number { ; let v = +x + 1; ; return v; }`,
    calls: [
      { fn: "idPlus", args: [f(5)] },
      { fn: "idPlus", args: [f("nan")] },
      { fn: "idPlus", args: [f("-0")] },
      { fn: "idPlus", args: [f("-inf")] },
      { fn: "stepped", args: [f(2.5)] },
    ],
  },
  {
    name: "namespace imports alias the target module exactly: values, calls, and qualified types",
    files: {
      "util.ts": `
export interface Cfg { readonly step: number; readonly scale: number; }
export const SEED = 7;
export function bump(n: number, c: Cfg): number { return n + c.step * c.scale; }
export function half(x: number): number { return x / 2; }`,
    },
    src: `
import * as util from "./util.ts";
export function seeded(): number { return util.SEED; }
export function stepped(n: number): number {
  const cfg: util.Cfg = { step: 2, scale: 3 };
  return util.bump(n, cfg);
}
export function halved(x: number): number { return util.half(x); }`,
    calls: [
      { fn: "seeded", args: [] },
      { fn: "stepped", args: [f(10)] },
      { fn: "halved", args: [f(5)] }, // 2.5 — the float class crosses the alias
      { fn: "halved", args: [f("-0")] },
    ],
  },
  {
    name: "entries loop: [i, x] pair over arrays and bytes (index and element agree with node)",
    src: `
export function weighted(xs: readonly number[]): number {
  let t = 0;
  for (const [i, x] of xs.entries()) { t += (i + 1) * x; }
  return t;
}
export function firstMatchIndex(bs: Uint8Array, want: number): number {
  for (const [i, b] of bs.entries()) { if (b === want) return i; }
  return -1;
}
`,
    calls: [
      { fn: "weighted", args: [{ t: "nums", v: [2, 3.5, "-0"] }] },
      { fn: "weighted", args: [{ t: "nums", v: [] }] },
      { fn: "firstMatchIndex", args: [{ t: "bytes", v: [9, 4, 4] }, i(4)] },
      { fn: "firstMatchIndex", args: [{ t: "bytes", v: [9] }, i(4)] },
    ],
  },
  {
    name: "steps in value position: arr[i++] scan order, pre-step value, assignment value",
    src: `
export function everyOther(bs: Uint8Array): number {
  let i = 0;
  let t = 0;
  while (i < bs.length) { t = t * 100 + bs[i++]; i++; }
  return t;
}
export function preStep(): number {
  let count = 4;
  const n = ++count;
  return n * 10 + count;
}
export function assignValue(x: number): number {
  let y = 0;
  const z = (y = x);
  const w = (y += 2);
  return z + w * 1000 + y;
}
`,
    calls: [
      { fn: "everyOther", args: [{ t: "bytes", v: [1, 2, 3, 4, 5] }] },
      { fn: "everyOther", args: [{ t: "bytes", v: [] }] },
      { fn: "preStep", args: [] },
      { fn: "assignValue", args: [f(7)] },
      { fn: "assignValue", args: [f("-0")] },
    ],
  },
  {
    name: "optional chains: element hops, method hops, and the ?? fold",
    src: `
export interface M { readonly xs: Uint8Array; }
export function firstByte(m: M | null): number { return m?.xs[0] ?? -1; }
export function second(xs: readonly number[] | null): number { return xs?.[1] ?? -1; }
export function hasThree(xs: readonly number[] | null): boolean { return xs?.includes(3) ?? false; }
export function windowLen(xs: readonly number[] | null): number {
  const w = xs?.slice(1, 9);
  if (w === undefined) return -1;
  return w.length;
}
`,
    node: `
line("m_hit", mod.firstByte({ xs: Uint8Array.from([7, 8]) }));
line("m_null", mod.firstByte(null));
line("el_hit", mod.second([4, 5, 6]));
line("el_null", mod.second(null));
line("inc_hit", mod.hasThree([1, 3]));
line("inc_null", mod.hasThree(null));
line("win_hit", mod.windowLen([1, 2, 3]));
line("win_null", mod.windowLen(null));
`,
    zig: `
row("m_hit", m.firstByte(.{ .xs = &[_]u8{ 7, 8 } }));
row("m_null", m.firstByte(null));
row("el_hit", m.second(&[_]f64{ 4, 5, 6 }));
row("el_null", m.second(null));
row("inc_hit", m.hasThree(&[_]f64{ 1, 3 }));
row("inc_null", m.hasThree(null));
row("win_hit", m.windowLen(&[_]f64{ 1, 2, 3 }));
row("win_null", m.windowLen(null));
`,
  },
  {
    name: "plain switch: strict equality, case order, mid-position default, gaps",
    src: `
export function grade(n: number): number {
  switch (n) {
    case 1: return 10;
    default: return -1;
    case 2:
    case 3: return 23;
  }
}
export function gapped(n: number): number {
  let out = 0;
  switch (n) {
    case 5: out = 50; break;
    case 6: out = 60; break;
  }
  return out;
}
export function tagOf(s: string): number {
  switch (s) { case "a": return 1; case "b": return 2; default: return 0; }
}
`,
    calls: [
      { fn: "grade", args: [f(1)] },
      { fn: "grade", args: [f(2)] },
      { fn: "grade", args: [f(3)] },
      { fn: "grade", args: [f(9)] },
      { fn: "grade", args: [f("nan")] },
      { fn: "grade", args: [f("-0")] },
      { fn: "grade", args: [f(2.5)] },
      { fn: "gapped", args: [f(5)] },
      { fn: "gapped", args: [f(7)] },
      { fn: "tagOf", args: [{ t: "str", v: "b" }] },
      { fn: "tagOf", args: [{ t: "str", v: "zz" }] },
    ],
  },
  {
    name: "generics: monomorphized helpers behave identically under node (records, optionals, floats, recursion)",
    src: `
export interface Task { readonly id: number; readonly done: boolean; }
export function pick<T>(xs: readonly T[], idx: number): T { return xs[idx]; }
export function first<T>(xs: readonly T[]): T | null {
  return xs.length > 0 ? pick(xs, 0) : null;
}
export function sizeAfter<T>(xs: readonly T[], drop: number): number {
  if (drop <= 0) return xs.length;
  return sizeAfter(xs.slice(1), drop - 1);
}
export function lastNum(xs: readonly number[]): number { return pick(xs, xs.length - 1); }
export function firstDoneId(tasks: readonly Task[]): number {
  const t = first(tasks);
  if (t === null) return -1;
  return t.done ? t.id : -2;
}
export function shrink(xs: readonly number[], n2: number): number { return sizeAfter(xs, n2); }
`,
    node: `
line("last", mod.lastNum([2, 3.5]));
line("last_neg0", mod.lastNum([1, -0]));
line("done", mod.firstDoneId([{ id: 4, done: true }]));
line("not_done", mod.firstDoneId([{ id: 4, done: false }]));
line("empty", mod.firstDoneId([]));
line("shrunk", mod.shrink([9, 9, 9, 9], 3));
`,
    zig: `
row("last", m.lastNum(&[_]f64{ 2, 3.5 }));
row("last_neg0", m.lastNum(&[_]f64{ 1, -0.0 }));
row("done", m.firstDoneId(&[_]m.Task{.{ .id = 4, .done = true }}));
row("not_done", m.firstDoneId(&[_]m.Task{.{ .id = 4, .done = false }}));
row("empty", m.firstDoneId(&[_]m.Task{}));
row("shrunk", m.shrink(&[_]f64{ 9, 9, 9, 9 }, 3));
`,
  },
  {
    name: "local function values: hoisted helpers by direct call, callback pass, and recursion",
    src: `
export function scaled(xs: readonly number[]): readonly number[] {
  const triple = (x: number): number => x * 3;
  return xs.map(triple);
}
export function factorial(n: number): number {
  const fact = (v: number): number => v <= 1 ? 1 : v * fact(v - 1);
  return fact(n);
}
export function applyTwice(x: number): number {
  const bump = (v: number): number => v + 1.5;
  return bump(bump(x));
}
`,
    calls: [
      { fn: "scaled", args: [{ t: "nums", v: [1, 2.5] }] },
      { fn: "factorial", args: [f(5)] },
      { fn: "factorial", args: [f(0)] },
      { fn: "applyTwice", args: [f("-0")] },
      { fn: "applyTwice", args: [f("nan")] },
    ],
  },
  {
    name: "arrays of byte buffers: push-built parts concatenate byte-identically",
    src: `
export function concatAll(parts: readonly Uint8Array[]): Uint8Array {
  let total = 0;
  for (const p of parts) total += p.length;
  const out = new Uint8Array(total);
  let off = 0;
  for (const p of parts) { out.set(p, off); off += p.length; }
  return out;
}
export function joined(a: Uint8Array, b: Uint8Array): Uint8Array {
  const parts: Uint8Array[] = [];
  parts.push(a);
  parts.push(b);
  return concatAll(parts);
}
`,
    calls: [
      { fn: "joined", args: [{ t: "bytes", v: [1, 2] }, { t: "bytes", v: [3, 4, 5] }] },
      { fn: "joined", args: [{ t: "bytes", v: [] }, { t: "bytes", v: [7] }] },
      { fn: "joined", args: [{ t: "bytes", v: [] }, { t: "bytes", v: [] }] },
    ],
  },
  {
    name: "bare function references: map/filter/reduce/toSorted callbacks match the arrow forms",
    src: `
function double(n: number): number { return n * 2; }
function isPositive(n: number): boolean { return n > 0; }
function add(a: number, b: number): number { return a + b; }
function byAscending(a: number, b: number): number { return a - b; }
export function total(xs: readonly number[]): number {
  return xs.map(double).filter(isPositive).reduce(add, 0);
}
export function sorted(xs: readonly number[]): readonly number[] {
  return xs.toSorted(byAscending);
}
`,
    calls: [
      { fn: "total", args: [{ t: "nums", v: [1.5, -2, 3] }] },
      { fn: "total", args: [{ t: "nums", v: [] }] },
      { fn: "sorted", args: [{ t: "nums", v: [3, "-0", 1.25, 2] }] },
      { fn: "sorted", args: [{ t: "nums", v: [] }] },
    ],
  },
  {
    name: "data classes: constructor defaults, mutating methods, field reads match node",
    src: `
export class Counter {
  count: number = 0;
  step: number;
  constructor(step: number) { this.step = step; }
  bump(): void { this.count += this.step; }
  scaled(by: number): number { return this.count * by; }
}
export class Accumulator {
  values: readonly number[] = [];
  push(v: number): void { this.values = [...this.values, v]; }
  total(): number {
    let sum = 0;
    for (const v of this.values) sum += v;
    return sum;
  }
}
export function run(step: number, times: number): number {
  const c = new Counter(step);
  for (let i = 0; i < times; i++) c.bump();
  return c.scaled(2);
}
export function accumulate(xs: readonly number[]): number {
  const a = new Accumulator();
  for (const x of xs) a.push(x);
  return a.total();
}
export function direct(seed: number): number {
  const c = new Counter(seed);
  c.count = 10;
  c.count += seed;
  return c.count;
}
`,
    calls: [
      { fn: "run", args: [f(2.5), i(3)] },
      { fn: "run", args: [i(4), i(0)] },
      { fn: "accumulate", args: [{ t: "nums", v: [1.25, -2, "-0"] }] },
      { fn: "accumulate", args: [{ t: "nums", v: [] }] },
      { fn: "direct", args: [f(0.5)] },
      { fn: "direct", args: [i(7)] },
    ],
  },
  {
    name: "exceptions: parser throw/catch/narrow chain matches node byte for byte",
    src: `
export type ParseError =
  | { readonly kind: "bad_digit"; readonly at: number }
  | { readonly kind: "empty" };
function parseDigits(bytes: Uint8Array): number {
  if (bytes.length === 0) throw { kind: "empty" } as ParseError;
  let n = 0;
  for (let i = 0; i < bytes.length; i++) {
    const b = bytes[i];
    if (b < 48 || b > 57) throw { kind: "bad_digit", at: i } as ParseError;
    n = n * 10 + (b - 48);
  }
  return n;
}
export function safeParse(bytes: Uint8Array): number {
  try {
    return parseDigits(bytes);
  } catch (e) {
    const err = e as ParseError;
    if (err.kind === "bad_digit") return -err.at - 1;
    return -1000;
  }
}
`,
    calls: [
      { fn: "safeParse", args: [{ t: "bytes", v: [49, 50, 51] }] },
      { fn: "safeParse", args: [{ t: "bytes", v: [49, 65, 51] }] },
      { fn: "safeParse", args: [{ t: "bytes", v: [65] }] },
      { fn: "safeParse", args: [{ t: "bytes", v: [] }] },
    ],
  },
  {
    name: "exceptions: a throw inside a map callback unwinds out of the lowered loop",
    src: `
export type Bad = { readonly kind: "bad"; readonly at: number } | { readonly kind: "none" };
export function firstBad(xs: readonly number[]): number {
  try {
    const doubled = xs.map((x, i) => {
      if (x < 0) throw { kind: "bad", at: i } as Bad;
      return x * 2;
    });
    return doubled.length;
  } catch (e) {
    const err = e as Bad;
    return err.kind === "bad" ? -err.at - 1 : -99;
  }
}
`,
    calls: [
      { fn: "firstBad", args: [{ t: "nums", v: [1, 2, -3, 4] }] },
      { fn: "firstBad", args: [{ t: "nums", v: [-1] }] },
      { fn: "firstBad", args: [{ t: "nums", v: [1, 2] }] },
      { fn: "firstBad", args: [{ t: "nums", v: [] }] },
    ],
  },
  {
    name: "exceptions: rethrow, nested try, and finally ordering match node",
    src: `
export type Fail = { readonly kind: "inner"; readonly n: number } | { readonly kind: "outer"; readonly n: number };
export function f(x: number): number {
  let log = 0;
  try {
    try {
      if (x > 0) throw { kind: "inner", n: x } as Fail;
      log += 1;
    } catch (e) {
      const err = e as Fail;
      if (err.kind === "inner") {
        if (err.n > 5) throw { kind: "outer", n: err.n } as Fail;
      }
      throw e;
    } finally {
      log += 10;
    }
  } catch (e) {
    const err = e as Fail;
    const tag = err.kind === "outer" ? 2 : 1;
    return log * 100 + tag;
  }
  return log;
}
`,
    calls: [
      { fn: "f", args: [f(3)] },
      { fn: "f", args: [f(9)] },
      { fn: "f", args: [f(-1)] },
      { fn: "f", args: [f(0.5)] },
    ],
  },
  {
    name: "exceptions: try/finally interleaves with loop break and continue like node",
    src: `
export type Never2 = { readonly kind: "never" } | { readonly kind: "either" };
export function loopLog(n: number): number {
  let log = 0;
  for (let i = 0; i < n; i++) {
    try {
      if (i === 1) continue;
      if (i === 3) break;
      log = log * 10 + 1;
    } finally {
      log = log * 10 + 2;
    }
  }
  return log;
}
export function sumUntilNeg(xs: readonly number[]): number {
  let sum = 0;
  try {
    for (const x of xs) {
      if (x < 0) throw { kind: "never" } as Never2;
      sum += x;
    }
    return sum;
  } catch {
    return -sum;
  }
}
`,
    calls: [
      { fn: "loopLog", args: [i(0)] },
      { fn: "loopLog", args: [i(1)] },
      { fn: "loopLog", args: [i(2)] },
      { fn: "loopLog", args: [i(6)] },
      { fn: "sumUntilNeg", args: [{ t: "nums", v: [1, 2.5, -1, 4] }] },
      { fn: "sumUntilNeg", args: [{ t: "nums", v: [1, 2] }] },
    ],
  },
  {
    name: "exceptions: a throw mid-mutation keeps the owned array's prior state (node parity)",
    src: `
export type Halt = { readonly kind: "halt" } | { readonly kind: "never" };
export function f(stop: number): number {
  const xs: number[] = [];
  try {
    xs.push(1);
    xs.push(2);
    if (xs.length >= stop) throw { kind: "halt" } as Halt;
    xs.push(3);
  } catch {
    return xs.length;
  }
  return xs.length * 10;
}
`,
    calls: [
      { fn: "f", args: [i(2)] },
      { fn: "f", args: [i(1)] },
      { fn: "f", args: [i(5)] },
    ],
  },
  {
    name: "exceptions: class constructors and methods throw like node",
    src: `
export type Range2 = { readonly kind: "range"; readonly v: number } | { readonly kind: "none" };
export class Gauge {
  v: number;
  constructor(v: number) {
    if (v < 0) throw { kind: "range", v } as Range2;
    this.v = v;
  }
  add(d: number): void {
    if (this.v + d > 100) throw { kind: "range", v: this.v + d } as Range2;
    this.v += d;
  }
}
export function run(start: number, d: number): number {
  try {
    const g = new Gauge(start);
    g.add(d);
    return g.v;
  } catch (e) {
    const err = e as Range2;
    return err.kind === "range" ? -err.v : -1;
  }
}
`,
    calls: [
      { fn: "run", args: [f(10), f(5.5)] },
      { fn: "run", args: [f(-2), f(0)] },
      { fn: "run", args: [f(60), f(50)] },
    ],
  },
  {
    name: "exceptions: number-shaped throws ride the f64 payload slot",
    src: `
export function g(x: number): number {
  try {
    if (x > 5) throw x * 2;
    return x;
  } catch (e) {
    const n = e as number;
    return n + 0.5;
  }
}
`,
    calls: [
      { fn: "g", args: [f(1.5)] },
      { fn: "g", args: [f(6)] },
      { fn: "g", args: [f(7.25)] },
    ],
  },
  {
    name: "exceptions: switch-case throws, try inside callbacks, labeled-loop throws",
    src: `
export type E = { readonly kind: "bad" } | { readonly kind: "stop" };
export function viaSwitch(n: number): number {
  try {
    switch (n) {
      case 1: throw { kind: "bad" } as E;
      case 2: return 20;
      default: return 0;
    }
  } catch { return -1; }
}
function classify(x: number): number {
  if (x < 0) throw { kind: "bad" } as E;
  return x * 2;
}
export function mapWithLocalCatch(xs: readonly number[]): readonly number[] {
  return xs.map((x) => {
    try {
      return classify(x);
    } catch {
      return -1;
    }
  });
}
export function labeled(n: number): number {
  let acc = 0;
  try {
    outer: for (let i = 0; i < n; i++) {
      for (let j = 0; j < 3; j++) {
        if (i + j === 4) throw { kind: "stop" } as E;
        if (j === 2) continue outer;
        acc += 1;
      }
    }
    return acc;
  } catch {
    return -acc;
  }
}
`,
    calls: [
      { fn: "viaSwitch", args: [i(1)] },
      { fn: "viaSwitch", args: [i(2)] },
      { fn: "viaSwitch", args: [i(9)] },
      { fn: "mapWithLocalCatch", args: [{ t: "nums", v: [1, -2, 3.5] }] },
      { fn: "mapWithLocalCatch", args: [{ t: "nums", v: [] }] },
      { fn: "labeled", args: [i(2)] },
      { fn: "labeled", args: [i(6)] },
      { fn: "labeled", args: [i(0)] },
    ],
  },
  {
    name: "export lists and value re-exports: renamed bindings and a re-export chain agree with node",
    src: `
import { bump } from "./api.ts";
function tripled(n: number): number { return n * 3; }
export { tripled as thrice };
export { bump } from "./api.ts";
export { OFFSET as BASE } from "./api.ts";
export function combined(n: number): number { return bump(n) + tripled(n); }
`,
    files: {
      "api.ts": `
export { bump, OFFSET } from "./impl.ts";
`,
      "impl.ts": `
export const OFFSET = 40;
export function bump(n: number): number { return n + OFFSET; }
`,
    },
    calls: [
      { fn: "combined", args: [i(5)] },
      { fn: "combined", args: [i(-3)] },
      { fn: "thrice", args: [i(7)] },
      { fn: "bump", args: [i(2)] },
    ],
  },
  {
    name: "heterogeneous throws: the thrown union narrows by kind in the catch, chains and callbacks included",
    src: `
export interface ParseError { readonly kind: "parse"; readonly at: number; }
export interface IoError { readonly kind: "io"; readonly code: number; readonly hard: boolean; }
export type Low = { readonly kind: "under"; readonly by: number } | { readonly kind: "zero" };
function inner(n: number): number {
  if (n < 0) throw { kind: "parse", at: n } as ParseError;
  if (n > 100) throw { kind: "io", code: n, hard: n > 1000 } as IoError;
  return n * 2;
}
function middle(n: number): number {
  // A throw two frames down unwinds through this one untouched.
  return inner(n) + 1;
}
export function catches(n: number): number {
  try {
    return middle(n);
  } catch (e) {
    if (e.kind === "parse") return e.at - 1000;
    if (e.kind === "io") return e.hard ? -e.code : e.code;
    return -1;
  }
}
export function viaSwitchAndUnion(n: number): number {
  try {
    if (n < 0) { const low: Low = n === -1 ? { kind: "zero" } : { kind: "under", by: n }; throw low; }
    return inner(n);
  } catch (e) {
    switch (e.kind) {
      case "under": return e.by - 100;
      case "zero": return -7;
      case "io": return e.code + 5;
      default: return -2;
    }
  }
}
export function callbackThrows(xs: readonly number[]): number {
  try {
    const doubled = xs.map((x) => {
      if (x < 0) throw { kind: "parse", at: x } as ParseError;
      if (x > 100) throw { kind: "io", code: x, hard: false } as IoError;
      return x * 2;
    });
    return doubled.length;
  } catch (e) {
    if (e.kind === "parse") return e.at;
    if (e.kind === "io") return e.code + 900;
    return -3;
  }
}
export function narrowedInCallback(xs: readonly number[], n: number): number {
  try {
    return inner(n);
  } catch (e) {
    if (e.kind === "io") {
      // The narrowed arm's payload read inside an inline callback.
      return xs.filter((x) => x > e.code).length;
    }
    return -4;
  }
}
export function rethrowNarrowed(n: number): number {
  try {
    try {
      return inner(n);
    } catch (e) {
      if (e.kind === "io") throw e; // rethrow of a narrowed arm re-raises the bound value
      return -5;
    }
  } catch (e2) {
    if (e2.kind === "io") return e2.hard ? e2.code + 7000 : e2.code + 70;
    return -9;
  }
}
`,
    calls: [
      { fn: "catches", args: [i(4)] },
      { fn: "catches", args: [i(-6)] },
      { fn: "catches", args: [i(300)] },
      { fn: "catches", args: [i(3000)] },
      { fn: "viaSwitchAndUnion", args: [i(5)] },
      { fn: "viaSwitchAndUnion", args: [i(-1)] },
      { fn: "viaSwitchAndUnion", args: [i(-8)] },
      { fn: "viaSwitchAndUnion", args: [i(200)] },
      { fn: "callbackThrows", args: [{ t: "nums", v: [1, 2, 3] }] },
      { fn: "callbackThrows", args: [{ t: "nums", v: [1, -4, 3] }] },
      { fn: "callbackThrows", args: [{ t: "nums", v: [1, 400, -2] }] },
      { fn: "narrowedInCallback", args: [{ t: "nums", v: [50, 150, 250] }, i(120)] },
      { fn: "narrowedInCallback", args: [{ t: "nums", v: [50, 150, 250] }, i(7)] },
      { fn: "rethrowNarrowed", args: [i(6)] },
      { fn: "rethrowNarrowed", args: [i(-2)] },
      { fn: "rethrowNarrowed", args: [i(500)] },
      { fn: "rethrowNarrowed", args: [i(5000)] },
    ],
  },
  {
    name: "class statics: static methods and consts behave identically under node and native",
    src: `
export class Gauge {
  reading: number;
  static readonly CEILING = 100;
  static readonly FLOOR = -10;
  constructor(reading: number) { this.reading = reading; }
  static clamp(v: number): number {
    if (v > Gauge.CEILING) return Gauge.CEILING;
    if (v < Gauge.FLOOR) return Gauge.FLOOR;
    return v;
  }
  static span(): number { return Gauge.CEILING - Gauge.FLOOR; }
  private normalized(): number { return Gauge.clamp(this.reading); }
  read(): number { return this.normalized(); }
}
export function measure(v: number): number {
  const g = new Gauge(v);
  return g.read() + Gauge.span();
}
export function clamped(v: number): number {
  return Gauge.clamp(v);
}
`,
    calls: [
      { fn: "measure", args: [i(50)] },
      { fn: "measure", args: [i(500)] },
      { fn: "measure", args: [i(-50)] },
      { fn: "clamped", args: [f(99.5)] },
      { fn: "clamped", args: [f("nan")] },
    ],
  },
  {
    name: "mutation loosenings: append writes, reassigned owning bindings, and readonly borrows match node",
    src: `
function total(xs: readonly number[]): number {
  let t = 0;
  for (const x of xs) { t += x; }
  return t;
}
function spread(xs: readonly number[]): number {
  // A borrowed slice read through nested borrowing calls.
  return total(xs) - xs.length;
}
export function appends(xs: readonly number[]): readonly number[] {
  const out: number[] = [];
  for (const x of xs) {
    if (x >= 0) out[out.length] = x * 2;
    else out.push(-x);
  }
  out[out.length] = total(out);
  return out;
}
export function rebuilt(xs: readonly number[], flip: boolean): readonly number[] {
  let w = xs.slice();
  w.push(100);
  if (flip) {
    w = xs.filter((x) => x > 0);
    w.push(200);
  }
  w.sort((a, b) => a - b);
  return w;
}
export function resetToEmpty(n: number): number {
  let acc: number[] = [n, n + 1];
  acc.push(n + 2);
  acc = [];
  acc.push(n * 10);
  return acc.length * 1000 + acc[0];
}
export function borrowed(n: number): number {
  const out: number[] = [n];
  const before = spread(out);
  out.push(n + 1);
  out[out.length] = n + 2;
  const mid = total(out);
  out.push(n + 3);
  return before + mid + total(out);
}
`,
    calls: [
      { fn: "appends", args: [{ t: "nums", v: [1, -2, 3] }] },
      { fn: "appends", args: [{ t: "nums", v: [] }] },
      { fn: "rebuilt", args: [{ t: "nums", v: [3, -1, 2] }, { t: "b", v: true }] },
      { fn: "rebuilt", args: [{ t: "nums", v: [3, -1, 2] }, { t: "b", v: false }] },
      { fn: "resetToEmpty", args: [i(4)] },
      { fn: "borrowed", args: [i(5)] },
      { fn: "borrowed", args: [i(-7)] },
    ],
  },
  {
    name: "byte text: simple case mapping is byte-identical (ASCII, Greek, Cyrillic, growth, invalid passthrough)",
    src: `
export function up(s: Uint8Array): Uint8Array { return s.toUpperCase(); }
export function low(s: Uint8Array): Uint8Array { return s.toLowerCase(); }
export function roundTrip(s: Uint8Array): Uint8Array { return s.toUpperCase().toLowerCase(); }
`,
    calls: [
      { fn: "up", args: [{ t: "bytes", v: [104, 101, 108, 108, 111, 33] }] }, // "hello!"
      { fn: "up", args: [{ t: "bytes", v: [207, 131, 206, 175, 207, 131, 207, 133, 207, 134, 206, 191, 207, 130] }] }, // σίσυφος (final sigma)
      { fn: "low", args: [{ t: "bytes", v: [208, 159, 208, 160, 208, 152, 208, 146, 208, 149, 208, 162] }] }, // ПРИВЕТ
      { fn: "up", args: [{ t: "bytes", v: [115, 116, 114, 97, 195, 159, 101] }] }, // straße: ß has NO simple upper — stays ß
      { fn: "up", args: [{ t: "bytes", v: [197, 191] }] }, // ſ -> S (2 bytes -> 1)
      { fn: "up", args: [{ t: "bytes", v: [194, 181] }] }, // µ -> Μ (2 -> 2)
      { fn: "up", args: [{ t: "bytes", v: [200, 191] }] }, // ȿ U+023F -> U+2C7E (2 -> 3, growth)
      { fn: "up", args: [{ t: "bytes", v: [240, 144, 144, 168] }] }, // Deseret U+10428 -> U+10400 (4 -> 4)
      { fn: "up", args: [{ t: "bytes", v: [97, 255, 195] }] }, // invalid lead + truncated tail pass through
      { fn: "low", args: [{ t: "bytes", v: [224, 128, 97, 128, 65] }] }, // overlong lead, lone continuation
      { fn: "up", args: [{ t: "bytes", v: [237, 160, 128, 66] }] }, // surrogate encoding is invalid: passthrough
      { fn: "up", args: [{ t: "bytes", v: [] }] },
      { fn: "roundTrip", args: [{ t: "bytes", v: [206, 163, 206, 145, 206, 155] }] }, // ΣΑΛ -> σαλ (Σ lowers to σ, never final ς)
    ],
  },
  {
    name: "byte text: repeat edges and byte-honest padding (multi-byte fill truncates by bytes)",
    src: `
import { asciiBytes } from "@native-sdk/core";
export function rep(s: Uint8Array, n: number): Uint8Array { return s.repeat(n); }
export function padDefault(s: Uint8Array, n: number): Uint8Array { return s.padStart(n); }
export function padCustom(s: Uint8Array, n: number, fill: Uint8Array): Uint8Array { return s.padStart(n, fill); }
export function padEndCustom(s: Uint8Array, n: number, fill: Uint8Array): Uint8Array { return s.padEnd(n, fill); }
export function gauge(used: number): Uint8Array { return asciiBytes("#").repeat(used).padEnd(8, asciiBytes(".")); }
`,
    calls: [
      { fn: "rep", args: [{ t: "bytes", v: [97, 98] }, i(3)] },
      { fn: "rep", args: [{ t: "bytes", v: [97, 98] }, i(0)] },
      { fn: "rep", args: [{ t: "bytes", v: [] }, i(5)] },
      { fn: "rep", args: [{ t: "bytes", v: [195, 169] }, i(2)] }, // multi-byte é
      { fn: "padDefault", args: [{ t: "bytes", v: [97, 98] }, i(5)] },
      { fn: "padDefault", args: [{ t: "bytes", v: [97, 98] }, i(1)] }, // at/under target: unchanged
      { fn: "padDefault", args: [{ t: "bytes", v: [97, 98] }, i(-3)] }, // negative target: unchanged
      { fn: "padCustom", args: [{ t: "bytes", v: [97, 98] }, i(8), { t: "bytes", v: [120, 121] }] }, // xy fill truncates
      { fn: "padCustom", args: [{ t: "bytes", v: [97] }, i(4), { t: "bytes", v: [195, 169] }] }, // é fill cut MID-SEQUENCE at byte 3: byte-honest, identical both sides
      { fn: "padCustom", args: [{ t: "bytes", v: [97, 98] }, i(9), { t: "bytes", v: [] }] }, // empty fill: unchanged
      { fn: "padEndCustom", args: [{ t: "bytes", v: [97, 98] }, i(7), { t: "bytes", v: [46] }] },
      { fn: "padDefault", args: [{ t: "bytes", v: [195, 169] }, i(4)] }, // é is 2 BYTES: 2 pad bytes, not 3
      { fn: "gauge", args: [i(3)] },
    ],
  },
  {
    name: "byte text: search dispatches by argument type (bytes substring vs byte element)",
    src: `
export function starts(s: Uint8Array, t: Uint8Array): boolean { return s.startsWith(t); }
export function ends(s: Uint8Array, t: Uint8Array): boolean { return s.endsWith(t); }
export function hasSub(s: Uint8Array, t: Uint8Array): boolean { return s.includes(t); }
export function hasByte(s: Uint8Array, b: number): boolean { return s.includes(b); }
export function idxSub(s: Uint8Array, t: Uint8Array): number { return s.indexOf(t); }
export function idxByte(s: Uint8Array, b: number): number { return s.indexOf(b); }
export function lastSub(s: Uint8Array, t: Uint8Array): number { return s.lastIndexOf(t); }
export function lastByte(s: Uint8Array, b: number): number { return s.lastIndexOf(b); }
`,
    calls: [
      { fn: "starts", args: [{ t: "bytes", v: [97, 98, 99] }, { t: "bytes", v: [97, 98] }] },
      { fn: "starts", args: [{ t: "bytes", v: [97, 98, 99] }, { t: "bytes", v: [] }] }, // empty needle: true
      { fn: "starts", args: [{ t: "bytes", v: [97] }, { t: "bytes", v: [97, 98] }] }, // needle longer than hay
      { fn: "ends", args: [{ t: "bytes", v: [97, 98, 99] }, { t: "bytes", v: [98, 99] }] },
      { fn: "ends", args: [{ t: "bytes", v: [97, 98, 99] }, { t: "bytes", v: [] }] },
      { fn: "hasSub", args: [{ t: "bytes", v: [97, 88, 98, 88] }, { t: "bytes", v: [88, 98] }] },
      { fn: "hasSub", args: [{ t: "bytes", v: [97, 98] }, { t: "bytes", v: [99] }] },
      { fn: "hasByte", args: [{ t: "bytes", v: [65, 66, 67] }, i(66)] },
      { fn: "hasByte", args: [{ t: "bytes", v: [65, 66, 67] }, f(66.5)] }, // SameValueZero: no byte is 66.5
      { fn: "hasByte", args: [{ t: "bytes", v: [0, 1] }, f("-0")] }, // -0 matches 0
      { fn: "hasByte", args: [{ t: "bytes", v: [65] }, f("nan")] }, // NaN matches nothing
      { fn: "hasByte", args: [{ t: "bytes", v: [65] }, i(300)] }, // out of byte range
      { fn: "idxSub", args: [{ t: "bytes", v: [97, 88, 98, 88] }, { t: "bytes", v: [88] }] },
      { fn: "idxSub", args: [{ t: "bytes", v: [97, 98, 99] }, { t: "bytes", v: [] }] }, // empty: 0
      { fn: "idxSub", args: [{ t: "bytes", v: [97] }, { t: "bytes", v: [98] }] }, // missing: -1
      { fn: "idxByte", args: [{ t: "bytes", v: [65, 66, 67, 66] }, i(66)] },
      { fn: "lastSub", args: [{ t: "bytes", v: [97, 97, 97, 97] }, { t: "bytes", v: [97, 97] }] }, // overlap: 2
      { fn: "lastSub", args: [{ t: "bytes", v: [97, 98, 99] }, { t: "bytes", v: [] }] }, // empty: hay.length
      { fn: "lastByte", args: [{ t: "bytes", v: [65, 66, 67, 66] }, i(66)] },
      { fn: "lastByte", args: [{ t: "bytes", v: [65] }, i(90)] },
    ],
  },
  {
    name: "byte text: the trim family strips the JS whitespace set over UTF-8, views only",
    src: `
import { trimAsciiSpaces } from "@native-sdk/core/text";
export function t(s: Uint8Array): Uint8Array { return s.trim(); }
export function ts(s: Uint8Array): Uint8Array { return s.trimStart(); }
export function te(s: Uint8Array): Uint8Array { return s.trimEnd(); }
export function sdkDiff(s: Uint8Array): number {
  // Reconciliation pin: .trim() strips the JS set (\\n included); the SDK's
  // trimAsciiSpaces stays byte-exact ASCII (space/tab/CR, never LF).
  return s.trim().length * 100 + trimAsciiSpaces(s).length;
}
`,
    calls: [
      { fn: "t", args: [{ t: "bytes", v: [194, 160, 9, 32, 97, 32, 98, 32, 10, 227, 128, 128] }] }, // NBSP \t sp "a b" sp \n IDEOGRAPHIC SPACE
      { fn: "ts", args: [{ t: "bytes", v: [239, 187, 191, 97] }] }, // U+FEFF is JS whitespace
      { fn: "te", args: [{ t: "bytes", v: [97, 13, 10] }] },
      { fn: "t", args: [{ t: "bytes", v: [255, 32, 97, 32, 255] }] }, // invalid bytes stop the trim
      { fn: "t", args: [{ t: "bytes", v: [32, 32, 32] }] }, // all whitespace -> empty
      { fn: "t", args: [{ t: "bytes", v: [] }] },
      { fn: "sdkDiff", args: [{ t: "bytes", v: [32, 97, 10, 32] }] }, // " a\\n " -> trim 1, trimAsciiSpaces 2 ("a\\n")
    ],
  },
  {
    name: "byte text: split shapes, multi-byte separators, ownership of the parts array, and at()",
    src: `
import { asciiBytes } from "@native-sdk/core";
export function parts(s: Uint8Array, sep: Uint8Array): number { return s.split(sep).length; }
export function part(s: Uint8Array, sep: Uint8Array, i: number): Uint8Array {
  const xs = s.split(sep);
  return xs[i];
}
export function grown(s: Uint8Array): number {
  const xs = s.split(asciiBytes(","));
  xs.push(asciiBytes("tail"));
  let total = 0;
  for (const p of xs) total += p.length;
  return total * 10 + xs.length;
}
export function at(s: Uint8Array, i: number): number { return s.at(i) ?? -1; }
export function atMiss(s: Uint8Array, i: number): boolean { return s.at(i) === undefined; }
`,
    calls: [
      { fn: "parts", args: [{ t: "bytes", v: [88, 97, 88, 98, 88] }, { t: "bytes", v: [88] }] }, // "XaXbX" -> 4
      { fn: "parts", args: [{ t: "bytes", v: [97, 88, 88, 98] }, { t: "bytes", v: [88] }] }, // adjacent -> 3
      { fn: "parts", args: [{ t: "bytes", v: [97, 98] }, { t: "bytes", v: [90] }] }, // no match -> 1
      { fn: "parts", args: [{ t: "bytes", v: [] }, { t: "bytes", v: [88] }] }, // "" -> [""]
      { fn: "parts", args: [{ t: "bytes", v: [97, 97, 97, 97] }, { t: "bytes", v: [97, 97] }] }, // non-overlapping -> 3
      { fn: "part", args: [{ t: "bytes", v: [88, 97, 88, 98, 88] }, { t: "bytes", v: [88] }, i(0)] },
      { fn: "part", args: [{ t: "bytes", v: [88, 97, 88, 98, 88] }, { t: "bytes", v: [88] }, i(1)] },
      { fn: "part", args: [{ t: "bytes", v: [88, 97, 88, 98, 88] }, { t: "bytes", v: [88] }, i(3)] },
      { fn: "part", args: [{ t: "bytes", v: [97, 195, 169, 98] }, { t: "bytes", v: [195, 169] }, i(1)] }, // multi-byte separator
      { fn: "grown", args: [{ t: "bytes", v: [97, 44, 98, 98] }] },
      { fn: "at", args: [{ t: "bytes", v: [65, 66, 67] }, i(0)] },
      { fn: "at", args: [{ t: "bytes", v: [65, 66, 67] }, i(-1)] },
      { fn: "at", args: [{ t: "bytes", v: [65, 66, 67] }, i(-4)] }, // out of range from the end
      { fn: "at", args: [{ t: "bytes", v: [65, 66, 67] }, i(3)] },
      { fn: "atMiss", args: [{ t: "bytes", v: [65] }, i(2)] },
      { fn: "atMiss", args: [{ t: "bytes", v: [65] }, i(0)] },
    ],
  },
];

// ------------------------------------------------------------ arg spelling

function numToZig(v: number): string {
  if (Object.is(v, -0)) return "-0.0";
  const s = String(v);
  return /[.eE]/.test(s) ? s : `${s}.0`;
}

function zigArg(a: Arg): string {
  switch (a.t) {
    case "i":
      return String(a.v);
    case "f":
      if (a.v === "nan") return "std.math.nan(f64)";
      if (a.v === "inf") return "std.math.inf(f64)";
      if (a.v === "-inf") return "-std.math.inf(f64)";
      if (a.v === "-0") return "-0.0";
      return numToZig(a.v);
    case "b":
      return a.v ? "true" : "false";
    case "null":
      return "null";
    case "bytes":
      return `&[_]u8{${a.v.join(", ")}}`;
    case "nums":
      return `&[_]f64{${a.v.map(numElemToZig).join(", ")}}`;
    case "tag":
      return `.${a.v}`;
    case "str":
      return JSON.stringify(a.v);
  }
}

function numElemToZig(v: number | "nan" | "-0"): string {
  if (v === "nan") return "std.math.nan(f64)";
  if (v === "-0") return "-0.0";
  return numToZig(v);
}

function nodeArg(a: Arg): string {
  switch (a.t) {
    case "i":
      return String(a.v);
    case "f":
      if (a.v === "nan") return "NaN";
      if (a.v === "inf") return "Infinity";
      if (a.v === "-inf") return "-Infinity";
      if (a.v === "-0") return "-0";
      return String(a.v);
    case "b":
      return a.v ? "true" : "false";
    case "null":
      return "null";
    case "bytes":
      return `Uint8Array.from([${a.v.join(", ")}])`;
    case "nums":
      return `[${a.v.map((v) => (v === "nan" ? "NaN" : String(v))).join(", ")}]`;
    case "tag":
      return JSON.stringify(a.v);
    case "str":
      return JSON.stringify(a.v);
  }
}

// --------------------------------------------------------- driver assembly

function caseId(idx: number): string {
  return `case_${String(idx).padStart(2, "0")}`;
}

function nodeDriver(cases: readonly RunCase[]): string {
  const lines: string[] = [
    "// Generated run-fidelity driver, plain-TS side: import each case module",
    "// as-is and print the canonical transcript to stdout.",
    "// The byte-text methods install before any call runs — the same tables",
    "// rt.zig case-maps from, so the two transcripts must match bytewise.",
    'import { installTextMethods } from "./text_polyfill.ts";',
  ];
  cases.forEach((c, idx) =>
    lines.push(`import * as ${caseId(idx)} from "./${c.files ? `${caseId(idx)}/core.ts` : `${caseId(idx)}.ts`}";`),
  );
  lines.push(
    "",
    "installTextMethods();",
    "const out = [];",
    "function hex(bytes) {",
    '  let s = "";',
    '  for (const b of bytes) s += b.toString(16).padStart(2, "0");',
    "  return s;",
    "}",
    "function fmt(v) {",
    '  if (v === null) return "null";',
    '  if (typeof v === "boolean") return v ? "b:true" : "b:false";',
    '  if (typeof v === "number") {',
    '    if (Number.isNaN(v)) return "n:nan";',
    "    const dv = new DataView(new ArrayBuffer(8));",
    "    dv.setFloat64(0, v);",
    '    let s = "n:";',
    '    for (let idx = 0; idx < 8; idx++) s += dv.getUint8(idx).toString(16).padStart(2, "0");',
    "    return s;",
    "  }",
    '  if (typeof v === "string") return "x:" + hex(new TextEncoder().encode(v));',
    '  if (v instanceof Uint8Array) return "x:" + hex(v);',
    '  if (Array.isArray(v)) return "[" + v.map(fmt).join(",") + "]";',
    '  throw new Error("unsupported value in the run-fidelity transcript");',
    "}",
    "",
  );
  cases.forEach((c, idx) => {
    const id = caseId(idx);
    for (const [ci, call] of (c.calls ?? []).entries()) {
      lines.push(`out.push("${id}.${ci} " + fmt(${id}.${call.fn}(${call.args.map(nodeArg).join(", ")})));`);
    }
    if (c.node) {
      lines.push(`{`);
      lines.push(`  const mod = ${id};`);
      lines.push(`  const line = (tag, v) => out.push("${id}." + tag + " " + fmt(v));`);
      lines.push(c.node.trim());
      lines.push(`}`);
    }
  });
  lines.push("", 'process.stdout.write(out.join("\\n") + "\\n");', "");
  return lines.join("\n");
}

function zigDriver(cases: readonly RunCase[]): string {
  const lines: string[] = [
    "//! Generated run-fidelity driver, native side: run every case's emitted",
    "//! module and write the canonical transcript; the plain-TS driver must",
    "//! produce identical bytes.",
    "",
    'const std = @import("std");',
  ];
  cases.forEach((_, idx) => lines.push(`const ${caseId(idx)} = @import("${caseId(idx)}.zig");`));
  lines.push(
    "",
    "var sink: std.ArrayList(u8) = .empty;",
    "var gpa: std.mem.Allocator = undefined;",
    "",
    "fn put(s: []const u8) void {",
    '    sink.appendSlice(gpa, s) catch @panic("oom");',
    "}",
    "",
    "fn putHexByte(b: u8) void {",
    '    const digits = "0123456789abcdef";',
    '    sink.append(gpa, digits[b >> 4]) catch @panic("oom");',
    '    sink.append(gpa, digits[b & 0xf]) catch @panic("oom");',
    "}",
    "",
    "// Numbers travel as f64 bit patterns (any NaN canonicalizes to n:nan),",
    "// so the transcript never depends on float-to-text formatting.",
    "fn putNum(x: f64) void {",
    "    if (std.math.isNan(x)) {",
    '        put("n:nan");',
    "        return;",
    "    }",
    '    put("n:");',
    "    const bits: u64 = @bitCast(x);",
    "    var idx: usize = 0;",
    "    while (idx < 8) : (idx += 1) {",
    "        putHexByte(@truncate(bits >> @intCast((7 - idx) * 8)));",
    "    }",
    "}",
    "",
    "fn putValue(v: anytype) void {",
    "    const T = @TypeOf(v);",
    "    switch (@typeInfo(T)) {",
    '        .bool => put(if (v) "b:true" else "b:false"),',
    "        .int, .comptime_int => putNum(@floatFromInt(v)),",
    "        .float, .comptime_float => putNum(v),",
    '        .optional => if (v) |inner| putValue(inner) else put("null"),',
    '        .@"enum" => {',
    '            put("x:");',
    "            for (@tagName(v)) |b| putHexByte(b);",
    "        },",
    "        .pointer => |p| {",
    "            if (p.size == .slice and p.child == u8) {",
    '                put("x:");',
    "                for (v) |b| putHexByte(b);",
    "            } else if (p.size == .slice) {",
    '                put("[");',
    "                for (v, 0..) |elem, idx| {",
    '                    if (idx > 0) put(",");',
    "                    putValue(elem);",
    "                }",
    '                put("]");',
    "            } else {",
    '                @compileError("unsupported pointer value in the transcript");',
    "            }",
    "        },",
    '        else => @compileError("unsupported value type in the transcript"),',
    "    }",
    "}",
    "",
    "fn tagged(tag: []const u8, v: anytype) void {",
    "    put(tag);",
    '    put(" ");',
    "    putValue(v);",
    '    put("\\n");',
    "}",
    "",
    "pub fn main(init: std.process.Init) !void {",
    "    gpa = init.arena.allocator();",
  );
  cases.forEach((c, idx) => {
    const id = caseId(idx);
    for (const [ci, call] of (c.calls ?? []).entries()) {
      lines.push(`    tagged("${id}.${ci}", ${id}.${call.fn}(${call.args.map(zigArg).join(", ")}));`);
    }
    if (c.zig) {
      lines.push(`    {`);
      lines.push(`        const m = ${id};`);
      lines.push(`        const Row = struct {`);
      lines.push(`            fn emit(tag: []const u8, v: anytype) void {`);
      lines.push(`                put("${id}.");`);
      lines.push(`                tagged(tag, v);`);
      lines.push(`            }`);
      lines.push(`        };`);
      lines.push(`        const row = Row.emit;`);
      lines.push(c.zig.replace(/^\n+|\n+$/g, "").replace(/^ {4}/gm, "        "));
      lines.push(`    }`);
    }
  });
  lines.push(
    '    try std.Io.Dir.cwd().writeFile(init.io, .{ .sub_path = "zig_transcript.txt", .data = sink.items });',
    "}",
    "",
  );
  return lines.join("\n");
}

// ------------------------------------------------------------------- tests

test("run corpus: every case transpiles clean", () => {
  for (const c of runCorpus) {
    const result = c.files
      ? transpileFiles({ "core.ts": c.src, ...c.files }, c.options ?? {})
      : transpile(c.src, c.options ?? {});
    assert.equal(result.typeErrors.length, 0, `${c.name}: tsc errors\n${result.typeErrors.join("\n")}`);
    const details = result.diagnostics.map((d) => `${d.id} ${d.message}`).join("\n");
    assert.equal(result.ok, true, `${c.name}: transpile failed\n${details}`);
  }
});

test("run corpus: emitted Zig behaves byte-identically to the same source under node", { skip: !hasZig, timeout: 600_000 }, () => {
  const work = fs.mkdtempSync(path.join(os.tmpdir(), "native-core-runfidelity-"));
  try {
    // Native side: emitted modules + rt kernel + generated driver.
    fs.copyFileSync(path.join(pkg, "rt", "rt.zig"), path.join(work, "rt.zig"));
    runCorpus.forEach((c, idx) => {
      const result = c.files
        ? transpileFiles({ "core.ts": c.src, ...c.files }, c.options ?? {})
        : transpile(c.src, c.options ?? {});
      assert.equal(result.ok, true, `${c.name}: transpile failed before the run step`);
      fs.writeFileSync(path.join(work, `${caseId(idx)}.zig`), result.zig!);
    });
    fs.writeFileSync(path.join(work, "driver.zig"), zigDriver(runCorpus));

    // Plain-TS side: the same sources verbatim, with only the SDK import
    // specifier resolved to a file path (a resolution detail, not semantics).
    const sdkCopy = path.join(work, "sdk_core.ts");
    fs.copyFileSync(path.join(pkg, "sdk", "core.ts"), sdkCopy);
    fs.copyFileSync(path.join(pkg, "sdk", "text.ts"), path.join(work, "sdk_text.ts"));
    // The byte-text polyfill and its generated tables — the node half of
    // the text-method surface the zig half gets from rt.zig.
    fs.copyFileSync(path.join(pkg, "src", "text_polyfill.ts"), path.join(work, "text_polyfill.ts"));
    fs.copyFileSync(path.join(pkg, "src", "text_tables.ts"), path.join(work, "text_tables.ts"));
    const resolveSdk = (src: string, prefix: string): string =>
      src
        .replace(/"@native-sdk\/core\/text"/g, `"${prefix}sdk_text.ts"`)
        .replace(/"@native-sdk\/core"/g, `"${prefix}sdk_core.ts"`);
    runCorpus.forEach((c, idx) => {
      if (c.files) {
        // Multi-file case: its own directory, so relative imports between
        // the modules keep their spellings (only SDK specifiers resolve).
        const dir = path.join(work, caseId(idx));
        fs.mkdirSync(dir, { recursive: true });
        for (const [name, source] of Object.entries({ "core.ts": c.src, ...c.files })) {
          fs.mkdirSync(path.dirname(path.join(dir, name)), { recursive: true });
          fs.writeFileSync(path.join(dir, name), resolveSdk(source, "../"));
        }
        return;
      }
      fs.writeFileSync(path.join(work, `${caseId(idx)}.ts`), resolveSdk(c.src, "./"));
    });
    fs.writeFileSync(path.join(work, "driver.ts"), nodeDriver(runCorpus));

    let nodeOut: string;
    try {
      nodeOut = execFileSync(process.execPath, [path.join(work, "driver.ts")], {
        cwd: work,
        encoding: "utf8",
      });
    } catch (e) {
      const err = e as { stderr?: string; stdout?: string };
      assert.fail(`plain-TS driver failed:\n${err.stderr ?? ""}${err.stdout ?? ""}`);
    }

    try {
      execFileSync("zig", ["run", "driver.zig"], { cwd: work, encoding: "utf8", stdio: "pipe" });
    } catch (e) {
      const err = e as { stderr?: string; stdout?: string };
      assert.fail(`native driver failed:\n${err.stderr ?? ""}${err.stdout ?? ""}`);
    }
    const zigOut = fs.readFileSync(path.join(work, "zig_transcript.txt"), "utf8");

    if (nodeOut !== zigOut) {
      const nodeLines = nodeOut.split("\n");
      const zigLines = zigOut.split("\n");
      const diffs: string[] = [];
      const max = Math.max(nodeLines.length, zigLines.length);
      for (let idx = 0; idx < max; idx++) {
        if (nodeLines[idx] !== zigLines[idx]) {
          diffs.push(`  ts:  ${nodeLines[idx] ?? "<missing>"}\n  zig: ${zigLines[idx] ?? "<missing>"}`);
        }
      }
      assert.fail(`run transcripts diverge (${diffs.length} lines):\n${diffs.join("\n")}`);
    }
  } finally {
    fs.rmSync(work, { recursive: true, force: true });
  }
});