@adobe/ecs 0.0.0-stage → 0.2.0

package/dist/implementation/world/wasm.js

@@ -0,0 +1,2460 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { blockShift, chunkShift } from './kernel.js';
+import { withoutIntrinsics } from './intrinsics.js';
+/** The scalar parameter a resource's, the input's or a shared value's leaf is read from. */
+export const scalarOfExpression = (expression) => expression.kind === "args" ? { source: "args", path: expression.path } : { source: expression.kind, index: expression.index, path: expression.path };
+/** The parameters each lookup through an index takes, after the lookup parameters, all as f64. */
+export const indexParameterCount = (lookup) => lookup.kind === "hash" ? 7 + lookup.watched : 11 + lookup.watched;
+/** Math functions with exact native equivalents; the rest are imported from JS so results match bit for bit. */
+const native = new Set(["abs", "sqrt", "floor", "ceil", "trunc", "min", "max", "fround", "imul", "clz32"]);
+/** Imported operations that aren't `Math` functions. */
+const operations = {
+    remainder: (a, b) => a % b,
+    power: (a, b) => a ** b,
+};
+/** No shared values: a call of a kernel reading none, or before its archetype is known. */
+export const noSharedValues = [];
+/**
+ * Reads a scalar parameter's value from the resources and args of a run, and the shared values of the call's
+ * archetype; booleans become 0 or 1.
+ */
+export const scalarValue = (scalar, resources, args, shared = noSharedValues) => {
+    let value = scalar.source === "args" ? args : scalar.source === "shared" ? shared[scalar.index] : resources[scalar.index];
+    for (const key of scalar.path)
+        value = typeof value === "object" && value !== null ? Reflect.get(value, key) : undefined;
+    return Number(value);
+};
+/** Reads each scalar parameter's value from the resources and args of a run, and a call's shared values. */
+export const scalarValues = (scalars, resources, args, shared = noSharedValues) => scalars.map(scalar => scalarValue(scalar, resources, args, shared));
+export const instantiateWasm = async (module, memory, imports) => {
+    const instance = await WebAssembly.instantiate(module, { env: { memory }, math: importsOf(imports) });
+    const run = instance.exports.run;
+    if (typeof run !== "function")
+        throw new Error("A WASM kernel has no run export.");
+    // The generator always exports `run` with this signature.
+    return run;
+};
+/** The JS functions a kernel's imports name. */
+export const importsOf = (names) => {
+    const functions = {};
+    for (const name of names) {
+        const operation = operations[name];
+        const math = Reflect.get(Math, name);
+        if (operation !== undefined)
+            functions[name] = operation;
+        else if (typeof math === "function")
+            functions[name] = (...values) => Number(Reflect.apply(math, Math, values));
+    }
+    return functions;
+};
+// Opcodes.
+const op = {
+    block: 0x02, loop: 0x03, if: 0x04, else: 0x05, end: 0x0b, br: 0x0c, brIf: 0x0d, call: 0x10, drop: 0x1a, select: 0x1b,
+    localGet: 0x20, localSet: 0x21, localTee: 0x22,
+    i32Load: 0x28, f32Load: 0x2a, f64Load: 0x2b, i32Load8u: 0x2d, i32Store: 0x36, f32Store: 0x38, f64Store: 0x39, i32Store8: 0x3a,
+    i32Const: 0x41, f64Const: 0x44, i32ReinterpretF32: 0xbc, i64ReinterpretF64: 0xbd, i32LtU: 0x49, i32GtU: 0x4b, i32LeU: 0x4d, i32GtS: 0x4a, f64Load2: 0x2b,
+    i32Eqz: 0x45, i32GeS: 0x4e,
+    f64Eq: 0x61, f64Ne: 0x62, f64Lt: 0x63, f64Gt: 0x64, f64Le: 0x65, f64Ge: 0x66,
+    i32Eq: 0x46, i32LtS: 0x48, i32LeS: 0x4c, i32Clz: 0x67, i32Ctz: 0x68, i32Popcnt: 0x69, i32Add: 0x6a, i32Sub: 0x6b, i32Mul: 0x6c, i32And: 0x71, i32Or: 0x72, i32Xor: 0x73, i32Shl: 0x74, i32ShrS: 0x75, i32ShrU: 0x76,
+    f64Abs: 0x99, f64Neg: 0x9a, f64Ceil: 0x9b, f64Floor: 0x9c, f64Trunc: 0x9d, f64Sqrt: 0x9f,
+    f64Add: 0xa0, f64Sub: 0xa1, f64Mul: 0xa2, f64Div: 0xa3, f64Min: 0xa4, f64Max: 0xa5,
+    i32WrapI64: 0xa7, i32GeU: 0x4f, i32Ne: 0x47, i64Const: 0x42, i64ShrU: 0x88, i64RemS: 0x81, f64ConvertI64S: 0xb9, f64Copysign: 0xa6, f32DemoteF64: 0xb6, f64ConvertI32S: 0xb7, f64ConvertI32U: 0xb8, f64PromoteF32: 0xbb,
+};
+const f64Type = 0x7c;
+const i32Type = 0x7f;
+/** Saturating truncations, 0xfc-prefixed opcodes. */
+const i64TruncSatF64S = [0xfc, 0x06];
+const truncations = { i32TruncSatF64U: [0xfc, 0x03], i64TruncSatF64U: [0xfc, 0x07] };
+const unsigned = (value) => {
+    const bytes = [];
+    do {
+        let byte = value & 0x7f;
+        value = Math.floor(value / 128);
+        if (value !== 0)
+            byte |= 0x80;
+        bytes.push(byte);
+    } while (value !== 0);
+    return bytes;
+};
+const signed = (value) => {
+    const bytes = [];
+    for (;;) {
+        const byte = value & 0x7f;
+        value >>= 7;
+        if ((value === 0 && (byte & 0x40) === 0) || (value === -1 && (byte & 0x40) !== 0))
+            return [...bytes, byte];
+        bytes.push(byte | 0x80);
+    }
+};
+const float64 = (value) => [...new Uint8Array(new Float64Array([value]).buffer)];
+const name = (text) => {
+    const bytes = [...new TextEncoder().encode(text)];
+    return [...unsigned(bytes.length), ...bytes];
+};
+const vector = (items) => [...unsigned(items.length), ...items.flat()];
+const section = (id, content) => [id, ...unsigned(content.length), ...content];
+/**
+ * Thrown inside generation when a program needs something WASM can't match exactly, saying what; the JS kernel is used
+ * instead. Only failing generation makes one.
+ */
+const reasons = new WeakMap();
+const unsupported = (reason) => {
+    const error = new Error(reason);
+    reasons.set(error, reason);
+    return error;
+};
+/** Thrown when a program can't run four rows at a time; the scalar loop handles every row instead. */
+const notVectorizable = Symbol("notVectorizable");
+const join = (a, b) => a === b ? a : "mixed";
+/** The operators whose folds rotate through lanes: each one's identity, -0 for sums so a sum of -0 stays -0, and its instruction. */
+const rotated = {
+    "+": { value: -0, combine: op.f64Add },
+    "*": { value: 1, combine: op.f64Mul },
+    "min": { value: Infinity, combine: op.f64Min },
+    "max": { value: -Infinity, combine: op.f64Max },
+};
+/**
+ * Generates a WASM module for a kernel program, with JS semantics: every value is an f64, and stores
+ * convert as typed arrays do. Returns `null` when exact equivalence can't be guaranteed.
+ *
+ * The exported `run(start, end, tick, ...columnAddresses, ...scalars)` processes rows `start` to `end`.
+ */
+export const generateWasm = (...parameters) => {
+    const generated = generateWasmOrReason(...parameters);
+    return typeof generated === "string" ? null : generated;
+};
+/** A WAT identifier's characters: a name's others become `_`. */
+const identifierOf = (text) => text.replace(/[^A-Za-z0-9_.]/g, "_");
+/**
+ * As `generateWasm`, or why exact equivalence can't be guaranteed. `named` appends a name section naming the function,
+ * its imports, parameters and locals, for printing it as text; the world never asks for one.
+ */
+export const generateWasmOrReason = (source, columns, scalarTypes, simdEnabled = true, filters = 0, lookups = [], 
+/** For a program reading `up`: the columns of the parent's components it reads. */
+upColumns = [], 
+/** Each accumulator's operator, in `reductions` order. */
+operators = [], 
+/** By lookup, for those through an index, how it reads its index; null for a lookup by entity. */
+indexLookups = [], 
+/** By probe, its lookup: `KernelDescription.probes[k].lookup`. */
+probeLookups = [], 
+/**
+ * Whether SIMD lanes may compute at storage precision, as only an explicit kernel's may: f32 rounds each step.
+ * Without it lanes are f64, two values a vector, promoted from f32 and demoted only on store, as the body computes.
+ */
+storagePrecision = true, named = false) => {
+    const program = withoutIntrinsics(source);
+    const scalars = [];
+    const scalarIndex = new Map();
+    const imports = [];
+    const scalarOf = (scalar) => {
+        const key = JSON.stringify(scalar);
+        let index = scalarIndex.get(key);
+        if (index === undefined) {
+            if (scalarTypes(scalar) === null)
+                throw unsupported("it reads a resource or input value that isn't a number or boolean");
+            index = scalars.length;
+            scalars.push(scalar);
+            scalarIndex.set(key, index);
+        }
+        return index;
+    };
+    const importOf = (functionName) => {
+        let index = imports.indexOf(functionName);
+        if (index < 0) {
+            index = imports.length;
+            imports.push(functionName);
+        }
+        return index;
+    };
+    /** Whether read `read` of lookup `lookup` is its `changed`, after what it reads. */
+    const isChanged = (lookup, read) => (lookups[lookup]?.watched ?? 0) > 0 && read === lookups[lookup]?.reads;
+    /** Whether any lookup watches, which then takes its `lastRun` after the other lookup parameters. */
+    const watching = lookups.some(lookup => (lookup.watched ?? 0) > 0);
+    /** Each handle's lookup, from the `find`s into it; a handle used by two lookups isn't supported. */
+    const lookupOfHandle = new Map();
+    const claim = (handle, lookup) => {
+        const existing = lookupOfHandle.get(handle);
+        if ((existing !== undefined && existing !== lookup) || lookup >= lookups.length)
+            throw unsupported("it reads one lookup's result through another lookup");
+        lookupOfHandle.set(handle, lookup);
+    };
+    /** Each probe's lookup, by the probe's index. */
+    const lookupOfProbe = new Map(probeLookups.map((lookup, probe) => [probe, lookup]));
+    const collectFinds = (statements) => {
+        for (const statement of statements) {
+            if (statement.kind === "find")
+                claim(statement.handle, statement.lookup);
+            else if (statement.kind === "probe") {
+                const lookup = lookupOfProbe.get(statement.probe);
+                if (lookup === undefined || indexLookups[lookup] === null || indexLookups[lookup] === undefined)
+                    throw unsupported("it probes a lookup that isn't through an index");
+                claim(statement.list, lookup);
+                claim(statement.first, lookup);
+            }
+            else if (statement.kind === "listRow") {
+                const lookup = lookupOfHandle.get(statement.list);
+                if (lookup === undefined)
+                    throw unsupported("it reads a row of a list no lookup gave");
+                claim(statement.row, lookup);
+            }
+            else if (statement.kind === "if") {
+                collectFinds(statement.consequent);
+                collectFinds(statement.alternate);
+            }
+            else if (statement.kind === "block" || statement.kind === "loop")
+                collectFinds(statement.body);
+        }
+    };
+    // Local types, to a fixed point over assignments.
+    const localTypes = new Array(program.locals);
+    const typeOf = (expression) => {
+        switch (expression.kind) {
+            case "number": return "number";
+            case "boolean": return "boolean";
+            case "column": return columns[expression.column].boolean ? "boolean" : "number";
+            case "resource":
+            case "args":
+            case "shared": return scalarTypes(scalarOfExpression(expression)) ?? "mixed";
+            case "local": return localTypes[expression.local] ?? "number";
+            case "unary": return expression.operator === "!" ? "boolean" : "number";
+            case "binary": return ["<", ">", "<=", ">=", "==", "!=", "===", "!=="].includes(expression.operator) ? "boolean" : "number";
+            case "logical": return join(typeOf(expression.left), typeOf(expression.right));
+            case "conditional": return join(typeOf(expression.consequent), typeOf(expression.alternate));
+            case "math": return "number";
+            case "found":
+            case "upFound": return "boolean";
+            case "upLeaf": return upColumns[expression.column]?.boolean === true ? "boolean" : "number";
+            case "lookupLeaf": {
+                const lookup = lookupOfHandle.get(expression.handle);
+                if (lookup !== undefined && isChanged(lookup, expression.read))
+                    return "boolean";
+                const leaf = lookup === undefined ? null : lookups[lookup]?.leaf(expression.read, expression.path);
+                return leaf?.boolean === true ? "boolean" : "number";
+            }
+            case "listLength":
+            case "rowEntity": return "number";
+            case "listChanged": return "boolean";
+            case "rowLeaf": {
+                const lookup = lookupOfHandle.get(expression.handle);
+                const leaf = lookup === undefined ? null : indexLookups[lookup]?.rowLeaf(expression.leaf);
+                return leaf?.column.boolean === true ? "boolean" : "number";
+            }
+            // Regions are inlined before generating.
+            case "lane": throw unsupported("it reads a GPU builtin's lane");
+        }
+    };
+    const inferLocals = (statements) => {
+        let changed = false;
+        for (const statement of statements) {
+            if (statement.kind === "set") {
+                const type = typeOf(statement.value);
+                const current = localTypes[statement.local];
+                const next = current === undefined ? type : join(current, type);
+                if (next !== current) {
+                    localTypes[statement.local] = next;
+                    changed = true;
+                }
+            }
+            else if (statement.kind === "if")
+                changed = inferLocals(statement.consequent) || inferLocals(statement.alternate) || changed;
+            else if (statement.kind === "block" || statement.kind === "loop")
+                changed = inferLocals(statement.body) || changed;
+        }
+        return changed;
+    };
+    for (let pass = 0; pass < program.locals + 2 && inferLocals(program.body); pass++)
+        ;
+    /** Whether a value is an integer below 2^32 in magnitude: integer column reads, small integer literals, and locals of only those. */
+    const accumulators = program.reductions ?? [];
+    // Accumulators start at their partials, which needn't be integers.
+    const integralLocals = new Array(program.locals).fill(true).map((integral, index) => integral && !accumulators.includes(index));
+    const integral = (expression) => {
+        switch (expression.kind) {
+            case "column": {
+                const { view, boolean } = columns[expression.column];
+                return !boolean && (view === "i32" || view === "u32" || view === "u8");
+            }
+            case "upLeaf": {
+                const column = upColumns[expression.column];
+                return column !== undefined && !column.boolean && (column.view === "i32" || column.view === "u32" || column.view === "u8");
+            }
+            case "number": return Number.isInteger(expression.value) && Math.abs(expression.value) <= 0x7FFFFFFF;
+            case "local": return integralLocals[expression.local];
+            default: return false;
+        }
+    };
+    const inferIntegral = (statements) => {
+        let changed = false;
+        for (const statement of statements) {
+            if (statement.kind === "set" && integralLocals[statement.local] && !integral(statement.value)) {
+                integralLocals[statement.local] = false;
+                changed = true;
+            }
+            else if (statement.kind === "if")
+                changed = inferIntegral(statement.consequent) || inferIntegral(statement.alternate) || changed;
+            else if (statement.kind === "block" || statement.kind === "loop")
+                changed = inferIntegral(statement.body) || changed;
+        }
+        return changed;
+    };
+    while (inferIntegral(program.body))
+        ;
+    // Parameters: start, end, tick, lastRun, column addresses, filter row, chunk and block tick addresses, scalars, and with reductions the partials address.
+    const columnParameter = (column) => 4 + column;
+    const filterRowParameter = (filter) => 4 + columns.length + filter;
+    const filterChunkParameter = (filter) => 4 + columns.length + filters + filter;
+    const filterBlockParameter = (filter) => 4 + columns.length + 2 * filters + filter;
+    /** Parameters before the lookups': the fixed four, the columns' and the filters'. */
+    const beforeLookups = 4 + columns.length + 3 * filters;
+    /**
+     * With lookups: the entity table (archetype, row and generation addresses, then its length), then each lookup's
+     * directory address and record count, all as f64 so workers pass them like scalars.
+     */
+    const lookupParameters = lookups.length === 0 ? 0 : 4 + 2 * lookups.length + (watching ? 1 : 0);
+    const lookupParameter = (index) => beforeLookups + index;
+    /** For `up`: the rows' and their parents' rows' addresses, whether there's a parent, then each parent column's address. */
+    const upMode = program.up === true;
+    // Its runner passes an `up` kernel only the rows that pass, and the filter loops step the row, not its list slot.
+    if (upMode && filters > 0)
+        throw new Error("A WASM kernel reading `up` takes no change filters: its runner lists only the rows that pass.");
+    const upParameters = upMode ? 3 + upColumns.length : 0;
+    /** Each lookup through an index's parameters, after the lookup parameters: `indexParameterCount` of them, as f64. */
+    const indexOffsets = [];
+    let indexParameters = 0;
+    for (let lookup = 0; lookup < lookups.length; lookup++) {
+        indexOffsets.push(indexParameters);
+        const index = indexLookups[lookup];
+        if (index !== null && index !== undefined)
+            indexParameters += indexParameterCount(index);
+    }
+    const indexParameter = (lookup, index) => beforeLookups + lookupParameters + indexOffsets[lookup] + index;
+    const upParameter = (index) => beforeLookups + lookupParameters + indexParameters + index;
+    const scalarParameter = (index) => beforeLookups + lookupParameters + indexParameters + upParameters + index;
+    const code = [];
+    const extraLocals = [];
+    /**
+     * Values the same for every row that call an import, by the expression: each computed once per call, before the
+     * rows, into the local it maps to. They're pure, so computing one a branch skips changes nothing.
+     */
+    const hoisted = new Map();
+    let localBase = 0;
+    const local = (index) => localBase + index;
+    const scratch = (type) => {
+        extraLocals.push(type);
+        return localBase + program.locals + extraLocals.length - 1;
+    };
+    let rowLocal = 0;
+    /** For `up`: the current row's parent row. */
+    let parentLocal = 0;
+    const address = (column) => {
+        code.push(op.localGet, ...unsigned(columnParameter(column)), op.localGet, ...unsigned(rowLocal), op.i32Const, ...signed(columns[column].stride), op.i32Mul, op.i32Add);
+    };
+    /** Leaves the JS `ToInt32` of the f64 on the stack as an i32: exact for every finite value; NaN and infinities give 0. */
+    const emitToInt32 = () => {
+        const value = scratch(f64Type);
+        code.push(op.localTee, ...unsigned(value));
+        code.push(op.localGet, ...unsigned(value), op.f64Const, ...float64(2 ** -32), op.f64Mul, op.f64Trunc, op.f64Const, ...float64(2 ** 32), op.f64Mul, op.f64Sub);
+        code.push(...i64TruncSatF64S, op.i32WrapI64);
+    };
+    /** Leaves 1 (i32) if the f64 on the stack is truthy: not 0, -0 or NaN. */
+    const emitTruthy = (type) => {
+        if (type === "boolean") {
+            code.push(op.f64Const, ...float64(0), op.f64Ne);
+            return;
+        }
+        const value = scratch(f64Type);
+        code.push(op.localTee, ...unsigned(value), op.f64Const, ...float64(0), op.f64Ne, op.localGet, ...unsigned(value), op.localGet, ...unsigned(value), op.f64Eq, op.i32And);
+    };
+    const emitCall = (functionName) => {
+        code.push(op.call, ...unsigned(importOf(functionName)));
+    };
+    const emit = (expression) => {
+        const hoistedLocal = hoisted.get(expression);
+        if (hoistedLocal !== undefined) {
+            code.push(op.localGet, ...unsigned(hoistedLocal));
+            return;
+        }
+        switch (expression.kind) {
+            case "number":
+                code.push(op.f64Const, ...float64(expression.value));
+                return;
+            case "boolean":
+                code.push(op.f64Const, ...float64(expression.value ? 1 : 0));
+                return;
+            case "local":
+                code.push(op.localGet, ...unsigned(local(expression.local)));
+                return;
+            case "resource":
+            case "args":
+            case "shared": {
+                code.push(op.localGet, ...unsigned(scalarParameter(scalarOf(scalarOfExpression(expression)))));
+                return;
+            }
+            case "upFound":
+                code.push(op.localGet, ...unsigned(upParameter(2)), op.f64ConvertI32U);
+                return;
+            case "upLeaf":
+            case "column": {
+                const { view, offset, boolean } = expression.kind === "upLeaf" ? upColumns[expression.column] : columns[expression.column];
+                if (expression.kind === "upLeaf") {
+                    code.push(op.localGet, ...unsigned(upParameter(3 + expression.column)), op.localGet, ...unsigned(parentLocal), op.i32Const, ...signed(upColumns[expression.column].stride), op.i32Mul, op.i32Add);
+                }
+                else
+                    address(expression.column);
+                const memory = (align) => [align, ...unsigned(offset)];
+                if (boolean) {
+                    code.push(view === "u8" ? op.i32Load8u : op.i32Load, ...memory(view === "u8" ? 0 : 2), op.i32Const, 0, 0x47 /* i32.ne */, op.f64ConvertI32U);
+                    return;
+                }
+                switch (view) {
+                    case "f32":
+                        code.push(op.f32Load, ...memory(2), op.f64PromoteF32);
+                        return;
+                    case "i32":
+                        code.push(op.i32Load, ...memory(2), op.f64ConvertI32S);
+                        return;
+                    case "u32":
+                        code.push(op.i32Load, ...memory(2), op.f64ConvertI32U);
+                        return;
+                    case "u8":
+                        code.push(op.i32Load8u, ...memory(0), op.f64ConvertI32U);
+                        return;
+                    default:
+                        code.push(op.f64Load, ...memory(3));
+                        return;
+                }
+            }
+            case "unary":
+                emit(expression.operand);
+                if (expression.operator === "-")
+                    code.push(op.f64Neg);
+                else if (expression.operator === "!") {
+                    emitTruthy(typeOf(expression.operand));
+                    code.push(op.i32Eqz, op.f64ConvertI32U);
+                }
+                else if (expression.operator === "~") {
+                    emitToInt32();
+                    code.push(op.i32Const, ...signed(-1), op.i32Xor, op.f64ConvertI32S);
+                }
+                return;
+            case "binary": return emitBinary(expression);
+            case "logical": {
+                const type = typeOf(expression.left);
+                const value = scratch(f64Type);
+                emit(expression.left);
+                code.push(op.localTee, ...unsigned(value));
+                emitTruthy(type);
+                code.push(op.if, f64Type);
+                if (expression.operator === "&&")
+                    emit(expression.right);
+                else
+                    code.push(op.localGet, ...unsigned(value));
+                code.push(op.else);
+                if (expression.operator === "&&")
+                    code.push(op.localGet, ...unsigned(value));
+                else
+                    emit(expression.right);
+                code.push(op.end);
+                return;
+            }
+            case "conditional":
+                emit(expression.test);
+                emitTruthy(typeOf(expression.test));
+                code.push(op.if, f64Type);
+                emit(expression.consequent);
+                code.push(op.else);
+                emit(expression.alternate);
+                code.push(op.end);
+                return;
+            case "math": return emitMath(expression.name, expression.arguments);
+            case "found":
+                code.push(op.localGet, ...unsigned(handleLocal(expression.handle, "found")), op.f64ConvertI32U);
+                return;
+            case "lookupLeaf": return emitLookupLeaf(expression.handle, expression.read, expression.path);
+            case "listLength": return emitListLength(expression.handle);
+            case "listChanged": return emitListChanged(expression.handle);
+            case "rowLeaf": return emitRowLeaf(expression.handle, expression.leaf);
+            case "rowEntity": return emitRowEntity(expression.handle);
+        }
+    };
+    const emitMath = (functionName, parameters) => {
+        if (!native.has(functionName)) {
+            // Imported functions take two f64s; unary ones ignore the second.
+            if (parameters.length > 2)
+                throw unsupported(`it calls Math.${functionName} with more than two arguments, and WASM imports it taking two`);
+            for (const parameter of parameters)
+                emit(parameter);
+            for (let i = parameters.length; i < 2; i++)
+                code.push(op.f64Const, ...float64(NaN));
+            emitCall(functionName);
+            return;
+        }
+        switch (functionName) {
+            case "min":
+            case "max": {
+                if (parameters.length === 0) {
+                    code.push(op.f64Const, ...float64(functionName === "min" ? Infinity : -Infinity));
+                    return;
+                }
+                emit(parameters[0]);
+                // JS converts every argument, so `Math.max(x)` is `+x`.
+                for (const parameter of parameters.slice(1)) {
+                    emit(parameter);
+                    code.push(functionName === "min" ? op.f64Min : op.f64Max);
+                }
+                return;
+            }
+            case "imul":
+                emit(parameters[0] ?? { kind: "number", value: 0 });
+                emitToInt32();
+                emit(parameters[1] ?? { kind: "number", value: 0 });
+                emitToInt32();
+                code.push(op.i32Mul, op.f64ConvertI32S);
+                return;
+            case "clz32":
+                emit(parameters[0] ?? { kind: "number", value: 0 });
+                emitToInt32();
+                code.push(op.i32Clz, op.f64ConvertI32U);
+                return;
+            case "fround":
+                emit(parameters[0] ?? { kind: "number", value: NaN });
+                code.push(op.f32DemoteF64, op.f64PromoteF32);
+                return;
+            default: {
+                emit(parameters[0] ?? { kind: "number", value: NaN });
+                const unary = { abs: op.f64Abs, sqrt: op.f64Sqrt, floor: op.f64Floor, ceil: op.f64Ceil, trunc: op.f64Trunc }[functionName];
+                if (unary === undefined)
+                    throw unsupported(`it calls Math.${functionName}, which WASM has no instruction for`);
+                code.push(unary);
+            }
+        }
+    };
+    const comparisons = { "<": op.f64Lt, ">": op.f64Gt, "<=": op.f64Le, ">=": op.f64Ge, "==": op.f64Eq, "!=": op.f64Ne, "===": op.f64Eq, "!==": op.f64Ne };
+    const arithmetic = { "+": op.f64Add, "-": op.f64Sub, "*": op.f64Mul, "/": op.f64Div };
+    const bitwise = { "&": op.i32And, "|": op.i32Or, "^": op.i32Xor, "<<": op.i32Shl, ">>": op.i32ShrS, ">>>": op.i32ShrU };
+    const emitBinary = (expression) => {
+        const { operator, left, right } = expression;
+        if (operator === "===" || operator === "!==") {
+            const leftType = typeOf(left);
+            const rightType = typeOf(right);
+            if (leftType === "mixed" || rightType === "mixed")
+                throw unsupported("it compares with === or !== a value that may be a boolean or a number");
+            // A boolean never strictly equals a number. Operands are pure, so they needn't be evaluated.
+            if (leftType !== rightType) {
+                code.push(op.f64Const, ...float64(operator === "===" ? 0 : 1));
+                return;
+            }
+        }
+        // Integers by a nonzero literal: i64 remainder is exact, and copysign gives JS's -0 for a negative dividend.
+        if (operator === "%" && integral(left) && right.kind === "number" && right.value !== 0 && integral(right)) {
+            const dividend = scratch(f64Type);
+            emit(left);
+            code.push(op.localTee, ...unsigned(dividend), ...i64TruncSatF64S, op.i64Const, ...signed(right.value), op.i64RemS, op.f64ConvertI64S, op.localGet, ...unsigned(dividend), op.f64Copysign);
+            return;
+        }
+        // Any dividend by a nonzero integer literal: exactly as above while the dividend is an integer below 2^53 in
+        // magnitude, which the row checks, and through the import otherwise.
+        if (operator === "%" && right.kind === "number" && right.value !== 0 && integral(right)) {
+            const dividend = scratch(f64Type);
+            emit(left);
+            code.push(op.localTee, ...unsigned(dividend), op.f64Trunc, op.localGet, ...unsigned(dividend), op.f64Eq);
+            code.push(op.localGet, ...unsigned(dividend), op.f64Abs, op.f64Const, ...float64(2 ** 53), op.f64Lt, op.i32And);
+            code.push(op.if, f64Type, op.localGet, ...unsigned(dividend), ...i64TruncSatF64S, op.i64Const, ...signed(right.value), op.i64RemS, op.f64ConvertI64S, op.localGet, ...unsigned(dividend), op.f64Copysign);
+            code.push(op.else, op.localGet, ...unsigned(dividend), op.f64Const, ...float64(right.value));
+            emitCall("remainder");
+            code.push(op.end);
+            return;
+        }
+        if (operator === "%" || operator === "**") {
+            emit(left);
+            emit(right);
+            emitCall(operator === "%" ? "remainder" : "power");
+            return;
+        }
+        emit(left);
+        if (operator in bitwise) {
+            emitToInt32();
+            emit(right);
+            emitToInt32();
+            code.push(bitwise[operator]);
+            code.push(operator === ">>>" ? op.f64ConvertI32U : op.f64ConvertI32S);
+            return;
+        }
+        emit(right);
+        if (operator in arithmetic) {
+            code.push(arithmetic[operator]);
+            return;
+        }
+        code.push(comparisons[operator], op.f64ConvertI32U);
+    };
+    /** Labels from innermost: program blocks and loops count toward IR depths; `if`s and the row block don't. */
+    const labels = [];
+    const wasmDepth = (depth) => {
+        let seen = -1;
+        for (let i = labels.length - 1; i >= 0; i--) {
+            if (labels[i] === "program" && ++seen === depth)
+                return labels.length - 1 - i;
+        }
+        throw unsupported("it branches to a block that isn't there");
+    };
+    const store = (column, value) => {
+        const { view, offset } = columns[column];
+        address(column);
+        if (value === "tick")
+            code.push(op.localGet, 2);
+        else
+            emit(value);
+        const memory = (align) => [align, ...unsigned(offset)];
+        switch (view) {
+            case "f32":
+                code.push(op.f32DemoteF64, op.f32Store, ...memory(2));
+                return;
+            case "i32":
+            case "u32":
+                emitToInt32();
+                code.push(op.i32Store, ...memory(2));
+                return;
+            case "u8":
+                emitToInt32();
+                code.push(op.i32Store8, ...memory(0));
+                return;
+            default:
+                code.push(op.f64Store, ...memory(3));
+                return;
+        }
+    };
+    /**
+     * Chunk and block columns stamped by every row, by the shift from a row to its element: top-level stamps with no
+     * `next` before them, in an unfiltered kernel. Their chunks and blocks are stamped once per call, for the whole
+     * range, instead of on each row.
+     */
+    const everyRow = new Map();
+    // Listed rows needn't be consecutive, so each stamps its own chunk and block.
+    if (filters === 0 && !upMode) {
+        const ends = (statement) => statement.kind === "next" || (statement.kind === "if" && (statement.consequent.some(ends) || statement.alternate.some(ends)))
+            || ((statement.kind === "block" || statement.kind === "loop") && statement.body.some(ends));
+        for (const statement of program.body) {
+            if (ends(statement))
+                break;
+            if (statement.kind !== "stamp")
+                continue;
+            if (columns[statement.blocks].muted !== true)
+                everyRow.set(statement.blocks, blockShift);
+            if (columns[statement.chunks].muted !== true)
+                everyRow.set(statement.chunks, chunkShift);
+        }
+    }
+    /** Stamps every chunk or block from `start`'s to `end - 1`'s, for the chunk and block columns every row stamps. */
+    const stampRangeChunks = () => {
+        for (const [dense, shift] of everyRow) {
+            const chunk = scratch(i32Type);
+            const last = scratch(i32Type);
+            // if (start < end) for (chunk = start >> shift; chunk <= (end - 1) >> shift; chunk++) dense[chunk] = tick
+            code.push(op.localGet, 0, op.localGet, 1, op.i32LtS, op.if, 0x40);
+            code.push(op.localGet, 0, op.i32Const, ...signed(shift), op.i32ShrU, op.localSet, ...unsigned(chunk));
+            code.push(op.localGet, 1, op.i32Const, 1, op.i32Sub, op.i32Const, ...signed(shift), op.i32ShrU, op.localSet, ...unsigned(last));
+            code.push(op.loop, 0x40);
+            code.push(op.localGet, ...unsigned(columnParameter(dense)), op.localGet, ...unsigned(chunk), op.i32Const, 3, op.i32Shl, op.i32Add, op.localGet, 2, op.f64Store, 3, 0);
+            code.push(op.localGet, ...unsigned(chunk), op.i32Const, 1, op.i32Add, op.localTee, ...unsigned(chunk), op.localGet, ...unsigned(last), op.i32LeS, op.brIf, 0);
+            code.push(op.end, op.end);
+        }
+    };
+    // ---- Lookups: a find checks the entity table and the lookup's directory record; leaves read through the record. ----
+    /** i32 locals holding the lookup parameters, converted once per call. */
+    let lookupLocals = [];
+    const convertLookupParameters = () => {
+        lookupLocals = [];
+        // The `lastRun` lookups watching compare with stays an f64 parameter.
+        for (let index = 0; index < lookupParameters - (watching ? 1 : 0); index++) {
+            const target = scratch(i32Type);
+            code.push(op.localGet, ...unsigned(lookupParameter(index)), ...truncations.i32TruncSatF64U, op.localSet, ...unsigned(target));
+            lookupLocals.push(target);
+        }
+    };
+    const entityArchetypes = () => lookupLocals[0];
+    const entityRows = () => lookupLocals[1];
+    const entityGenerations = () => lookupLocals[2];
+    const entityCount = () => lookupLocals[3];
+    const directory = (lookup) => lookupLocals[4 + 2 * lookup];
+    const directoryCount = (lookup) => lookupLocals[5 + 2 * lookup];
+    /** Per handle: whether found, the row, and the address of its directory record. */
+    const handleLocals = new Map();
+    const handleLocal = (handle, part) => {
+        const key = `${handle}:${part}`;
+        let index = handleLocals.get(key);
+        if (index === undefined)
+            handleLocals.set(key, index = scratch(i32Type));
+        return index;
+    };
+    const emitFind = (handle, lookup, entity) => {
+        const found = handleLocal(handle, "found");
+        const row = handleLocal(handle, "row");
+        const record = handleLocal(handle, "record");
+        const value = scratch(f64Type);
+        const wide = scratch(0x7e);
+        const generation = scratch(f64Type);
+        const index = scratch(i32Type);
+        const archetype = scratch(i32Type);
+        const words = 1 + lookups[lookup].reads + (lookups[lookup].watched ?? 0);
+        code.push(op.i32Const, 0, op.localSet, ...unsigned(found));
+        // As JS `locate`: the index is ToUint32 of the entity and the generation is floor(entity / 2^32), compared as
+        // numbers, so negative, fractional and NaN entities behave exactly as they do there.
+        emit(entity);
+        code.push(op.localTee, ...unsigned(value));
+        // Real entities are non-negative integers: one i64 gives both parts. Anything else takes the general path.
+        code.push(...i64TruncSatF64S, op.localTee, ...unsigned(wide), op.f64ConvertI64S, op.localGet, ...unsigned(value), op.f64Eq);
+        code.push(op.localGet, ...unsigned(value), op.f64Const, ...float64(0), op.f64Ge, op.i32And);
+        code.push(op.if, 0x40);
+        code.push(op.localGet, ...unsigned(wide), op.i32WrapI64, op.localSet, ...unsigned(index));
+        code.push(op.localGet, ...unsigned(wide), op.i64Const, 32, op.i64ShrU, op.f64ConvertI64S, op.localSet, ...unsigned(generation));
+        code.push(op.else);
+        code.push(op.localGet, ...unsigned(value));
+        emitToInt32();
+        code.push(op.localSet, ...unsigned(index));
+        code.push(op.localGet, ...unsigned(value), op.f64Const, ...float64(2 ** -32), op.f64Mul, op.f64Floor, op.localSet, ...unsigned(generation));
+        code.push(op.end);
+        code.push(op.block, 0x40);
+        labels.push("if");
+        code.push(op.localGet, ...unsigned(index), op.localGet, ...unsigned(entityCount()), op.i32GeU, op.brIf, 0);
+        code.push(op.localGet, ...unsigned(entityGenerations()), op.localGet, ...unsigned(index), op.i32Const, 2, op.i32Shl, op.i32Add, op.i32Load, 2, 0, op.f64ConvertI32U);
+        code.push(op.localGet, ...unsigned(generation), op.f64Ne, op.brIf, 0);
+        code.push(op.localGet, ...unsigned(entityArchetypes()), op.localGet, ...unsigned(index), op.i32Const, 2, op.i32Shl, op.i32Add, op.i32Load, 2, 0, op.localTee, ...unsigned(archetype));
+        code.push(op.i32Const, 0, op.i32LtS, op.brIf, 0);
+        code.push(op.localGet, ...unsigned(archetype), op.localGet, ...unsigned(directoryCount(lookup)), op.i32GeS, op.brIf, 0);
+        code.push(op.localGet, ...unsigned(directory(lookup)), op.localGet, ...unsigned(archetype), op.i32Const, ...signed(4 * words), op.i32Mul, op.i32Add, op.localTee, ...unsigned(record));
+        code.push(op.i32Load, 2, 0, op.i32Eqz, op.brIf, 0);
+        code.push(op.localGet, ...unsigned(entityRows()), op.localGet, ...unsigned(index), op.i32Const, 2, op.i32Shl, op.i32Add, op.i32Load, 2, 0, op.localSet, ...unsigned(row));
+        code.push(op.i32Const, 1, op.localSet, ...unsigned(found));
+        labels.pop();
+        code.push(op.end);
+    };
+    /**
+     * A found entity's `changed`: whether a watched component's tick at its row is newer than the lookups' `lastRun`,
+     * or one keeps no ticks, as 0 or 1; NaN if nothing was found.
+     */
+    const emitChanged = (handle, lookup) => {
+        const { reads, watched = 0 } = lookups[lookup];
+        const since = lookupParameter(lookupParameters - 1);
+        const changed = scratch(i32Type);
+        const address = scratch(i32Type);
+        code.push(op.localGet, ...unsigned(handleLocal(handle, "found")), op.if, f64Type);
+        labels.push("if");
+        code.push(op.i32Const, 0, op.localSet, ...unsigned(changed));
+        for (let w = 0; w < watched; w++) {
+            code.push(op.localGet, ...unsigned(handleLocal(handle, "record")), op.i32Load, 2, ...unsigned(4 * (1 + reads + w)), op.localTee, ...unsigned(address));
+            code.push(op.i32Eqz, op.if, i32Type);
+            labels.push("if");
+            code.push(op.i32Const, 1);
+            code.push(op.else);
+            code.push(op.localGet, ...unsigned(address), op.localGet, ...unsigned(handleLocal(handle, "row")), op.i32Const, 3, op.i32Shl, op.i32Add, op.f64Load, 3, 0);
+            code.push(op.localGet, ...unsigned(since), op.f64Gt);
+            code.push(op.end);
+            labels.pop();
+            code.push(op.localGet, ...unsigned(changed), op.i32Or, op.localSet, ...unsigned(changed));
+        }
+        code.push(op.localGet, ...unsigned(changed), op.f64ConvertI32U);
+        code.push(op.else, op.f64Const, ...float64(NaN), op.end);
+        labels.pop();
+    };
+    const emitLookupLeaf = (handle, read, path) => {
+        const lookup = lookupOfHandle.get(handle);
+        if (lookup !== undefined && isChanged(lookup, read)) {
+            if (path.length > 0)
+                throw unsupported("it reads a field of a lookup's changed flag");
+            emitChanged(handle, lookup);
+            return;
+        }
+        const leaf = lookup === undefined ? null : lookups[lookup].leaf(read, path);
+        if (leaf === null)
+            throw unsupported("it reads a value of a lookup that isn't a number or boolean in linear memory");
+        const { view, stride, offset, boolean } = leaf;
+        code.push(op.localGet, ...unsigned(handleLocal(handle, "found")), op.if, f64Type);
+        labels.push("if");
+        // The column's address from the record, then the row's element.
+        code.push(op.localGet, ...unsigned(handleLocal(handle, "record")), op.i32Load, 2, ...unsigned(4 * (1 + read)));
+        code.push(op.localGet, ...unsigned(handleLocal(handle, "row")), op.i32Const, ...signed(stride), op.i32Mul, op.i32Add);
+        const memory = (align) => [align, ...unsigned(offset)];
+        if (boolean)
+            code.push(view === "u8" ? op.i32Load8u : op.i32Load, ...memory(view === "u8" ? 0 : 2), op.i32Const, 0, op.i32Ne, op.f64ConvertI32U);
+        else if (view === "f32")
+            code.push(op.f32Load, ...memory(2), op.f64PromoteF32);
+        else if (view === "i32")
+            code.push(op.i32Load, ...memory(2), op.f64ConvertI32S);
+        else if (view === "u32")
+            code.push(op.i32Load, ...memory(2), op.f64ConvertI32U);
+        else if (view === "u8")
+            code.push(op.i32Load8u, ...memory(0), op.f64ConvertI32U);
+        else
+            code.push(op.f64Load, ...memory(3));
+        code.push(op.else, op.f64Const, ...float64(NaN), op.end);
+        labels.pop();
+    };
+    // ---- Lookups through indexes: probes of a hash table or searches of a sorted index's blocks, and their lists' rows. ----
+    const get = (index) => [op.localGet, ...unsigned(index)];
+    const put = (index) => [op.localSet, ...unsigned(index)];
+    const tee = (index) => [op.localTee, ...unsigned(index)];
+    const constant = (value) => [op.i32Const, ...signed(value | 0)];
+    const load = (offset) => [op.i32Load, 2, ...unsigned(offset)];
+    /** By lookup through an index, its parameters as locals: addresses and counts as i32, ticks as f64. */
+    let indexLocals = [];
+    /** Which of a hash index's and a sorted index's parameters are f64. */
+    const hashTicks = new Set([5, 6]);
+    const sortedTicks = new Set([9, 10]);
+    const convertIndexParameters = () => {
+        indexLocals = [];
+        for (let lookup = 0; lookup < lookups.length; lookup++) {
+            const index = indexLookups[lookup];
+            const locals = [];
+            indexLocals.push(locals);
+            if (index === null || index === undefined)
+                continue;
+            const ticks = index.kind === "hash" ? hashTicks : sortedTicks;
+            for (let k = 0; k < indexParameterCount(index); k++) {
+                const f64 = ticks.has(k);
+                const target = scratch(f64 ? f64Type : i32Type);
+                code.push(...get(indexParameter(lookup, k)));
+                if (!f64)
+                    code.push(...truncations.i32TruncSatF64U);
+                code.push(...put(target));
+                locals.push(target);
+            }
+        }
+    };
+    const indexLocal = (lookup, k) => indexLocals[lookup][k];
+    /** The lookup a handle is of, and its index's description. */
+    const indexOf = (handle) => {
+        const lookup = lookupOfHandle.get(handle);
+        const index = lookup === undefined ? undefined : indexLookups[lookup];
+        if (lookup === undefined || index === null || index === undefined)
+            throw unsupported("it reads a list of a lookup that isn't through an index");
+        return { lookup, index };
+    };
+    /** A list handle's i32 locals: a hash list's start, length and bucket; a sorted list's runs and cursor. */
+    const listLocal = (handle, part) => {
+        const key = `${handle}:list:${part}`;
+        let index = handleLocals.get(key);
+        if (index === undefined)
+            handleLocals.set(key, index = scratch(i32Type));
+        return index;
+    };
+    /** The key's words of a lookup's probes, as i32 locals. */
+    const keyLocals = new Map();
+    const keyLocal = (lookup, word) => {
+        const key = `${lookup}:${word}`;
+        let index = keyLocals.get(key);
+        if (index === undefined)
+            keyLocals.set(key, index = scratch(i32Type));
+        return index;
+    };
+    /** Encodes the f64 on the stack, converted to `value`'s stored type as a store converts it, into the key's words where it goes. */
+    const encodeKey = (lookup, value) => {
+        const word = keyLocal(lookup, value.word);
+        switch (value.scalar) {
+            case "i32":
+                emitToInt32();
+                code.push(...constant(0x80000000), op.i32Xor, ...put(word));
+                return;
+            case "u32":
+                emitToInt32();
+                code.push(...put(word));
+                return;
+            case "boolean":
+                emitToInt32();
+                code.push(...constant(0xFF), op.i32And, ...constant(0), op.i32Ne, ...put(word));
+                return;
+            case "f32": {
+                const bits = scratch(i32Type);
+                code.push(op.f32DemoteF64, op.i32ReinterpretF32, ...tee(bits));
+                // NaN last, -0 as +0, a negative's bits flipped, a positive's sign set.
+                code.push(...constant(0x7F800000), op.i32And, ...constant(0x7F800000), op.i32Eq);
+                code.push(...get(bits), ...constant(0x7FFFFF), op.i32And, ...constant(0), op.i32Ne, op.i32And);
+                code.push(op.if, i32Type, ...constant(-1), op.else);
+                code.push(...get(bits), ...constant(0x80000000), op.i32Eq, op.if, i32Type, ...constant(0x80000000), op.else);
+                code.push(...get(bits), ...constant(31), op.i32ShrU, op.if, i32Type, ...get(bits), ...constant(-1), op.i32Xor, op.else, ...get(bits), ...constant(0x80000000), op.i32Or, op.end);
+                code.push(op.end, op.end, ...put(word));
+                return;
+            }
+            default: {
+                const wide = scratch(0x7e);
+                const high = scratch(i32Type);
+                const low = scratch(i32Type);
+                const next = keyLocal(lookup, value.word + 1);
+                code.push(op.i64ReinterpretF64, ...tee(wide), op.i64Const, 32, op.i64ShrU, op.i32WrapI64, ...put(high));
+                code.push(...get(wide), op.i32WrapI64, ...put(low));
+                code.push(...get(high), ...constant(0x7FF00000), op.i32And, ...constant(0x7FF00000), op.i32Eq);
+                code.push(...get(high), ...constant(0xFFFFF), op.i32And, ...get(low), op.i32Or, ...constant(0), op.i32Ne, op.i32And);
+                code.push(op.if, 0x40, ...constant(-1), ...put(word), ...constant(-1), ...put(next), op.else);
+                code.push(...get(high), ...constant(0x80000000), op.i32Eq, ...get(low), op.i32Eqz, op.i32And);
+                code.push(op.if, 0x40, ...constant(0x80000000), ...put(word), ...constant(0), ...put(next), op.else);
+                code.push(...get(high), ...constant(31), op.i32ShrU);
+                code.push(op.if, 0x40, ...get(high), ...constant(-1), op.i32Xor, ...put(word), ...get(low), ...constant(-1), op.i32Xor, ...put(next));
+                code.push(op.else, ...get(high), ...constant(0x80000000), op.i32Or, ...put(word), ...get(low), ...put(next), op.end);
+                code.push(op.end, op.end);
+                return;
+            }
+        }
+    };
+    /** Points row handle `row` at an entry's archetype and row, found when its archetype holds what the lookup reads. */
+    const bindRow = (row, lookup, archetype, entryRow) => {
+        const found = handleLocal(row, "found");
+        const record = handleLocal(row, "record");
+        const words = 1 + lookups[lookup].reads;
+        code.push(...constant(0), ...put(found));
+        code.push(op.block, 0x40);
+        code.push(...get(archetype), ...get(directoryCount(lookup)), op.i32GeU, op.brIf, 0);
+        code.push(...get(directory(lookup)), ...get(archetype), ...constant(4 * words), op.i32Mul, op.i32Add, ...tee(record));
+        code.push(...load(0), op.i32Eqz, op.brIf, 0);
+        code.push(...get(entryRow), ...put(handleLocal(row, "row")), ...constant(1), ...put(found));
+        code.push(op.end);
+    };
+    /** Fenwick tree sum of the lengths of the blocks before position `k` (an i32 local), left on the stack. */
+    const emitPrefix = (lookup, k) => {
+        const node = scratch(i32Type);
+        const sum = scratch(i32Type);
+        const counts = indexLocal(lookup, 5);
+        code.push(...constant(0), ...put(sum), ...get(k), ...put(node));
+        code.push(op.block, 0x40, op.loop, 0x40);
+        code.push(...get(node), op.i32Eqz, op.brIf, 1);
+        code.push(...get(sum), ...get(counts), ...get(node), ...constant(2), op.i32Shl, op.i32Add, ...load(0), op.i32Add, ...put(sum));
+        code.push(...get(node), ...get(node), ...constant(0), ...get(node), op.i32Sub, op.i32And, op.i32Sub, ...put(node), op.br, 0);
+        code.push(op.end, op.end, ...get(sum));
+    };
+    /** The position in `order` of the block holding entry position `position` (an i32 local), into `k`. */
+    const emitBlockAt = (lookup, position, k) => {
+        const remaining = scratch(i32Type);
+        const step = scratch(i32Type);
+        const next = scratch(i32Type);
+        const blocks = indexLocal(lookup, 1);
+        const counts = indexLocal(lookup, 5);
+        code.push(...constant(0), ...put(k), ...get(position), ...put(remaining));
+        // The largest power of two at most `blocks`, or 0 without blocks.
+        code.push(...get(blocks), op.i32Eqz, op.if, i32Type, ...constant(0), op.else, ...constant(1), ...constant(31), ...get(blocks), op.i32Clz, op.i32Sub, op.i32Shl, op.end, ...put(step));
+        code.push(op.block, 0x40, op.loop, 0x40);
+        code.push(...get(step), op.i32Eqz, op.brIf, 1);
+        code.push(...get(k), ...get(step), op.i32Add, ...tee(next), ...get(blocks), op.i32LeU);
+        code.push(op.if, 0x40);
+        code.push(...get(counts), ...get(next), ...constant(2), op.i32Shl, op.i32Add, ...load(0), ...get(remaining), op.i32LeU);
+        code.push(op.if, 0x40, ...get(next), ...put(k), ...get(remaining), ...get(counts), ...get(next), ...constant(2), op.i32Shl, op.i32Add, ...load(0), op.i32Sub, ...put(remaining), op.end);
+        code.push(op.end);
+        code.push(...get(step), ...constant(1), op.i32ShrU, ...put(step), op.br, 0);
+        code.push(op.end, op.end);
+    };
+    /**
+     * Leaves 1 when the key at `address` (an i32 local) passes against the key's first `count` words: after them, or
+     * with `after` false, not before them, comparing unsigned words in order.
+     */
+    const emitPasses = (lookup, address, count, after) => {
+        const passes = scratch(i32Type);
+        const word = scratch(i32Type);
+        code.push(...constant(after ? 0 : 1), ...put(passes));
+        code.push(op.block, 0x40);
+        for (let w = 0; w < count; w++) {
+            code.push(...get(address), ...load(4 * w), ...tee(word), ...get(keyLocal(lookup, w)), op.i32Ne);
+            code.push(op.if, 0x40, ...get(word), ...get(keyLocal(lookup, w)), op.i32GtU, ...put(passes), op.br, 1, op.end);
+        }
+        code.push(op.end, ...get(passes));
+    };
+    /**
+     * The first entry position whose key's first `count` words pass, into `result`: a search over the blocks' fences,
+     * then within a block. A lower bound leaves the list's cursor at its block.
+     */
+    const emitBound = (lookup, index, count, after, result, list) => {
+        if (count === 0) {
+            code.push(...(after ? get(indexLocal(lookup, 6)) : constant(0)), ...put(result));
+            return;
+        }
+        const low = scratch(i32Type);
+        const high = scratch(i32Type);
+        const middle = scratch(i32Type);
+        const address = scratch(i32Type);
+        const block = scratch(i32Type);
+        const base = scratch(i32Type);
+        const fences = indexLocal(lookup, 0);
+        const blocks = indexLocal(lookup, 1);
+        const fenceBytes = 4 * (index.words + 1);
+        const entryBytes = 4 * index.stride;
+        const search = (from, length, at) => {
+            code.push(...constant(0), ...put(low));
+            length();
+            code.push(...put(high));
+            code.push(op.block, 0x40, op.loop, 0x40);
+            code.push(...get(low), ...get(high), op.i32GeU, op.brIf, 1);
+            code.push(...get(low), ...get(high), op.i32Add, ...constant(1), op.i32ShrU, ...put(middle));
+            at();
+            code.push(...put(address));
+            emitPasses(lookup, address, count, after);
+            code.push(op.if, 0x40, ...get(middle), ...put(high), op.else, ...get(middle), ...constant(1), op.i32Add, ...put(low), op.end);
+            code.push(op.br, 0, op.end, op.end);
+            void from;
+        };
+        search(() => { }, () => code.push(...get(blocks)), () => code.push(...get(fences), ...get(middle), ...constant(fenceBytes), op.i32Mul, op.i32Add));
+        // Past the last block: the size.
+        code.push(...get(low), ...get(blocks), op.i32GeU, op.if, 0x40, ...get(indexLocal(lookup, 6)), ...put(result), op.else);
+        const k = scratch(i32Type);
+        code.push(...get(low), ...put(k));
+        code.push(...get(indexLocal(lookup, 2)), ...get(k), ...constant(2), op.i32Shl, op.i32Add, ...load(0), ...put(block));
+        code.push(...get(indexLocal(lookup, 4)), ...get(block), ...constant(entryBytes * 128), op.i32Mul, op.i32Add, ...put(base));
+        search(() => { }, () => code.push(...get(indexLocal(lookup, 3)), ...get(block), ...constant(2), op.i32Shl, op.i32Add, ...load(0)), () => code.push(...get(base), ...get(middle), ...constant(entryBytes), op.i32Mul, op.i32Add));
+        emitPrefix(lookup, k);
+        if (!after) {
+            const first = scratch(i32Type);
+            code.push(...tee(first), ...get(low), op.i32Add, ...put(result));
+            code.push(...get(k), ...put(listLocal(list, "k")), ...get(first), ...put(listLocal(list, "first")));
+            code.push(...get(indexLocal(lookup, 3)), ...get(block), ...constant(2), op.i32Shl, op.i32Add, ...load(0), ...put(listLocal(list, "count")));
+        }
+        else
+            code.push(...get(low), op.i32Add, ...put(result));
+        code.push(op.end);
+    };
+    /** Looks a key up, into list handle `list`, and its first row into `first`. */
+    const emitProbe = (list, first, probe, values) => {
+        const { lookup, index } = indexOf(list);
+        const plan = index.probe(probe);
+        if (plan === null)
+            throw unsupported("it looks up an index by a key WASM can't encode");
+        let next = 0;
+        const encode = (targets) => {
+            for (const target of targets) {
+                const value = values[next++];
+                if (value === undefined)
+                    throw unsupported("it looks up an index with fewer values than its key has");
+                emit(value);
+                encodeKey(lookup, target);
+            }
+        };
+        encode(plan.values);
+        if (index.kind === "hash") {
+            const hash = scratch(i32Type);
+            const slot = scratch(i32Type);
+            const address = scratch(i32Type);
+            const filled = scratch(i32Type);
+            const base = scratch(i32Type);
+            const bucket = listLocal(list, "bucket");
+            const slots = indexLocal(lookup, 0);
+            const mask = indexLocal(lookup, 1);
+            const records = indexLocal(lookup, 2);
+            const recordBytes = 4 * index.stride;
+            code.push(...constant(0x811C9DC5), ...put(hash));
+            for (let w = 0; w < index.words; w++) {
+                code.push(...get(hash), ...get(keyLocal(lookup, w)), op.i32Xor, ...constant(0x9E3779B1), op.i32Mul, ...tee(hash), ...get(hash), ...constant(15), op.i32ShrU, op.i32Xor, ...put(hash));
+            }
+            code.push(...get(hash), ...get(hash), ...constant(16), op.i32ShrU, op.i32Xor, ...constant(0x85EBCA6B), op.i32Mul, ...put(hash));
+            code.push(...get(hash), ...get(hash), ...constant(13), op.i32ShrU, op.i32Xor, ...constant(0xC2B2AE35), op.i32Mul, ...put(hash));
+            code.push(...get(hash), ...get(hash), ...constant(16), op.i32ShrU, op.i32Xor, ...put(hash));
+            code.push(...get(hash), ...get(mask), op.i32And, ...put(slot), ...constant(-1), ...put(bucket));
+            code.push(op.block, 0x40, op.loop, 0x40);
+            code.push(...get(slots), ...get(slot), ...constant(8), op.i32Mul, op.i32Add, ...tee(address), ...load(4), ...tee(filled), op.i32Eqz, op.brIf, 1);
+            code.push(...get(address), ...load(0), ...get(hash), op.i32Eq, op.if, 0x40);
+            code.push(...get(records), ...get(filled), ...constant(1), op.i32Sub, ...constant(recordBytes), op.i32Mul, op.i32Add, ...put(base));
+            code.push(...constant(1));
+            for (let w = 0; w < index.words; w++)
+                code.push(...get(base), ...load(16 + 4 * w), ...get(keyLocal(lookup, w)), op.i32Eq, op.i32And);
+            code.push(op.if, 0x40, ...get(filled), ...constant(1), op.i32Sub, ...put(bucket), op.br, 3, op.end);
+            code.push(op.end);
+            code.push(...get(slot), ...constant(1), op.i32Add, ...get(mask), op.i32And, ...put(slot), op.br, 0);
+            code.push(op.end, op.end);
+            code.push(...get(bucket), ...constant(0), op.i32LtS, op.if, 0x40, ...constant(0), ...put(listLocal(list, "start")), ...constant(0), ...put(listLocal(list, "length")));
+            code.push(op.else);
+            code.push(...get(records), ...get(bucket), ...constant(recordBytes), op.i32Mul, op.i32Add, ...tee(base), ...load(4), ...put(listLocal(list, "start")));
+            code.push(...get(base), ...load(8), ...put(listLocal(list, "length")));
+            code.push(op.end);
+        }
+        else {
+            const low = listLocal(list, "low");
+            const high = listLocal(list, "high");
+            const second = listLocal(list, "second");
+            const end = listLocal(list, "end");
+            code.push(...constant(0), ...put(second), ...constant(0), ...put(end), ...constant(0), ...put(listLocal(list, "count")));
+            if (plan.comparisons === null) {
+                emitBound(lookup, index, plan.prefixWords, false, low, list);
+                emitBound(lookup, index, plan.prefixWords, true, high, list);
+            }
+            else {
+                emitBound(lookup, index, plan.prefixWords, false, low, list);
+                emitBound(lookup, index, plan.prefixWords, true, high, list);
+                const bound = scratch(i32Type);
+                const unequalLow = scratch(i32Type);
+                const unequalHigh = scratch(i32Type);
+                code.push(...constant(-1), ...put(unequalLow));
+                const raise = () => { code.push(...get(bound), ...get(low), ...get(bound), ...get(low), op.i32GtS, op.select, ...put(low)); };
+                const lower = () => { code.push(...get(bound), ...get(high), ...get(bound), ...get(high), op.i32LtS, op.select, ...put(high)); };
+                for (const comparison of plan.comparisons) {
+                    encode(comparison.values);
+                    switch (comparison.operator) {
+                        case ">=":
+                            emitBound(lookup, index, comparison.words, false, bound, list);
+                            raise();
+                            break;
+                        case ">":
+                            emitBound(lookup, index, comparison.words, true, bound, list);
+                            raise();
+                            break;
+                        case "<":
+                            emitBound(lookup, index, comparison.words, false, bound, list);
+                            lower();
+                            break;
+                        case "<=":
+                            emitBound(lookup, index, comparison.words, true, bound, list);
+                            lower();
+                            break;
+                        case "==":
+                            emitBound(lookup, index, comparison.words, false, bound, list);
+                            raise();
+                            emitBound(lookup, index, comparison.words, true, bound, list);
+                            lower();
+                            break;
+                        case "!=":
+                            emitBound(lookup, index, comparison.words, false, unequalLow, list);
+                            emitBound(lookup, index, comparison.words, true, unequalHigh, list);
+                            break;
+                        default: throw unsupported(`it compares an index's key with ${comparison.operator}, which WASM's lookups don't`);
+                    }
+                }
+                // An empty range, and without `!=`'s, one run; with it, the rows before and after the value.
+                code.push(...get(high), ...get(low), op.i32LtS, op.if, 0x40, ...get(low), ...put(high), op.end);
+                code.push(...get(unequalLow), ...constant(0), op.i32GeS, op.if, 0x40);
+                // second = max(low, min(high, unequalHigh)); end = high; high = min(high, max(low, unequalLow))
+                code.push(...get(unequalHigh), ...get(high), ...get(unequalHigh), ...get(high), op.i32LtS, op.select, ...put(second));
+                code.push(...get(second), ...get(low), ...get(second), ...get(low), op.i32GtS, op.select, ...put(second));
+                code.push(...get(high), ...put(end));
+                code.push(...get(unequalLow), ...get(low), ...get(unequalLow), ...get(low), op.i32GtS, op.select, ...put(bound));
+                code.push(...get(bound), ...get(high), ...get(bound), ...get(high), op.i32LtS, op.select, ...put(high));
+                code.push(...get(second), ...get(end), op.i32GeS, op.if, 0x40, ...constant(0), ...put(second), ...constant(0), ...put(end), op.end);
+                code.push(op.end);
+            }
+            // The cursor holds the block of the last lower bound, which needn't be the first row's: `count` 0 marks it unknown.
+            code.push(...constant(0), ...put(listLocal(list, "count")));
+        }
+        emitListRowAt(first, list, () => code.push(op.f64Const, ...float64(0)));
+    };
+    /** How many rows a list holds, as an i32 on the stack. */
+    const emitListCount = (list) => {
+        const { index } = indexOf(list);
+        if (index.kind === "hash")
+            code.push(...get(listLocal(list, "length")));
+        else
+            code.push(...get(listLocal(list, "high")), ...get(listLocal(list, "low")), op.i32Sub, ...get(listLocal(list, "end")), ...get(listLocal(list, "second")), op.i32Sub, op.i32Add);
+    };
+    const emitListLength = (list) => {
+        emitListCount(list);
+        code.push(op.f64ConvertI32U);
+    };
+    /** Points row handle `row` at row `index` (an f64 the callback leaves) of list handle `list`, or at none outside it. */
+    const emitListRowAt = (row, list, index) => {
+        const { lookup, index: structure } = indexOf(list);
+        const value = scratch(f64Type);
+        const position = scratch(i32Type);
+        const archetype = scratch(i32Type);
+        const entryRow = scratch(i32Type);
+        const entry = scratch(i32Type);
+        code.push(...constant(0), ...put(handleLocal(row, "found")));
+        index();
+        code.push(...tee(value), op.f64Const, ...float64(0), op.f64Ge, ...get(value));
+        emitListCount(list);
+        code.push(op.f64ConvertI32U, op.f64Lt, op.i32And, op.if, 0x40);
+        code.push(...get(value), ...truncations.i32TruncSatF64U, ...put(position));
+        if (structure.kind === "hash") {
+            code.push(...get(indexLocal(lookup, 3)), ...get(listLocal(list, "start")), ...get(position), op.i32Add, ...constant(12), op.i32Mul, op.i32Add, ...put(entry));
+            code.push(...get(entry), ...load(4), ...put(archetype), ...get(entry), ...load(8), ...put(entryRow));
+        }
+        else {
+            const runLength = scratch(i32Type);
+            const k = listLocal(list, "k");
+            const first = listLocal(list, "first");
+            const count = listLocal(list, "count");
+            // The position among the entries: in the first run, or the second.
+            code.push(...get(listLocal(list, "high")), ...get(listLocal(list, "low")), op.i32Sub, ...tee(runLength), ...get(position), op.i32GtU);
+            code.push(op.if, i32Type, ...get(listLocal(list, "low")), ...get(position), op.i32Add, op.else, ...get(listLocal(list, "second")), ...get(position), op.i32Add, ...get(runLength), op.i32Sub, op.end, ...put(position));
+            // Outside the cursor's block: find it.
+            code.push(...get(position), ...get(first), op.i32Sub, ...get(count), op.i32GeU, op.if, 0x40);
+            emitBlockAt(lookup, position, k);
+            emitPrefix(lookup, k);
+            code.push(...put(first));
+            code.push(...get(indexLocal(lookup, 3)), ...get(indexLocal(lookup, 2)), ...get(k), ...constant(2), op.i32Shl, op.i32Add, ...load(0), ...constant(2), op.i32Shl, op.i32Add, ...load(0), ...put(count));
+            code.push(op.end);
+            const entryBytes = 4 * structure.stride;
+            code.push(...get(indexLocal(lookup, 4)), ...get(indexLocal(lookup, 2)), ...get(k), ...constant(2), op.i32Shl, op.i32Add, ...load(0), ...constant(entryBytes * 128), op.i32Mul, op.i32Add);
+            code.push(...get(position), ...get(first), op.i32Sub, ...constant(entryBytes), op.i32Mul, op.i32Add, ...put(entry));
+            code.push(...get(entry), ...load(4 * (structure.words + 1)), ...put(archetype), ...get(entry), ...load(4 * (structure.words + 2)), ...put(entryRow));
+        }
+        bindRow(row, lookup, archetype, entryRow);
+        code.push(op.end);
+    };
+    const emitListRow = (row, list, index) => emitListRowAt(row, list, () => emit(index));
+    /** Leaves 1 when a segment tree's ticks over the blocks around entry positions `low` to `high` (i32 locals) are newer than `since`. */
+    const emitRunChanged = (lookup, tree, low, high) => {
+        const from = scratch(i32Type);
+        const to = scratch(i32Type);
+        const position = scratch(i32Type);
+        const node = scratch(i32Type);
+        const limit = scratch(i32Type);
+        const maximum = scratch(f64Type);
+        const size = indexLocal(lookup, 6);
+        const leaves = indexLocal(lookup, 8);
+        // Clamped to the entries: max(low - 1, 0) and min(high, size - 1), then their blocks.
+        code.push(...get(low), ...constant(1), op.i32Sub, ...tee(position), ...constant(0), ...get(position), ...constant(0), op.i32GtS, op.select, ...tee(position));
+        code.push(...get(size), ...constant(1), op.i32Sub, ...get(position), ...get(size), ...constant(1), op.i32Sub, op.i32LtS, op.select, ...put(position));
+        emitBlockAt(lookup, position, from);
+        code.push(...get(high), ...get(size), ...constant(1), op.i32Sub, ...get(high), ...get(size), ...constant(1), op.i32Sub, op.i32LtS, op.select, ...put(position));
+        emitBlockAt(lookup, position, to);
+        code.push(op.f64Const, ...float64(0), ...put(maximum));
+        code.push(...get(from), ...get(leaves), op.i32Add, ...put(node), ...get(to), ...get(leaves), op.i32Add, ...constant(1), op.i32Add, ...put(limit));
+        code.push(op.block, 0x40, op.loop, 0x40);
+        code.push(...get(node), ...get(limit), op.i32GeU, op.brIf, 1);
+        code.push(...get(node), ...constant(1), op.i32And, op.if, 0x40);
+        code.push(...get(maximum), ...get(tree), ...get(node), ...constant(3), op.i32Shl, op.i32Add, op.f64Load, 3, 0, op.f64Max, ...put(maximum), ...get(node), ...constant(1), op.i32Add, ...put(node));
+        code.push(op.end);
+        code.push(...get(limit), ...constant(1), op.i32And, op.if, 0x40);
+        code.push(...get(limit), ...constant(1), op.i32Sub, ...tee(limit), ...constant(3), op.i32Shl, ...get(tree), op.i32Add, op.f64Load, 3, 0, ...get(maximum), op.f64Max, ...put(maximum));
+        code.push(op.end);
+        code.push(...get(node), ...constant(1), op.i32ShrU, ...put(node), ...get(limit), ...constant(1), op.i32ShrU, ...put(limit), op.br, 0);
+        code.push(op.end, op.end);
+        code.push(...get(maximum), ...get(indexLocal(lookup, 10)), op.f64Gt);
+    };
+    /** Whether a list changed since its system last ran, as an f64 of 0 or 1. */
+    const emitListChanged = (list) => {
+        const { lookup, index } = indexOf(list);
+        if (index.kind === "hash") {
+            const bucket = listLocal(list, "bucket");
+            const since = indexLocal(lookup, 6);
+            code.push(...get(bucket), ...constant(0), op.i32LtS, op.if, i32Type, ...get(indexLocal(lookup, 5)), ...get(since), op.f64Gt, op.else);
+            code.push(...get(indexLocal(lookup, 4)), ...get(bucket), ...constant(3), op.i32Shl, op.i32Add, op.f64Load, 3, 0, ...get(since), op.f64Gt);
+            for (let k = 0; k < index.watched; k++)
+                code.push(...get(indexLocal(lookup, 7 + k)), ...get(bucket), ...constant(3), op.i32Shl, op.i32Add, op.f64Load, 3, 0, ...get(since), op.f64Gt, op.i32Or);
+            code.push(op.end, op.f64ConvertI32U);
+            return;
+        }
+        const trees = [indexLocal(lookup, 7), ...Array.from({ length: index.watched }, (_, k) => indexLocal(lookup, 11 + k))];
+        code.push(...get(indexLocal(lookup, 1)), op.i32Eqz, op.if, i32Type, ...get(indexLocal(lookup, 9)), ...get(indexLocal(lookup, 10)), op.f64Gt, op.else);
+        code.push(...constant(0));
+        for (const tree of trees) {
+            emitRunChanged(lookup, tree, listLocal(list, "low"), listLocal(list, "high"));
+            code.push(op.i32Or);
+            code.push(...get(listLocal(list, "end")), ...get(listLocal(list, "second")), op.i32GtS, op.if, i32Type);
+            emitRunChanged(lookup, tree, listLocal(list, "second"), listLocal(list, "end"));
+            code.push(op.else, ...constant(0), op.end, op.i32Or);
+        }
+        code.push(op.end, op.f64ConvertI32U);
+    };
+    /** A leaf of a row handle's row, through its directory record's column `word`, or NaN without a row. */
+    const emitRecordLeaf = (handle, word, column) => {
+        const { view, stride, offset, boolean } = column;
+        code.push(...get(handleLocal(handle, "found")), op.if, f64Type);
+        code.push(...get(handleLocal(handle, "record")), op.i32Load, 2, ...unsigned(4 * word));
+        code.push(...get(handleLocal(handle, "row")), ...constant(stride), op.i32Mul, op.i32Add);
+        const memory = (align) => [align, ...unsigned(offset)];
+        if (boolean)
+            code.push(view === "u8" ? op.i32Load8u : op.i32Load, ...memory(view === "u8" ? 0 : 2), op.i32Const, 0, op.i32Ne, op.f64ConvertI32U);
+        else if (view === "f32")
+            code.push(op.f32Load, ...memory(2), op.f64PromoteF32);
+        else if (view === "i32")
+            code.push(op.i32Load, ...memory(2), op.f64ConvertI32S);
+        else if (view === "u32")
+            code.push(op.i32Load, ...memory(2), op.f64ConvertI32U);
+        else if (view === "u8")
+            code.push(op.i32Load8u, ...memory(0), op.f64ConvertI32U);
+        else
+            code.push(op.f64Load, ...memory(3));
+        code.push(op.else, op.f64Const, ...float64(NaN), op.end);
+    };
+    const emitRowLeaf = (row, leaf) => {
+        const { index } = indexOf(row);
+        const found = index.rowLeaf(leaf);
+        if (found === null)
+            throw unsupported("it reads a value of an index's row that isn't stored in linear memory");
+        // Word 1 is the archetype's entities, so a read's column is at 2 + read.
+        emitRecordLeaf(row, 2 + found.read, found.column);
+    };
+    const emitRowEntity = (row) => {
+        indexOf(row);
+        emitRecordLeaf(row, 1, { view: "f64", stride: 8, offset: 0, boolean: false });
+    };
+    /**
+     * Sets the chunk or block tick, by `shift`, of the row `rowOffset` rows past the current one, unless it's muted
+     * or every row's is stamped up front.
+     */
+    const stampDense = (dense, shift, rowOffset) => {
+        if (columns[dense].muted === true || everyRow.has(dense))
+            return;
+        code.push(op.localGet, ...unsigned(columnParameter(dense)), op.localGet, ...unsigned(rowLocal));
+        if (rowOffset !== 0)
+            code.push(op.i32Const, ...signed(rowOffset), op.i32Add);
+        code.push(op.i32Const, ...signed(shift), op.i32ShrU, op.i32Const, 3, op.i32Shl, op.i32Add, op.localGet, 2, op.f64Store, 3, 0);
+    };
+    const statement = (current) => {
+        switch (current.kind) {
+            case "set":
+                emit(current.value);
+                code.push(op.localSet, ...unsigned(local(current.local)));
+                return;
+            case "store": return store(current.column, current.value);
+            // A chunk column stays when its row column is muted, for a component held on the GPU.
+            case "stamp":
+                if (columns[current.column].muted !== true)
+                    store(current.column, "tick");
+                stampDense(current.blocks, blockShift, 0);
+                stampDense(current.chunks, chunkShift, 0);
+                return;
+            case "if":
+                emit(current.test);
+                emitTruthy(typeOf(current.test));
+                code.push(op.if, 0x40);
+                labels.push("if");
+                for (const inner of current.consequent)
+                    statement(inner);
+                if (current.alternate.length > 0) {
+                    code.push(op.else);
+                    for (const inner of current.alternate)
+                        statement(inner);
+                }
+                labels.pop();
+                code.push(op.end);
+                return;
+            case "block":
+            case "loop":
+                code.push(current.kind === "block" ? op.block : op.loop, 0x40);
+                labels.push("program");
+                for (const inner of current.body)
+                    statement(inner);
+                labels.pop();
+                code.push(op.end);
+                return;
+            case "branch":
+                code.push(op.br, ...unsigned(wasmDepth(current.depth)));
+                return;
+            case "branchIf":
+                emit(current.test);
+                emitTruthy(typeOf(current.test));
+                code.push(op.brIf, ...unsigned(wasmDepth(current.depth)));
+                return;
+            case "next":
+                code.push(op.br, ...unsigned(labels.length - 1 - labels.lastIndexOf("next")));
+                return;
+            case "find": return emitFind(current.handle, current.lookup, current.entity);
+            case "probe": return emitProbe(current.list, current.first, current.probe, current.values);
+            case "listRow": return emitListRow(current.row, current.list, current.index);
+        }
+    };
+    // ---- SIMD. f32 lanes compute at storage precision, so results may differ from the scalar path; f64 lanes don't. ----
+    const v128Type = 0x7b;
+    const simd = (operation) => [0xfd, ...unsigned(operation)];
+    const vop = {
+        load: 0, store: 11, const: 12, f32Splat: 19, f64Splat: 20,
+        f32Eq: 65, f32Ne: 66, f32Lt: 67, f32Gt: 68, f32Le: 69, f32Ge: 70,
+        f64Gt: 74, not: 77, and: 78, andNot: 79, or: 80, bitselect: 82, anyTrue: 83,
+        store32Lane: 90, store64Lane: 91, load32Zero: 92, load64Zero: 93,
+        f64Eq: 71, f64Ne: 72, f64Lt: 73, f64Le: 75, f64Ge: 76, f32DemoteF64Zero: 94, f64PromoteLowF32: 95,
+        f32Ceil: 103, f32Floor: 104, f32Trunc: 105, f64Ceil: 116, f64Floor: 117, f64Trunc: 122, i64ExtendLowS: 199, i64ExtendHighS: 200,
+        f32Abs: 224, f32Neg: 225, f32Sqrt: 227, f32Add: 228, f32Sub: 229, f32Mul: 230, f32Div: 231, f32Min: 232, f32Max: 233,
+        f64Abs: 236, f64Neg: 237, f64Sqrt: 239, f64Add: 240, f64Sub: 241, f64Mul: 242, f64Div: 243, f64Min: 244, f64Max: 245,
+    };
+    /** f64 lanes: each vector holds two values, each operation the f64 one, so lanes compute as the scalar path does. */
+    const wide = !storagePrecision;
+    /** Bytes of f32 storage one vector covers: four lanes, or two promoted to f64. */
+    const laneBytes = wide ? 8 : 16;
+    const float32 = (value) => [...new Uint8Array(new Float32Array([value]).buffer)];
+    const vectorConstant = (values) => wide
+        ? [...simd(vop.const), ...[0, 1].flatMap(lane => float64(values[lane] ?? 0))]
+        : [...simd(vop.const), ...[0, 1, 2, 3].flatMap(lane => float32(values[lane] ?? 0))];
+    const splatConstant = (value) => vectorConstant([value, value, value, value]);
+    const arithmeticVector = wide
+        ? { "+": vop.f64Add, "-": vop.f64Sub, "*": vop.f64Mul, "/": vop.f64Div }
+        : { "+": vop.f32Add, "-": vop.f32Sub, "*": vop.f32Mul, "/": vop.f32Div };
+    const unaryVector = wide
+        ? { abs: vop.f64Abs, sqrt: vop.f64Sqrt, floor: vop.f64Floor, ceil: vop.f64Ceil, trunc: vop.f64Trunc }
+        : { abs: vop.f32Abs, sqrt: vop.f32Sqrt, floor: vop.f32Floor, ceil: vop.f32Ceil, trunc: vop.f32Trunc };
+    const negateVector = wide ? vop.f64Neg : vop.f32Neg;
+    const comparisonVector = wide
+        ? { "<": vop.f64Lt, ">": vop.f64Gt, "<=": vop.f64Le, ">=": vop.f64Ge, "==": vop.f64Eq, "!=": vop.f64Ne, "===": vop.f64Eq, "!==": vop.f64Ne }
+        : { "<": vop.f32Lt, ">": vop.f32Gt, "<=": vop.f32Le, ">=": vop.f32Ge, "==": vop.f32Eq, "!=": vop.f32Ne, "===": vop.f32Eq, "!==": vop.f32Ne };
+    /** Loads the vector of f32 storage at the address on the stack plus `offset`, as lanes. */
+    const loadLanes = (offset) => {
+        if (wide)
+            code.push(...simd(vop.load64Zero), 2, ...unsigned(offset), ...simd(vop.f64PromoteLowF32));
+        else
+            code.push(...simd(vop.load), 2, ...unsigned(offset));
+    };
+    /** Stores lanes, on the stack after the address, to f32 storage at that address plus `offset`. */
+    const storeLanes = (offset) => {
+        if (wide)
+            code.push(...simd(vop.f32DemoteF64Zero), ...simd(vop.store64Lane), 2, ...unsigned(offset), 0);
+        else
+            code.push(...simd(vop.store), 2, ...unsigned(offset));
+    };
+    const isArithmetic = (operator) => operator in arithmeticVector;
+    /** A value that's the same for every lane, splatted: demoted to f32 for f32 lanes, as a lane computes. */
+    const emitSplat = (expression) => {
+        emit(expression);
+        if (wide)
+            code.push(...simd(vop.f64Splat));
+        else
+            code.push(op.f32DemoteF64, ...simd(vop.f32Splat));
+    };
+    /** `Math` functions with a vector equivalent; `fround` is the identity in f32 and a demotion and promotion in f64. */
+    const emitVectorMath = (functionName, count) => {
+        if (functionName === "min" || functionName === "max") {
+            const operation = functionName === "min" ? (wide ? vop.f64Min : vop.f32Min) : (wide ? vop.f64Max : vop.f32Max);
+            for (let i = 1; i < count; i++)
+                code.push(...simd(operation));
+            return;
+        }
+        if (functionName === "fround" && wide)
+            return void code.push(...simd(vop.f32DemoteF64Zero), ...simd(vop.f64PromoteLowF32));
+        const unary = unaryVector[functionName];
+        if (unary !== undefined)
+            code.push(...simd(unary));
+    };
+    const vectorMath = (functionName, count) => ((functionName === "min" || functionName === "max") && count > 0) || ((unaryVector[functionName] !== undefined || functionName === "fround") && count === 1);
+    // ---- Across rows: four rows at a time in f32 lanes, two in f64, for programs whose columns are all dense f32. ----
+    /** The mask of the enclosing `if`s, or null outside any. */
+    let mask = null;
+    const rowsLocals = [];
+    const rowsLocal = (index) => rowsLocals[index] ??= scratch(v128Type);
+    /** Rows a pass of the across-rows loops runs at once, which stamps cover. */
+    let groupRows = 4;
+    const denseAddress = (column) => {
+        const { view, stride, boolean, component } = columns[column];
+        if (view !== "f32" || stride !== 4 || boolean || component < 0)
+            throw notVectorizable;
+        code.push(op.localGet, ...unsigned(columnParameter(column)), op.localGet, ...unsigned(rowLocal), op.i32Const, 4, op.i32Mul, op.i32Add);
+    };
+    const vectorTruthy = (type) => {
+        if (type === "boolean") {
+            code.push(...splatConstant(0), ...simd(comparisonVector["!="] ?? vop.f32Ne));
+            return;
+        }
+        const value = scratch(v128Type);
+        code.push(op.localTee, ...unsigned(value), ...splatConstant(0), ...simd(comparisonVector["!="] ?? vop.f32Ne));
+        code.push(op.localGet, ...unsigned(value), op.localGet, ...unsigned(value), ...simd(comparisonVector["=="] ?? vop.f32Eq), ...simd(vop.and));
+    };
+    /** A lane mask as a value: 1 where set, 0 elsewhere. */
+    const maskValue = () => {
+        code.push(...splatConstant(1), ...simd(vop.and));
+    };
+    const rowsEmit = (expression) => {
+        switch (expression.kind) {
+            case "number":
+                code.push(...splatConstant(expression.value));
+                return;
+            case "boolean":
+                code.push(...splatConstant(expression.value ? 1 : 0));
+                return;
+            case "local":
+                code.push(op.localGet, ...unsigned(rowsLocal(expression.local)));
+                return;
+            case "resource":
+            case "args":
+            case "shared": return emitSplat(expression);
+            case "column":
+                denseAddress(expression.column);
+                loadLanes(columns[expression.column].offset);
+                return;
+            case "unary":
+                rowsEmit(expression.operand);
+                if (expression.operator === "-")
+                    code.push(...simd(negateVector));
+                else if (expression.operator === "!") {
+                    vectorTruthy(typeOf(expression.operand));
+                    code.push(...simd(vop.not));
+                    maskValue();
+                }
+                else if (expression.operator === "~")
+                    throw notVectorizable;
+                return;
+            case "binary": {
+                const { operator, left, right } = expression;
+                if (operator === "===" || operator === "!==") {
+                    const leftType = typeOf(left);
+                    const rightType = typeOf(right);
+                    if (leftType === "mixed" || rightType === "mixed")
+                        throw unsupported("it compares with === or !== a value that may be a boolean or a number");
+                    if (leftType !== rightType) {
+                        code.push(...splatConstant(operator === "===" ? 0 : 1));
+                        return;
+                    }
+                }
+                const comparison = comparisonVector[operator];
+                if (!isArithmetic(operator) && comparison === undefined)
+                    throw notVectorizable;
+                rowsEmit(left);
+                rowsEmit(right);
+                if (isArithmetic(operator))
+                    code.push(...simd(arithmeticVector[operator]));
+                else if (comparison !== undefined) {
+                    code.push(...simd(comparison));
+                    maskValue();
+                }
+                return;
+            }
+            case "logical": {
+                const value = scratch(v128Type);
+                rowsEmit(expression.left);
+                code.push(op.localSet, ...unsigned(value));
+                // bitselect(a, b, m) takes a where m is set.
+                if (expression.operator === "&&") {
+                    rowsEmit(expression.right);
+                    code.push(op.localGet, ...unsigned(value));
+                }
+                else {
+                    code.push(op.localGet, ...unsigned(value));
+                    rowsEmit(expression.right);
+                }
+                code.push(op.localGet, ...unsigned(value));
+                vectorTruthy(typeOf(expression.left));
+                code.push(...simd(vop.bitselect));
+                return;
+            }
+            case "conditional":
+                rowsEmit(expression.consequent);
+                rowsEmit(expression.alternate);
+                rowsEmit(expression.test);
+                vectorTruthy(typeOf(expression.test));
+                code.push(...simd(vop.bitselect));
+                return;
+            case "math":
+                if (!vectorMath(expression.name, expression.arguments.length))
+                    throw notVectorizable;
+                for (const parameter of expression.arguments)
+                    rowsEmit(parameter);
+                emitVectorMath(expression.name, expression.arguments.length);
+                return;
+            case "found":
+            case "lookupLeaf":
+            case "upFound":
+            case "upLeaf":
+            case "listLength":
+            case "listChanged":
+            case "rowLeaf":
+            case "rowEntity": throw notVectorizable;
+        }
+    };
+    /** Under a mask, keeps the old value (left on the stack below the new one) where the mask is clear. */
+    const blend = () => {
+        if (mask === null)
+            return;
+        code.push(op.localGet, ...unsigned(mask), ...simd(vop.bitselect));
+    };
+    const rowsStatement = (current) => {
+        switch (current.kind) {
+            case "set": {
+                const target = rowsLocal(current.local);
+                rowsEmit(current.value);
+                if (mask !== null) {
+                    code.push(op.localGet, ...unsigned(target));
+                    blend();
+                }
+                code.push(op.localSet, ...unsigned(target));
+                return;
+            }
+            case "store": {
+                const value = scratch(v128Type);
+                rowsEmit(current.value);
+                if (mask !== null) {
+                    rowsEmit({ kind: "column", column: current.column });
+                    blend();
+                }
+                code.push(op.localSet, ...unsigned(value));
+                denseAddress(current.column);
+                code.push(op.localGet, ...unsigned(value));
+                storeLanes(columns[current.column].offset);
+                return;
+            }
+            case "stamp": {
+                // Ticks are dense f64: each two rows are an f64x2 store; a chunk column stays when its row column is muted.
+                // f64 lanes' masks are already a lane per row; f32 lanes' are extended, two rows a store.
+                if (columns[current.column].muted !== true) {
+                    for (let half = 0; half < groupRows / 2; half++) {
+                        const address = () => { code.push(op.localGet, ...unsigned(columnParameter(current.column)), op.localGet, ...unsigned(rowLocal), op.i32Const, 3, op.i32Shl, op.i32Add); };
+                        address();
+                        code.push(op.localGet, 2, ...simd(vop.f64Splat));
+                        if (mask !== null) {
+                            address();
+                            code.push(...simd(vop.load), 3, ...unsigned(16 * half));
+                            code.push(op.localGet, ...unsigned(mask));
+                            if (!wide)
+                                code.push(...simd(half === 0 ? vop.i64ExtendLowS : vop.i64ExtendHighS));
+                            code.push(...simd(vop.bitselect));
+                        }
+                        code.push(...simd(vop.store), 3, ...unsigned(16 * half));
+                    }
+                }
+                // The group may straddle two chunks or blocks. Under a mask this can stamp one no lane changed, which only costs a scan.
+                stampDense(current.blocks, blockShift, 0);
+                stampDense(current.blocks, blockShift, groupRows - 1);
+                stampDense(current.chunks, chunkShift, 0);
+                stampDense(current.chunks, chunkShift, groupRows - 1);
+                return;
+            }
+            case "if": {
+                const test = scratch(v128Type);
+                rowsEmit(current.test);
+                vectorTruthy(typeOf(current.test));
+                code.push(op.localSet, ...unsigned(test));
+                const outer = mask;
+                const branch = (statements, negate) => {
+                    if (statements.length === 0)
+                        return;
+                    const inner = scratch(v128Type);
+                    if (outer === null) {
+                        code.push(op.localGet, ...unsigned(test));
+                        if (negate)
+                            code.push(...simd(vop.not));
+                    }
+                    else {
+                        code.push(op.localGet, ...unsigned(outer), op.localGet, ...unsigned(test), ...simd(negate ? vop.andNot : vop.and));
+                    }
+                    code.push(op.localSet, ...unsigned(inner));
+                    mask = inner;
+                    for (const statement of statements)
+                        rowsStatement(statement);
+                    mask = outer;
+                };
+                branch(current.consequent, false);
+                branch(current.alternate, true);
+                return;
+            }
+            default: throw notVectorizable;
+        }
+    };
+    /** Rows from `start` in groups of a vector's lanes, up to the last whole group; leaves the row local at the first row not done. */
+    const rowsLoop = () => {
+        groupRows = laneBytes / 4;
+        const vectorEnd = scratch(i32Type);
+        code.push(op.localGet, 1, op.localGet, 0, op.i32Sub, op.i32Const, ...signed(-groupRows), op.i32And, op.localGet, 0, op.i32Add, op.localSet, ...unsigned(vectorEnd));
+        code.push(op.block, 0x40, op.loop, 0x40);
+        code.push(op.localGet, ...unsigned(rowLocal), op.localGet, ...unsigned(vectorEnd), op.i32GeS, op.brIf, 1);
+        mask = null;
+        for (const current of program.body)
+            rowsStatement(current);
+        code.push(op.localGet, ...unsigned(rowLocal), op.i32Const, ...signed(groupRows), op.i32Add, op.localSet, ...unsigned(rowLocal), op.br, 0);
+        code.push(op.end, op.end);
+    };
+    /** f32 leaves of one component, as consecutive lanes from the lowest offset; null if they can't be. */
+    const windowOf = (laneColumns) => {
+        const infos = laneColumns.map(column => columns[column]);
+        const first = infos[0];
+        if (first === undefined || infos.some(info => info.view !== "f32" || info.boolean || info.component !== first.component || info.component < 0))
+            return null;
+        const base = Math.min(...infos.map(info => info.offset));
+        const lanes = infos.map(info => (info.offset - base) / 4);
+        if (lanes.some(lane => lane > 3) || new Set(lanes).size !== lanes.length)
+            return null;
+        return { component: first.component, base, lanes: Math.max(...lanes) + 1 };
+    };
+    const laneIn = (window, column) => (columns[column].offset - window.base) / 4;
+    const elementAddress = (column) => {
+        code.push(op.localGet, ...unsigned(columnParameter(column)), op.localGet, ...unsigned(rowLocal), op.i32Const, ...signed(columns[column].stride), op.i32Mul, op.i32Add);
+    };
+    /**
+     * Loads a window's lanes. Three or four lanes load 16 bytes, which can read up to 12 past the element:
+     * columns keep `columnSlack` bytes after their last row for that. Two or one load only their lanes.
+     */
+    const loadWindow = (column, { base, lanes }) => {
+        elementAddress(column);
+        if (lanes >= 3)
+            return void code.push(...simd(vop.load), 2, ...unsigned(base));
+        code.push(...simd(lanes === 1 ? vop.load32Zero : vop.load64Zero), 2, ...unsigned(base));
+    };
+    /** Stores a window's lanes from a v128 local, without touching the rest of the element. */
+    const storeWindow = (column, { base, lanes }, value) => {
+        elementAddress(column);
+        code.push(op.localGet, ...unsigned(value));
+        if (lanes === 4)
+            return void code.push(...simd(vop.store), 2, ...unsigned(base));
+        code.push(...simd(vop.store64Lane), 2, ...unsigned(base), 0);
+        if (lanes !== 3)
+            return;
+        elementAddress(column);
+        code.push(op.localGet, ...unsigned(value), ...simd(vop.store32Lane), 2, ...unsigned(base + 8), 2);
+    };
+    /** Plans the fusion of top-level statements. Statement index to group, and which `set`s only feed groups. */
+    const planLanes = () => {
+        const body = program.body;
+        const assignments = new Map();
+        const uses = new Map();
+        const countExpression = (expression) => {
+            switch (expression.kind) {
+                case "local":
+                    uses.set(expression.local, (uses.get(expression.local) ?? 0) + 1);
+                    return;
+                case "unary": return countExpression(expression.operand);
+                case "binary":
+                case "logical":
+                    countExpression(expression.left);
+                    return countExpression(expression.right);
+                case "conditional":
+                    countExpression(expression.test);
+                    countExpression(expression.consequent);
+                    return countExpression(expression.alternate);
+                case "math":
+                    for (const parameter of expression.arguments)
+                        countExpression(parameter);
+                    return;
+                default: return;
+            }
+        };
+        const countStatements = (statements) => {
+            for (const statement of statements) {
+                switch (statement.kind) {
+                    case "set":
+                        assignments.set(statement.local, (assignments.get(statement.local) ?? 0) + 1);
+                        countExpression(statement.value);
+                        break;
+                    case "store":
+                        countExpression(statement.value);
+                        break;
+                    case "branchIf":
+                        countExpression(statement.test);
+                        break;
+                    case "find":
+                        countExpression(statement.entity);
+                        break;
+                    case "if":
+                        countExpression(statement.test);
+                        countStatements(statement.consequent);
+                        countStatements(statement.alternate);
+                        break;
+                    case "block":
+                    case "loop":
+                        countStatements(statement.body);
+                        break;
+                    default: break;
+                }
+            }
+        };
+        countStatements(body);
+        // Packs: single-assignment snapshot locals of one component's leaves, with no store to it between their sets.
+        const packOfLocal = new Map();
+        const open = new Map();
+        const packs = new Map();
+        const close = (component) => {
+            const pending = open.get(component);
+            open.delete(component);
+            if (pending === undefined || pending.columns.length < 2)
+                return;
+            const window = windowOf(pending.columns);
+            if (window === null)
+                return;
+            const pack = { first: pending.first, column: pending.columns[0], window, lanes: new Map(), used: false, local: -1 };
+            pending.locals.forEach((local, i) => {
+                pack.lanes.set(local, laneIn(window, pending.columns[i]));
+                packOfLocal.set(local, pack);
+            });
+            packs.set(pending.first, pack);
+        };
+        body.forEach((statement, index) => {
+            if (statement.kind === "set" && statement.value.kind === "column" && assignments.get(statement.local) === 1) {
+                const info = columns[statement.value.column];
+                if (info.view === "f32" && !info.boolean && info.component >= 0) {
+                    const pending = open.get(info.component) ?? { first: index, columns: [], locals: [] };
+                    open.set(info.component, pending);
+                    pending.columns.push(statement.value.column);
+                    pending.locals.push(statement.local);
+                    return;
+                }
+            }
+            if (statement.kind === "store")
+                close(columns[statement.column].component);
+            if (statement.kind !== "set")
+                for (const component of [...open.keys()])
+                    close(component);
+        });
+        for (const component of [...open.keys()])
+            close(component);
+        /** Whether an expression reads a leaf (by component and offset) in `written`. */
+        const reads = (expression, written) => {
+            switch (expression.kind) {
+                case "column": return written.has(`${columns[expression.column].component}:${columns[expression.column].offset}`);
+                case "unary": return reads(expression.operand, written);
+                case "binary":
+                case "logical": return reads(expression.left, written) || reads(expression.right, written);
+                case "conditional": return reads(expression.test, written) || reads(expression.consequent, written) || reads(expression.alternate, written);
+                case "math": return expression.arguments.some(parameter => reads(parameter, written));
+                default: return false;
+            }
+        };
+        /** Fused stores read everything before writing, so no store may read a leaf an earlier one in the group wrote. */
+        const readsEarlierStore = (stores) => {
+            const written = new Set();
+            for (const store of stores) {
+                if (reads(store.value, written))
+                    return true;
+                written.add(`${columns[store.column].component}:${columns[store.column].offset}`);
+            }
+            return false;
+        };
+        const groupUses = new Map();
+        /** Matches one expression per lane; null if they don't line up. */
+        const match = (lanes) => {
+            const first = lanes[0];
+            if (lanes.every(lane => JSON.stringify(lane) === JSON.stringify(first)))
+                return { kind: "splat", expression: first };
+            if (lanes.every(lane => lane.kind === "number"))
+                return { kind: "constant", values: lanes.map(lane => lane.kind === "number" ? lane.value : 0) };
+            if (first.kind === "local") {
+                const pack = packOfLocal.get(first.local);
+                if (pack !== undefined && lanes.every((lane, i) => lane.kind === "local" && packOfLocal.get(lane.local) === pack && pack.lanes.get(lane.local) === i)) {
+                    for (const lane of lanes)
+                        if (lane.kind === "local")
+                            groupUses.set(lane.local, (groupUses.get(lane.local) ?? 0) + 1);
+                    return { kind: "pack", pack };
+                }
+                return null;
+            }
+            if (first.kind === "column") {
+                const laneColumns = lanes.flatMap(lane => lane.kind === "column" ? [lane.column] : []);
+                const window = laneColumns.length === lanes.length ? windowOf(laneColumns) : null;
+                return window !== null && laneColumns.every((column, i) => laneIn(window, column) === i) ? { kind: "load", column: laneColumns[0], window } : null;
+            }
+            if (first.kind === "binary" && isArithmetic(first.operator)) {
+                const { operator } = first;
+                const pairs = lanes.flatMap(lane => lane.kind === "binary" && lane.operator === operator ? [lane] : []);
+                if (pairs.length !== lanes.length)
+                    return null;
+                const left = match(pairs.map(pair => pair.left));
+                const right = left === null ? null : match(pairs.map(pair => pair.right));
+                return left === null || right === null ? null : { kind: "binary", operator, left, right };
+            }
+            if (first.kind === "unary" && (first.operator === "-" || first.operator === "+")) {
+                const operator = first.operator;
+                const operands = lanes.flatMap(lane => lane.kind === "unary" && lane.operator === operator ? [lane.operand] : []);
+                if (operands.length !== lanes.length)
+                    return null;
+                const operand = match(operands);
+                return operand === null ? null : operator === "-" ? { kind: "negate", operand } : operand;
+            }
+            if (first.kind === "math" && vectorMath(first.name, first.arguments.length)) {
+                const calls = lanes.flatMap(lane => lane.kind === "math" && lane.name === first.name && lane.arguments.length === first.arguments.length ? [lane] : []);
+                if (calls.length !== lanes.length)
+                    return null;
+                const parameters = [];
+                for (let i = 0; i < first.arguments.length; i++) {
+                    const parameter = match(calls.map(call => call.arguments[i]));
+                    if (parameter === null)
+                        return null;
+                    parameters.push(parameter);
+                }
+                return { kind: "math", name: first.name, arguments: parameters };
+            }
+            return null;
+        };
+        // Groups: consecutive stores to two or more leaves of one component whose values match lane for lane.
+        const groups = new Map();
+        for (let index = 0; index < body.length;) {
+            const statement = body[index];
+            if (statement.kind !== "store") {
+                index++;
+                continue;
+            }
+            const component = columns[statement.column].component;
+            let end = index;
+            while (end < body.length) {
+                const next = body[end];
+                if (next.kind !== "store" || columns[next.column].component !== component)
+                    break;
+                end++;
+            }
+            const stores = body.slice(index, end).flatMap(store => store.kind === "store" ? [store] : []);
+            const window = stores.length >= 2 ? windowOf(stores.map(store => store.column)) : null;
+            const lanes = [];
+            if (window !== null && window.lanes === stores.length)
+                for (const store of stores)
+                    lanes[laneIn(window, store.column)] = store.value;
+            const before = new Map(groupUses);
+            const value = window !== null && window.lanes === stores.length && !readsEarlierStore(stores) ? match(lanes) : null;
+            if (window !== null && value !== null) {
+                groups.set(index, { length: stores.length, column: stores[0].column, window, value });
+                const markUsed = (expression) => {
+                    if (expression.kind === "pack")
+                        expression.pack.used = true;
+                    else if (expression.kind === "binary") {
+                        markUsed(expression.left);
+                        markUsed(expression.right);
+                    }
+                    else if (expression.kind === "negate")
+                        markUsed(expression.operand);
+                    else if (expression.kind === "math")
+                        expression.arguments.forEach(markUsed);
+                };
+                markUsed(value);
+            }
+            else {
+                groupUses.clear();
+                for (const [local, count] of before)
+                    groupUses.set(local, count);
+            }
+            index = end;
+        }
+        // A snapshot `set` whose local is only read through vectors needn't run as a scalar.
+        const skipped = new Set();
+        body.forEach((statement, index) => {
+            if (statement.kind === "set" && packOfLocal.get(statement.local)?.used === true && (uses.get(statement.local) ?? 0) === (groupUses.get(statement.local) ?? 0))
+                skipped.add(index);
+        });
+        return { groups, packs, skipped };
+    };
+    const emitVectorExpression = (expression) => {
+        switch (expression.kind) {
+            case "pack":
+                code.push(op.localGet, ...unsigned(expression.pack.local));
+                return;
+            case "load": return loadWindow(expression.column, expression.window);
+            case "constant":
+                code.push(...vectorConstant(expression.values));
+                return;
+            case "splat": return emitSplat(expression.expression);
+            case "binary":
+                emitVectorExpression(expression.left);
+                emitVectorExpression(expression.right);
+                code.push(...simd(arithmeticVector[expression.operator]));
+                return;
+            case "negate":
+                emitVectorExpression(expression.operand);
+                code.push(...simd(negateVector));
+                return;
+            case "math":
+                for (const parameter of expression.arguments)
+                    emitVectorExpression(parameter);
+                emitVectorMath(expression.name, expression.arguments.length);
+                return;
+        }
+    };
+    /** The row body, with planned groups fused; returns whether anything was. */
+    const emitLaneBody = () => {
+        const { groups, packs, skipped } = planLanes();
+        const body = program.body;
+        for (let index = 0; index < body.length; index++) {
+            const pack = packs.get(index);
+            if (pack?.used === true) {
+                pack.local = scratch(v128Type);
+                loadWindow(pack.column, pack.window);
+                code.push(op.localSet, ...unsigned(pack.local));
+            }
+            const group = groups.get(index);
+            if (group !== undefined) {
+                const value = scratch(v128Type);
+                emitVectorExpression(group.value);
+                code.push(op.localSet, ...unsigned(value));
+                storeWindow(group.column, group.window, value);
+                index += group.length - 1;
+                continue;
+            }
+            if (!skipped.has(index))
+                statement(body[index]);
+        }
+        return groups.size > 0;
+    };
+    /** Whether a value calls an import: `%` and `**`, which only integers by a literal skip, and most `Math` functions. */
+    const callsImport = (expression) => {
+        switch (expression.kind) {
+            case "unary": return callsImport(expression.operand);
+            case "binary": return expression.operator === "%" || expression.operator === "**" || callsImport(expression.left) || callsImport(expression.right);
+            case "logical": return callsImport(expression.left) || callsImport(expression.right);
+            case "conditional": return callsImport(expression.test) || callsImport(expression.consequent) || callsImport(expression.alternate);
+            case "math": return !native.has(expression.name) || expression.arguments.some(callsImport);
+            default: return false;
+        }
+    };
+    /** Computes each largest row-independent value calling an import within `statements` into a local of its own. */
+    const hoist = (statements) => {
+        const visit = (expression) => {
+            if (hoisted.has(expression))
+                return;
+            if (rowIndependent(expression) && callsImport(expression)) {
+                emit(expression);
+                const value = scratch(f64Type);
+                code.push(op.localSet, ...unsigned(value));
+                hoisted.set(expression, value);
+                return;
+            }
+            switch (expression.kind) {
+                case "unary": return visit(expression.operand);
+                case "binary":
+                case "logical":
+                    visit(expression.left);
+                    visit(expression.right);
+                    return;
+                case "conditional":
+                    visit(expression.test);
+                    visit(expression.consequent);
+                    visit(expression.alternate);
+                    return;
+                case "math": return expression.arguments.forEach(visit);
+                default: return;
+            }
+        };
+        for (const current of statements) {
+            switch (current.kind) {
+                case "set":
+                case "store":
+                    visit(current.value);
+                    break;
+                case "if":
+                    visit(current.test);
+                    hoist(current.consequent);
+                    hoist(current.alternate);
+                    break;
+                case "block":
+                case "loop":
+                    hoist(current.body);
+                    break;
+                case "branchIf":
+                    visit(current.test);
+                    break;
+                case "find":
+                    visit(current.entity);
+                    break;
+                case "probe":
+                    current.values.forEach(visit);
+                    break;
+                case "listRow":
+                    visit(current.index);
+                    break;
+                case "intrinsic":
+                    for (const operand of current.operands)
+                        operand.forEach(visit);
+                    hoist(current.body);
+                    break;
+                default: break;
+            }
+        }
+    };
+    /** Whether a value is the same for every row. */
+    const rowIndependent = (expression) => {
+        switch (expression.kind) {
+            case "number":
+            case "boolean":
+            case "resource":
+            case "args":
+            case "shared": return true;
+            case "unary": return rowIndependent(expression.operand);
+            case "binary":
+            case "logical": return rowIndependent(expression.left) && rowIndependent(expression.right);
+            case "conditional": return rowIndependent(expression.test) && rowIndependent(expression.consequent) && rowIndependent(expression.alternate);
+            case "math": return expression.arguments.every(rowIndependent);
+            default: return false;
+        }
+    };
+    /**
+     * Whether the planned groups are the whole body and run unchanged on flat vectors of four rows: each group stores
+     * whole elements and reads windows from byte 0 of components with the same stride, so lane `l` of vector `j` is the
+     * same leaf in every operand. Snapshot sets must be skipped, and stamps run as in the across-rows loop.
+     */
+    const acrossElements = ({ groups, skipped }) => {
+        if (filters > 0 || groups.size === 0)
+            return false;
+        const whole = (column, window, stride) => window.base === 0 && columns[column].stride === stride;
+        const fits = (expression, stride) => {
+            switch (expression.kind) {
+                case "pack": return whole(expression.pack.column, expression.pack.window, stride);
+                case "load": return whole(expression.column, expression.window, stride);
+                case "constant": return true;
+                case "splat": return rowIndependent(expression.expression);
+                case "binary": return fits(expression.left, stride) && fits(expression.right, stride);
+                case "negate": return fits(expression.operand, stride);
+                case "math": return expression.arguments.every(parameter => fits(parameter, stride));
+            }
+        };
+        const body = program.body;
+        for (let index = 0; index < body.length; index++) {
+            const group = groups.get(index);
+            if (group !== undefined) {
+                const { stride } = columns[group.column];
+                if (group.window.base !== 0 || group.window.lanes * 4 !== stride || !fits(group.value, stride))
+                    return false;
+                index += group.length - 1;
+            }
+            else if (!skipped.has(index) && body[index].kind !== "stamp")
+                return false;
+        }
+        return true;
+    };
+    /** Vector `vector` of an expression over four rows of `stride`-byte elements; packs are in `packVectors`. */
+    const emitElementExpression = (expression, vector, stride, packVectors) => {
+        switch (expression.kind) {
+            case "pack": {
+                // Every pack a group uses is loaded at its first set, before the group.
+                const local = packVectors.get(expression.pack)?.[vector];
+                if (local === undefined)
+                    throw new Error("A pack is used before it's loaded.");
+                code.push(op.localGet, ...unsigned(local));
+                return;
+            }
+            case "load":
+                elementAddress(expression.column);
+                loadLanes(laneBytes * vector);
+                return;
+            case "constant":
+                code.push(...vectorConstant([0, 1, 2, 3].map(lane => expression.values[((laneBytes * vector + 4 * lane) % stride) / 4] ?? 0)));
+                return;
+            case "splat": return emitSplat(expression.expression);
+            case "binary":
+                emitElementExpression(expression.left, vector, stride, packVectors);
+                emitElementExpression(expression.right, vector, stride, packVectors);
+                code.push(...simd(arithmeticVector[expression.operator]));
+                return;
+            case "negate":
+                emitElementExpression(expression.operand, vector, stride, packVectors);
+                code.push(...simd(negateVector));
+                return;
+            case "math":
+                for (const parameter of expression.arguments)
+                    emitElementExpression(parameter, vector, stride, packVectors);
+                emitVectorMath(expression.name, expression.arguments.length);
+                return;
+        }
+    };
+    /**
+     * Rows from `start` in groups of four, up to the last whole group, with every group as `stride / 4` full-vector loads,
+     * operations and stores; leaves the row local at the first row not done. Vectors stay inside the four rows' elements,
+     * and each vector's store only touches bytes no other vector reads.
+     */
+    const elementsLoop = ({ groups, packs }) => {
+        groupRows = 4;
+        const vectors = (stride) => 4 * stride / laneBytes;
+        const vectorEnd = scratch(i32Type);
+        code.push(op.localGet, 1, op.localGet, 0, op.i32Sub, op.i32Const, ...signed(-4), op.i32And, op.localGet, 0, op.i32Add, op.localSet, ...unsigned(vectorEnd));
+        code.push(op.block, 0x40, op.loop, 0x40);
+        code.push(op.localGet, ...unsigned(rowLocal), op.localGet, ...unsigned(vectorEnd), op.i32GeS, op.brIf, 1);
+        mask = null;
+        const packVectors = new Map();
+        const body = program.body;
+        for (let index = 0; index < body.length; index++) {
+            const pack = packs.get(index);
+            if (pack?.used === true) {
+                const locals = Array.from({ length: vectors(columns[pack.column].stride) }, (_, vector) => {
+                    const local = scratch(v128Type);
+                    elementAddress(pack.column);
+                    loadLanes(laneBytes * vector);
+                    code.push(op.localSet, ...unsigned(local));
+                    return local;
+                });
+                packVectors.set(pack, locals);
+            }
+            const group = groups.get(index);
+            if (group !== undefined) {
+                const { stride } = columns[group.column];
+                for (let vector = 0; vector < vectors(stride); vector++) {
+                    const value = scratch(v128Type);
+                    emitElementExpression(group.value, vector, stride, packVectors);
+                    code.push(op.localSet, ...unsigned(value));
+                    elementAddress(group.column);
+                    code.push(op.localGet, ...unsigned(value));
+                    storeLanes(laneBytes * vector);
+                }
+                index += group.length - 1;
+            }
+            else if (body[index].kind === "stamp")
+                rowsStatement(body[index]);
+        }
+        code.push(op.localGet, ...unsigned(rowLocal), op.i32Const, 4, op.i32Add, op.localSet, ...unsigned(rowLocal), op.br, 0);
+        code.push(op.end, op.end);
+    };
+    try {
+        const parameterCount = beforeLookups + lookupParameters + indexParameters + upParameters;
+        collectFinds(program.body);
+        /** Leaves 1 if any filter's tick at `(row >> shift) * 8` in its `parameter` array is newer than `lastRun`. */
+        const anyNewer = (parameter, shift) => {
+            for (let filter = 0; filter < filters; filter++) {
+                code.push(op.localGet, ...unsigned(parameter(filter)), op.localGet, ...unsigned(rowLocal));
+                if (shift > 0)
+                    code.push(op.i32Const, ...signed(shift), op.i32ShrU);
+                code.push(op.i32Const, 3, op.i32Shl, op.i32Add, op.f64Load, 3, 0, op.localGet, 3, op.f64Gt);
+                if (filter > 0)
+                    code.push(op.i32Or);
+            }
+        };
+        /**
+         * i32 locals: the row after the current chunk; the row after the current run of passing blocks, both `start`
+         * before the first; the current chunk's blocks that pass, a bit each; and two temporaries.
+         */
+        let chunkEnd = 0;
+        let blockEnd = 0;
+        let passingBlocks = 0;
+        let ahead = 0;
+        let skipped = 0;
+        const startChunksAndBlocks = () => {
+            chunkEnd = scratch(i32Type);
+            blockEnd = scratch(i32Type);
+            passingBlocks = scratch(i32Type);
+            ahead = scratch(i32Type);
+            skipped = scratch(i32Type);
+            code.push(op.localGet, 0, op.localTee, ...unsigned(chunkEnd), op.localSet, ...unsigned(blockEnd));
+        };
+        const get = (local) => [op.localGet, ...unsigned(local)];
+        const set = (local) => [op.localSet, ...unsigned(local)];
+        /** Leaves `min(end, ((row >> shift) + count) << shift)`, with `count` on the stack first. */
+        const runEnd = (shift, target) => {
+            code.push(...get(rowLocal), op.i32Const, ...signed(shift), op.i32ShrU, op.i32Add, op.i32Const, ...signed(shift), op.i32Shl, ...set(target));
+            code.push(...get(target), op.localGet, 1, ...get(target), op.localGet, 1, op.i32LtS, op.select, ...set(target));
+        };
+        const blocksPerChunk = 2 ** (chunkShift - blockShift);
+        /**
+         * In the outer row loop, at `row`, the first row after the last run of passing blocks: past the current chunk,
+         * skips chunks no filter's chunk tick says changed, and notes which blocks of the next one pass, a bit each;
+         * then skips the blocks that don't pass, and sets `blockEnd` to the end of the run of blocks that do, which the
+         * inner loop runs. A chunk with more than half its blocks passing is one run: ending a run costs more than the
+         * eight-row checks spend on a block between runs.
+         */
+        const findRun = () => {
+            code.push(...get(rowLocal), ...get(chunkEnd), op.i32GeS, op.if, 0x40);
+            code.push(op.i32Const, 1);
+            runEnd(chunkShift, chunkEnd);
+            anyNewer(filterChunkParameter, chunkShift);
+            code.push(op.i32Eqz, op.if, 0x40, ...get(chunkEnd), ...set(rowLocal), op.br, 2, op.end);
+            // The chunk's blocks that pass, from its first block, `(row >> chunkShift) << (chunkShift - blockShift)`.
+            for (let block = 0; block < blocksPerChunk; block++) {
+                for (let filter = 0; filter < filters; filter++) {
+                    code.push(...get(filterBlockParameter(filter)), ...get(rowLocal), op.i32Const, ...signed(chunkShift), op.i32ShrU, op.i32Const, ...signed(chunkShift - blockShift), op.i32Shl);
+                    code.push(op.i32Const, ...signed(block), op.i32Add, op.i32Const, 3, op.i32Shl, op.i32Add, op.f64Load, 3, 0, op.localGet, 3, op.f64Gt);
+                    if (filter > 0)
+                        code.push(op.i32Or);
+                }
+                if (block > 0)
+                    code.push(op.i32Const, ...signed(block), op.i32Shl, ...get(passingBlocks), op.i32Or);
+                code.push(...set(passingBlocks));
+            }
+            code.push(...get(passingBlocks), op.i32Popcnt, op.i32Const, ...signed(blocksPerChunk / 2), op.i32GtS, op.if, 0x40);
+            code.push(op.i32Const, ...signed((2 ** blocksPerChunk - 1) | 0), ...set(passingBlocks), op.end);
+            code.push(op.end);
+            // ahead = passingBlocks >> (row's block in its chunk); none ahead skips the rest of the chunk.
+            code.push(...get(passingBlocks), ...get(rowLocal), op.i32Const, ...signed(blockShift), op.i32ShrU, op.i32Const, ...signed(blocksPerChunk - 1), op.i32And, op.i32ShrU, op.localTee, ...unsigned(ahead));
+            code.push(op.i32Eqz, op.if, 0x40, ...get(chunkEnd), ...set(rowLocal), op.br, 1, op.end);
+            // Skips to the next passing block, then runs to the end of the passing blocks after it.
+            code.push(...get(ahead), op.i32Ctz, op.localTee, ...unsigned(skipped), op.if, 0x40);
+            code.push(...get(skipped), ...get(rowLocal), op.i32Const, ...signed(blockShift), op.i32ShrU, op.i32Add, op.i32Const, ...signed(blockShift), op.i32Shl, ...set(rowLocal));
+            code.push(op.end);
+            code.push(...get(ahead), ...get(skipped), op.i32ShrU, op.i32Const, ...signed(-1), op.i32Xor, op.i32Ctz);
+            runEnd(blockShift, blockEnd);
+            code.push(...get(blockEnd), ...get(chunkEnd), ...get(blockEnd), ...get(chunkEnd), op.i32LtS, op.select, ...set(blockEnd));
+            // A row moved to a later block goes round the outer loop, which checks it against `end`.
+            code.push(...get(skipped), op.brIf, 0);
+        };
+        /** Rows an eight-row skip checks at once: four f64x2 loads of each filter's row ticks. */
+        const eightRows = 8;
+        /**
+         * With SIMD, at a row that's a multiple of `eightRows`, skips that many rows when none passes a filter, testing
+         * two ticks per comparison. Only aligned rows check, so rows that do pass pay one check per eight.
+         */
+        const skipEights = () => {
+            code.push(op.localGet, ...unsigned(rowLocal), op.i32Const, eightRows - 1, op.i32And, op.i32Eqz);
+            code.push(op.localGet, ...unsigned(rowLocal), op.i32Const, eightRows, op.i32Add, op.localGet, 1, op.i32LeS, op.i32And, op.if, 0x40);
+            for (let filter = 0; filter < filters; filter++) {
+                for (let pair = 0; pair < eightRows / 2; pair++) {
+                    code.push(op.localGet, ...unsigned(filterRowParameter(filter)), op.localGet, ...unsigned(rowLocal), op.i32Const, 3, op.i32Shl, op.i32Add);
+                    code.push(...simd(vop.load), 3, ...unsigned(16 * pair), op.localGet, 3, ...simd(vop.f64Splat), ...simd(vop.f64Gt));
+                    if (filter > 0 || pair > 0)
+                        code.push(...simd(vop.or));
+                }
+            }
+            code.push(...simd(vop.anyTrue), op.i32Eqz, op.if, 0x40);
+            code.push(op.localGet, ...unsigned(rowLocal), op.i32Const, eightRows, op.i32Add, op.localSet, ...unsigned(rowLocal));
+            code.push(op.br, 2, op.end, op.end);
+        };
+        // Scalars are discovered while generating, so code is generated first with locals placed after a provisional scalar count.
+        /** `rows`: four rows at a time where every column is dense; `lanes`: fuse statements within each row. */
+        let fused = false;
+        const generate = (scalarCount, mode) => {
+            code.length = 0;
+            extraLocals.length = 0;
+            rowsLocals.length = 0;
+            // With reductions, the partials' address follows the scalars.
+            const partialsParameter = parameterCount + scalarCount;
+            localBase = partialsParameter + (accumulators.length > 0 ? 1 : 0);
+            rowLocal = scratch(i32Type);
+            code.push(op.localGet, 0, op.localSet, ...unsigned(rowLocal));
+            hoisted.clear();
+            hoist(program.body);
+            accumulators.forEach((accumulator, k) => {
+                code.push(op.localGet, ...unsigned(partialsParameter), op.f64Load, 3, ...unsigned(8 * k), op.localSet, ...unsigned(local(accumulator)));
+            });
+            // Floating-point folds wait on the one before, so consecutive rows fold into one of four lanes in turn:
+            // the accumulator, rotated with three more starting at the identity, then combined in a fixed order.
+            const lanes = accumulators.map((_, k) => {
+                const operator = operators[k];
+                const identity = rotated[operator];
+                if (identity === undefined)
+                    return null;
+                return [0, 1, 2].map(() => {
+                    const lane = scratch(f64Type);
+                    code.push(op.f64Const, ...float64(identity.value), op.localSet, ...unsigned(lane));
+                    return lane;
+                });
+            });
+            handleLocals.clear();
+            keyLocals.clear();
+            if (lookupParameters > 0)
+                convertLookupParameters();
+            if (indexParameters > 0)
+                convertIndexParameters();
+            stampRangeChunks();
+            if (filters > 0)
+                startChunksAndBlocks();
+            if (mode === "rows")
+                rowsLoop();
+            let across = false;
+            if (mode === "lanes") {
+                const plan = planLanes();
+                across = acrossElements(plan);
+                if (across)
+                    elementsLoop(plan);
+            }
+            // for (; row < end; row++) { block next { body } }, where with `up` the row and its parent's are rows[n] and parents[n].
+            const slot = rowLocal;
+            if (upMode) {
+                rowLocal = scratch(i32Type);
+                parentLocal = scratch(i32Type);
+            }
+            code.push(op.block, 0x40, op.loop, 0x40);
+            code.push(op.localGet, ...unsigned(slot), op.localGet, 1, op.i32GeS, op.brIf, 1);
+            // With change filters, an outer loop finds each run of passing blocks and an inner one runs its rows.
+            if (filters > 0) {
+                findRun();
+                code.push(op.block, 0x40, op.loop, 0x40, ...get(rowLocal), ...get(blockEnd), op.i32GeS, op.brIf, 1);
+            }
+            if (upMode) {
+                code.push(op.localGet, ...unsigned(upParameter(0)), op.localGet, ...unsigned(slot), op.i32Const, 2, op.i32Shl, op.i32Add, op.i32Load, 2, 0, op.localSet, ...unsigned(rowLocal));
+                code.push(op.localGet, ...unsigned(upParameter(1)), op.localGet, ...unsigned(slot), op.i32Const, 2, op.i32Shl, op.i32Add, op.i32Load, 2, 0, op.localSet, ...unsigned(parentLocal));
+            }
+            if (filters > 0 && simdEnabled && !upMode)
+                skipEights();
+            code.push(op.block, 0x40);
+            // A row that no filter passes goes to the next.
+            if (filters > 0) {
+                anyNewer(filterRowParameter, 0);
+                code.push(op.i32Eqz, op.brIf, 0);
+            }
+            labels.length = 0;
+            labels.push("next");
+            // f64 lanes fuse only across rows: within a row the rest run as scalars, as the body computes.
+            if (mode === "lanes" && !wide)
+                fused = emitLaneBody();
+            else {
+                if (mode === "lanes")
+                    fused = across;
+                for (const current of program.body)
+                    statement(current);
+            }
+            labels.pop();
+            code.push(op.end);
+            accumulators.forEach((accumulator, k) => {
+                const extra = lanes[k];
+                if (extra === null)
+                    return;
+                const [first, second, third] = extra;
+                const own = unsigned(local(accumulator));
+                code.push(op.localGet, ...own, op.localGet, ...unsigned(first), op.localSet, ...own);
+                code.push(op.localGet, ...unsigned(second), op.localSet, ...unsigned(first), op.localGet, ...unsigned(third), op.localSet, ...unsigned(second));
+                code.push(op.localSet, ...unsigned(third));
+            });
+            code.push(op.localGet, ...unsigned(slot), op.i32Const, 1, op.i32Add, op.localSet, ...unsigned(slot), op.br, 0);
+            code.push(op.end, op.end);
+            if (filters > 0)
+                code.push(op.br, 0, op.end, op.end);
+            rowLocal = slot;
+            accumulators.forEach((accumulator, k) => {
+                const extra = lanes[k];
+                if (extra === null)
+                    return;
+                const combine = rotated[operators[k]].combine;
+                const [first, second, third] = extra;
+                const own = unsigned(local(accumulator));
+                code.push(op.localGet, ...own, op.localGet, ...unsigned(first), combine, op.localGet, ...unsigned(second), op.localGet, ...unsigned(third), combine, combine, op.localSet, ...own);
+            });
+            accumulators.forEach((accumulator, k) => {
+                code.push(op.localGet, ...unsigned(partialsParameter), op.localGet, ...unsigned(local(accumulator)), op.f64Store, 3, ...unsigned(8 * k));
+            });
+            // The function's end.
+            code.push(op.end);
+        };
+        // Across-rows mode doesn't filter rows, so filtered kernels fuse within rows instead.
+        // Accumulators carry from row to row, which neither SIMD mode keeps.
+        // Listed rows aren't consecutive, so `up` programs run one row at a time.
+        // Within a row, f64 lanes would split a component's leaves across vectors, so filtered kernels at the body's
+        // precision run one row at a time.
+        let mode = !simdEnabled || accumulators.length > 0 || upMode || (wide && filters > 0) ? "scalar" : filters > 0 ? "lanes" : "rows";
+        try {
+            generate(0, mode);
+        }
+        catch (error) {
+            if (error !== notVectorizable)
+                throw error;
+            mode = "lanes";
+            generate(0, mode);
+        }
+        if (mode === "lanes" && !fused) {
+            mode = "scalar";
+            generate(0, mode);
+        }
+        const discovered = scalars.length;
+        generate(discovered, mode);
+        if (scalars.length !== discovered)
+            throw unsupported("its resource and input values differ between passes");
+        const vectorized = mode !== "scalar";
+        /** The custom section naming the function, its imports, and each parameter and local the generator knows the role of. */
+        const nameSection = () => {
+            const parameterNames = ["start", "end", "tick", "lastRun", ...columns.map((_, k) => `c${k}`)];
+            for (const part of ["Rows", "Chunks", "Blocks"])
+                for (let filter = 0; filter < filters; filter++)
+                    parameterNames.push(`filter${filter}${part}`);
+            if (lookupParameters > 0) {
+                parameterNames.push("entityArchetypes", "entityRows", "entityGenerations", "entityCount");
+                lookups.forEach((_, k) => parameterNames.push(`l${k}Directory`, `l${k}Records`));
+                if (watching)
+                    parameterNames.push("lookupsSince");
+            }
+            for (let lookup = 0; lookup < lookups.length; lookup++) {
+                const index = indexLookups[lookup];
+                if (index !== null && index !== undefined)
+                    for (let k = 0; k < indexParameterCount(index); k++)
+                        parameterNames.push(`l${lookup}Index${k}`);
+            }
+            if (upMode)
+                parameterNames.push("rows", "parents", "found", ...upColumns.map((_, k) => `u${k}`));
+            for (const scalar of scalars)
+                parameterNames.push(identifierOf(scalar.source === "args" ? ["input", ...scalar.path].join("_") : [`${scalar.source === "shared" ? "shared" : "r"}${scalar.index}`, ...scalar.path].join("_")));
+            if (accumulators.length > 0)
+                parameterNames.push("partials");
+            const localNames = [
+                ...parameterNames,
+                ...Array.from({ length: program.locals }, (_, k) => identifierOf(program.names?.[k] ?? `t_${k}`)),
+                ...extraLocals.map((_, k) => k === 0 ? "row" : `s${k}`),
+            ];
+            const functions = [...imports.map((functionName, k) => [...unsigned(k), ...name(functionName)]), [...unsigned(imports.length), ...name("run")]];
+            const locals = [[...unsigned(imports.length), ...vector(localNames.map((localName, k) => [...unsigned(k), ...name(localName)]))]];
+            // Subsections have a section's form: function names (1), then local names (2).
+            return section(0, [...name("name"), ...section(1, vector(functions)), ...section(2, vector(locals))]);
+        };
+        const parameterTypes = [i32Type, i32Type, f64Type, f64Type, ...columns.map(() => i32Type), ...new Array(3 * filters).fill(i32Type), ...new Array(lookupParameters).fill(f64Type), ...new Array(indexParameters).fill(f64Type), ...new Array(upParameters).fill(i32Type), ...scalars.map(() => f64Type), ...accumulators.length > 0 ? [i32Type] : []];
+        const localTypesList = [...new Array(program.locals).fill(f64Type)];
+        // Locals in order: program locals, then extras in creation order; the row index was the first extra.
+        const declared = [...localTypesList.map(type => [1, type]), ...extraLocals.map(type => [1, type])];
+        const body = [...vector(declared.map(([count, type]) => [...unsigned(count), type])), ...code];
+        const types = [
+            [0x60, ...vector(parameterTypes.map(type => [type])), ...vector([])],
+            [0x60, ...vector([[f64Type], [f64Type]]), ...vector([[f64Type]])],
+        ];
+        const importEntries = [
+            [...name("env"), ...name("memory"), 0x02, 0x03, ...unsigned(1), ...unsigned(65536)],
+            ...imports.map(functionName => [...name("math"), ...name(functionName), 0x00, ...unsigned(1)]),
+        ];
+        const bytes = new Uint8Array([
+            0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00,
+            ...section(1, vector(types)),
+            ...section(2, vector(importEntries)),
+            ...section(3, vector([unsigned(0)])),
+            ...section(7, vector([[...name("run"), 0x00, ...unsigned(imports.length)]])),
+            ...section(10, vector([[...unsigned(body.length), ...body]])),
+            ...named ? nameSection() : [],
+        ]);
+        return { bytes, scalars, imports, vectorized };
+    }
+    catch (error) {
+        const reason = typeof error === "object" && error !== null ? reasons.get(error) : undefined;
+        if (reason !== undefined)
+            return reason;
+        throw error;
+    }
+};
+//# sourceMappingURL=wasm.js.map