@adobe/ecs 0.1.0 → 0.2.1

package/dist/implementation/world/wasm.js

@@ -1,5 +1,8 @@
-import { chunkShift } from './kernel.js';
+// © 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. */
@@ -9,15 +12,20 @@ const operations = {
     remainder: (a, b) => a % b,
     power: (a, b) => a ** b,
 };
-/** Reads a scalar parameter's value from the resources and args of a run; booleans become 0 or 1. */
-export const scalarValue = (scalar, resources, args) => {
-    let value = scalar.source === "args" ? args : resources[scalar.index];
+/** 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. */
-export const scalarValues = (scalars, resources, args) => scalars.map(scalar => scalarValue(scalar, resources, args));
+/** 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;
@@ -47,7 +55,7 @@ const op = {
     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, i32Add: 0x6a, i32Sub: 0x6b, i32Mul: 0x6c, i32And: 0x71, i32Or: 0x72, i32Xor: 0x73, i32Shl: 0x74, i32ShrS: 0x75, i32ShrU: 0x76,
+    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,
@@ -85,8 +93,16 @@ const name = (text) => {
 };
 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; the JS kernel is used instead. */
-const unsupported = Symbol("unsupported");
+/**
+ * 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";
@@ -103,7 +119,17 @@ const rotated = {
  *
  * The exported `run(start, end, tick, ...columnAddresses, ...scalars)` processes rows `start` to `end`.
  */
-export const generateWasm = (source, columns, scalarTypes, simdEnabled = true, filters = 0, lookups = [], 
+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. */
@@ -111,7 +137,12 @@ 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 = []) => {
+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();
@@ -121,7 +152,7 @@ probeLookups = []) => {
         let index = scalarIndex.get(key);
         if (index === undefined) {
             if (scalarTypes(scalar) === null)
-                throw unsupported;
+                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);
@@ -145,7 +176,7 @@ probeLookups = []) => {
     const claim = (handle, lookup) => {
         const existing = lookupOfHandle.get(handle);
         if ((existing !== undefined && existing !== lookup) || lookup >= lookups.length)
-            throw unsupported;
+            throw unsupported("it reads one lookup's result through another lookup");
         lookupOfHandle.set(handle, lookup);
     };
     /** Each probe's lookup, by the probe's index. */
@@ -157,14 +188,14 @@ probeLookups = []) => {
             else if (statement.kind === "probe") {
                 const lookup = lookupOfProbe.get(statement.probe);
                 if (lookup === undefined || indexLookups[lookup] === null || indexLookups[lookup] === undefined)
-                    throw unsupported;
+                    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;
+                    throw unsupported("it reads a row of a list no lookup gave");
                 claim(statement.row, lookup);
             }
             else if (statement.kind === "if") {
@@ -183,7 +214,8 @@ probeLookups = []) => {
             case "boolean": return "boolean";
             case "column": return columns[expression.column].boolean ? "boolean" : "number";
             case "resource":
-            case "args": return scalarTypes(expression.kind === "args" ? { source: "args", path: expression.path } : { source: "resource", index: expression.index, path: expression.path }) ?? "mixed";
+            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";
@@ -209,7 +241,7 @@ probeLookups = []) => {
                 return leaf?.column.boolean === true ? "boolean" : "number";
             }
             // Regions are inlined before generating.
-            case "lane": throw unsupported;
+            case "lane": throw unsupported("it reads a GPU builtin's lane");
         }
     };
     const inferLocals = (statements) => {
@@ -268,18 +300,24 @@ probeLookups = []) => {
     };
     while (inferIntegral(program.body))
         ;
-    // Parameters: start, end, tick, lastRun, column addresses, filter row tick addresses, filter chunk tick addresses, scalars, and with reductions the partials address.
+    // 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) => 4 + columns.length + 2 * filters + index;
+    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 = [];
@@ -290,11 +328,16 @@ probeLookups = []) => {
         if (index !== null && index !== undefined)
             indexParameters += indexParameterCount(index);
     }
-    const indexParameter = (lookup, index) => 4 + columns.length + 2 * filters + lookupParameters + indexOffsets[lookup] + index;
-    const upParameter = (index) => 4 + columns.length + 2 * filters + lookupParameters + indexParameters + index;
-    const scalarParameter = (index) => 4 + columns.length + 2 * filters + lookupParameters + indexParameters + upParameters + 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) => {
@@ -327,6 +370,11 @@ probeLookups = []) => {
         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));
@@ -338,9 +386,9 @@ probeLookups = []) => {
                 code.push(op.localGet, ...unsigned(local(expression.local)));
                 return;
             case "resource":
-            case "args": {
-                const scalar = expression.kind === "args" ? { source: "args", path: expression.path } : { source: "resource", index: expression.index, path: expression.path };
-                code.push(op.localGet, ...unsigned(scalarParameter(scalarOf(scalar))));
+            case "args":
+            case "shared": {
+                code.push(op.localGet, ...unsigned(scalarParameter(scalarOf(scalarOfExpression(expression)))));
                 return;
             }
             case "upFound":
@@ -434,7 +482,7 @@ probeLookups = []) => {
         if (!native.has(functionName)) {
             // Imported functions take two f64s; unary ones ignore the second.
             if (parameters.length > 2)
-                throw unsupported;
+                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++)
@@ -477,7 +525,7 @@ probeLookups = []) => {
                 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;
+                    throw unsupported(`it calls Math.${functionName}, which WASM has no instruction for`);
                 code.push(unary);
             }
         }
@@ -491,7 +539,7 @@ probeLookups = []) => {
             const leftType = typeOf(left);
             const rightType = typeOf(right);
             if (leftType === "mixed" || rightType === "mixed")
-                throw unsupported;
+                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));
@@ -505,6 +553,19 @@ probeLookups = []) => {
             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);
@@ -535,7 +596,7 @@ probeLookups = []) => {
             if (labels[i] === "program" && ++seen === depth)
                 return labels.length - 1 - i;
         }
-        throw unsupported;
+        throw unsupported("it branches to a block that isn't there");
     };
     const store = (column, value) => {
         const { view, offset } = columns[column];
@@ -564,32 +625,37 @@ probeLookups = []) => {
         }
     };
     /**
-     * Chunk columns stamped by every row: top-level stamps with no `next` before them, in an unfiltered kernel.
-     * Their chunks are stamped once per call, for the whole range, instead of on each row.
+     * 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 Set();
-    // Listed rows needn't be consecutive, so each stamps its own chunk.
+    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" && columns[statement.chunks].muted !== true)
-                everyRow.add(statement.chunks);
+            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 from `start`'s to `end - 1`'s, for the chunk columns every row stamps. */
+    /** 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 chunks of everyRow) {
+        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++) chunks[chunk] = tick
+            // 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(chunkShift), op.i32ShrU, op.localSet, ...unsigned(chunk));
-            code.push(op.localGet, 1, op.i32Const, 1, op.i32Sub, op.i32Const, ...signed(chunkShift), op.i32ShrU, op.localSet, ...unsigned(last));
+            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(chunks)), op.localGet, ...unsigned(chunk), op.i32Const, 3, op.i32Shl, op.i32Add, op.localGet, 2, op.f64Store, 3, 0);
+            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);
         }
@@ -695,13 +761,13 @@ probeLookups = []) => {
         const lookup = lookupOfHandle.get(handle);
         if (lookup !== undefined && isChanged(lookup, read)) {
             if (path.length > 0)
-                throw unsupported;
+                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;
+            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");
@@ -761,7 +827,7 @@ probeLookups = []) => {
         const lookup = lookupOfHandle.get(handle);
         const index = lookup === undefined ? undefined : indexLookups[lookup];
         if (lookup === undefined || index === null || index === undefined)
-            throw unsupported;
+            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. */
@@ -946,13 +1012,13 @@ probeLookups = []) => {
         const { lookup, index } = indexOf(list);
         const plan = index.probe(probe);
         if (plan === null)
-            throw unsupported;
+            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;
+                    throw unsupported("it looks up an index with fewer values than its key has");
                 emit(value);
                 encodeKey(lookup, target);
             }
@@ -1042,7 +1108,7 @@ probeLookups = []) => {
                             emitBound(lookup, index, comparison.words, false, unequalLow, list);
                             emitBound(lookup, index, comparison.words, true, unequalHigh, list);
                             break;
-                        default: throw unsupported;
+                        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.
@@ -1196,7 +1262,7 @@ probeLookups = []) => {
         const { index } = indexOf(row);
         const found = index.rowLeaf(leaf);
         if (found === null)
-            throw unsupported;
+            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);
     };
@@ -1204,14 +1270,17 @@ probeLookups = []) => {
         indexOf(row);
         emitRecordLeaf(row, 1, { view: "f64", stride: 8, offset: 0, boolean: false });
     };
-    /** Sets the chunk tick of the row `rowOffset` rows past the current one, unless every row's chunk is stamped up front. */
-    const stampChunk = (chunks, rowOffset) => {
-        if (everyRow.has(chunks))
+    /**
+     * 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(chunks)), op.localGet, ...unsigned(rowLocal));
+        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(chunkShift), op.i32ShrU, op.i32Const, 3, op.i32Shl, op.i32Add, op.localGet, 2, op.f64Store, 3, 0);
+        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) {
@@ -1224,9 +1293,9 @@ probeLookups = []) => {
             case "stamp":
                 if (columns[current.column].muted !== true)
                     store(current.column, "tick");
-                if (columns[current.chunks].muted === true)
-                    return;
-                return stampChunk(current.chunks, 0);
+                stampDense(current.blocks, blockShift, 0);
+                stampDense(current.chunks, chunkShift, 0);
+                return;
             case "if":
                 emit(current.test);
                 emitTruthy(typeOf(current.test));
@@ -1267,7 +1336,7 @@ probeLookups = []) => {
             case "listRow": return emitListRow(current.row, current.list, current.index);
         }
     };
-    // ---- SIMD. Lanes compute in f32, at storage precision, so results may differ from the scalar path in the last bit. ----
+    // ---- 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 = {
@@ -1275,37 +1344,75 @@ probeLookups = []) => {
         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,
-        f32Ceil: 103, f32Floor: 104, f32Trunc: 105, i64ExtendLowS: 199, i64ExtendHighS: 200,
+        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) => [...simd(vop.const), ...[0, 1, 2, 3].flatMap(lane => float32(values[lane] ?? 0))];
+    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 = { "+": vop.f32Add, "-": vop.f32Sub, "*": vop.f32Mul, "/": vop.f32Div };
-    const unaryVector = { abs: vop.f32Abs, sqrt: vop.f32Sqrt, floor: vop.f32Floor, ceil: vop.f32Ceil, trunc: vop.f32Trunc };
+    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, as a lane computes. */
+    /** 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);
-        code.push(op.f32DemoteF64, ...simd(vop.f32Splat));
+        if (wide)
+            code.push(...simd(vop.f64Splat));
+        else
+            code.push(op.f32DemoteF64, ...simd(vop.f32Splat));
     };
-    /** `Math` functions with an f32x4 equivalent; `fround` is the identity in f32. */
+    /** `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(functionName === "min" ? vop.f32Min : vop.f32Max));
+                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, for straight-line programs whose columns are all dense f32. ----
+    // ---- 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)
@@ -1314,12 +1421,12 @@ probeLookups = []) => {
     };
     const vectorTruthy = (type) => {
         if (type === "boolean") {
-            code.push(...splatConstant(0), ...simd(vop.f32Ne));
+            code.push(...splatConstant(0), ...simd(comparisonVector["!="] ?? vop.f32Ne));
             return;
         }
         const value = scratch(v128Type);
-        code.push(op.localTee, ...unsigned(value), ...splatConstant(0), ...simd(vop.f32Ne));
-        code.push(op.localGet, ...unsigned(value), op.localGet, ...unsigned(value), ...simd(vop.f32Eq), ...simd(vop.and));
+        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 = () => {
@@ -1337,15 +1444,16 @@ probeLookups = []) => {
                 code.push(op.localGet, ...unsigned(rowsLocal(expression.local)));
                 return;
             case "resource":
-            case "args": return emitSplat(expression);
+            case "args":
+            case "shared": return emitSplat(expression);
             case "column":
                 denseAddress(expression.column);
-                code.push(...simd(vop.load), 2, ...unsigned(columns[expression.column].offset));
+                loadLanes(columns[expression.column].offset);
                 return;
             case "unary":
                 rowsEmit(expression.operand);
                 if (expression.operator === "-")
-                    code.push(...simd(vop.f32Neg));
+                    code.push(...simd(negateVector));
                 else if (expression.operator === "!") {
                     vectorTruthy(typeOf(expression.operand));
                     code.push(...simd(vop.not));
@@ -1360,13 +1468,13 @@ probeLookups = []) => {
                     const leftType = typeOf(left);
                     const rightType = typeOf(right);
                     if (leftType === "mixed" || rightType === "mixed")
-                        throw unsupported;
+                        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 = { "<": vop.f32Lt, ">": vop.f32Gt, "<=": vop.f32Le, ">=": vop.f32Ge, "==": vop.f32Eq, "!=": vop.f32Ne, "===": vop.f32Eq, "!==": vop.f32Ne }[operator];
+                const comparison = comparisonVector[operator];
                 if (!isArithmetic(operator) && comparison === undefined)
                     throw notVectorizable;
                 rowsEmit(left);
@@ -1448,29 +1556,34 @@ probeLookups = []) => {
                 }
                 code.push(op.localSet, ...unsigned(value));
                 denseAddress(current.column);
-                code.push(op.localGet, ...unsigned(value), ...simd(vop.store), 2, ...unsigned(columns[current.column].offset));
+                code.push(op.localGet, ...unsigned(value));
+                storeLanes(columns[current.column].offset);
                 return;
             }
             case "stamp": {
-                // Ticks are dense f64: four rows are two f64x2 stores; a chunk column stays when its row column is muted.
+                // 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 < 2; half++) {
+                    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), ...simd(half === 0 ? vop.i64ExtendLowS : vop.i64ExtendHighS), ...simd(vop.bitselect));
+                            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));
                     }
                 }
-                if (columns[current.chunks].muted === true)
-                    return;
-                // The group may straddle two chunks. Under a mask this can stamp a chunk no lane changed, which only costs a scan.
-                stampChunk(current.chunks, 0);
-                stampChunk(current.chunks, 3);
+                // 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": {
@@ -1504,16 +1617,17 @@ probeLookups = []) => {
             default: throw notVectorizable;
         }
     };
-    /** Rows from `start` in groups of four, up to the last whole group; leaves the row local at the first row not done. */
+    /** 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(-4), op.i32And, op.localGet, 0, op.i32Add, op.localSet, ...unsigned(vectorEnd));
+        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, 4, op.i32Add, op.localSet, ...unsigned(rowLocal), op.br, 0);
+        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. */
@@ -1797,7 +1911,7 @@ probeLookups = []) => {
                 return;
             case "negate":
                 emitVectorExpression(expression.operand);
-                code.push(...simd(vop.f32Neg));
+                code.push(...simd(negateVector));
                 return;
             case "math":
                 for (const parameter of expression.arguments)
@@ -1831,13 +1945,89 @@ probeLookups = []) => {
         }
         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": return true;
+            case "args":
+            case "shared": return true;
             case "unary": return rowIndependent(expression.operand);
             case "binary":
             case "logical": return rowIndependent(expression.left) && rowIndependent(expression.right);
@@ -1893,10 +2083,10 @@ probeLookups = []) => {
             }
             case "load":
                 elementAddress(expression.column);
-                code.push(...simd(vop.load), 2, ...unsigned(16 * vector));
+                loadLanes(laneBytes * vector);
                 return;
             case "constant":
-                code.push(...vectorConstant([0, 1, 2, 3].map(lane => expression.values[((16 * vector + 4 * lane) % stride) / 4])));
+                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":
@@ -1906,7 +2096,7 @@ probeLookups = []) => {
                 return;
             case "negate":
                 emitElementExpression(expression.operand, vector, stride, packVectors);
-                code.push(...simd(vop.f32Neg));
+                code.push(...simd(negateVector));
                 return;
             case "math":
                 for (const parameter of expression.arguments)
@@ -1921,6 +2111,8 @@ probeLookups = []) => {
      * 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);
@@ -1931,23 +2123,25 @@ probeLookups = []) => {
         for (let index = 0; index < body.length; index++) {
             const pack = packs.get(index);
             if (pack?.used === true) {
-                const vectors = Array.from({ length: columns[pack.column].stride / 4 }, (_, vector) => {
+                const locals = Array.from({ length: vectors(columns[pack.column].stride) }, (_, vector) => {
                     const local = scratch(v128Type);
                     elementAddress(pack.column);
-                    code.push(...simd(vop.load), 2, ...unsigned(16 * vector), op.localSet, ...unsigned(local));
+                    loadLanes(laneBytes * vector);
+                    code.push(op.localSet, ...unsigned(local));
                     return local;
                 });
-                packVectors.set(pack, vectors);
+                packVectors.set(pack, locals);
             }
             const group = groups.get(index);
             if (group !== undefined) {
                 const { stride } = columns[group.column];
-                for (let vector = 0; vector < stride / 4; vector++) {
+                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), ...simd(vop.store), 2, ...unsigned(16 * vector));
+                    code.push(op.localGet, ...unsigned(value));
+                    storeLanes(laneBytes * vector);
                 }
                 index += group.length - 1;
             }
@@ -1958,7 +2152,7 @@ probeLookups = []) => {
         code.push(op.end, op.end);
     };
     try {
-        const parameterCount = 4 + columns.length + 2 * filters + lookupParameters + indexParameters + upParameters;
+        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) => {
@@ -1971,29 +2165,83 @@ probeLookups = []) => {
                     code.push(op.i32Or);
             }
         };
-        /** At a chunk's first row, skips the whole chunk unless a filter's chunk tick is newer. */
-        const skipChunks = () => {
-            const next = scratch(i32Type);
-            code.push(op.localGet, ...unsigned(rowLocal), op.localGet, 0, op.i32Eq, op.localGet, ...unsigned(rowLocal), op.i32Const, ...signed(2 ** chunkShift - 1), op.i32And, op.i32Eqz, op.i32Or);
-            code.push(op.if, 0x40);
+        /**
+         * 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);
-            // row = min(end, start of the next chunk)
-            code.push(op.localGet, ...unsigned(rowLocal), op.i32Const, ...signed(chunkShift), op.i32ShrU, op.i32Const, 1, op.i32Add, op.i32Const, ...signed(chunkShift), op.i32Shl, op.localSet, ...unsigned(next));
-            code.push(op.localGet, ...unsigned(next), op.localGet, 1, op.localGet, ...unsigned(next), op.localGet, 1, op.i32LtS, op.select, op.localSet, ...unsigned(rowLocal));
-            code.push(op.br, 2, op.end, op.end);
+            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 a block skip checks at once: four f64x2 loads of each filter's row ticks. */
-        const blockRows = 8;
+        /** 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 `blockRows`, 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 block.
+         * 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 skipBlocks = () => {
-            code.push(op.localGet, ...unsigned(rowLocal), op.i32Const, blockRows - 1, op.i32And, op.i32Eqz);
-            code.push(op.localGet, ...unsigned(rowLocal), op.i32Const, blockRows, op.i32Add, op.localGet, 1, op.i32LeS, op.i32And, op.if, 0x40);
+        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 < blockRows / 2; pair++) {
+                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)
@@ -2001,7 +2249,7 @@ probeLookups = []) => {
                 }
             }
             code.push(...simd(vop.anyTrue), op.i32Eqz, op.if, 0x40);
-            code.push(op.localGet, ...unsigned(rowLocal), op.i32Const, blockRows, op.i32Add, op.localSet, ...unsigned(rowLocal));
+            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.
@@ -2016,6 +2264,8 @@ probeLookups = []) => {
             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)));
             });
@@ -2039,11 +2289,15 @@ probeLookups = []) => {
             if (indexParameters > 0)
                 convertIndexParameters();
             stampRangeChunks();
+            if (filters > 0)
+                startChunksAndBlocks();
             if (mode === "rows")
                 rowsLoop();
+            let across = false;
             if (mode === "lanes") {
                 const plan = planLanes();
-                if (acrossElements(plan))
+                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].
@@ -2054,14 +2308,17 @@ probeLookups = []) => {
             }
             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)
-                skipChunks();
             if (filters > 0 && simdEnabled && !upMode)
-                skipBlocks();
+                skipEights();
             code.push(op.block, 0x40);
             // A row that no filter passes goes to the next.
             if (filters > 0) {
@@ -2070,11 +2327,15 @@ probeLookups = []) => {
             }
             labels.length = 0;
             labels.push("next");
-            if (mode === "lanes")
+            // 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
+            else {
+                if (mode === "lanes")
+                    fused = across;
                 for (const current of program.body)
                     statement(current);
+            }
             labels.pop();
             code.push(op.end);
             accumulators.forEach((accumulator, k) => {
@@ -2089,6 +2350,8 @@ probeLookups = []) => {
             });
             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];
@@ -2108,7 +2371,9 @@ probeLookups = []) => {
         // 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.
-        let mode = !simdEnabled || accumulators.length > 0 || upMode ? "scalar" : filters > 0 ? "lanes" : "rows";
+        // 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);
         }
@@ -2125,9 +2390,43 @@ probeLookups = []) => {
         const discovered = scalars.length;
         generate(discovered, mode);
         if (scalars.length !== discovered)
-            throw unsupported;
+            throw unsupported("its resource and input values differ between passes");
         const vectorized = mode !== "scalar";
-        const parameterTypes = [i32Type, i32Type, f64Type, f64Type, ...columns.map(() => i32Type), ...new Array(2 * 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] : []];
+        /** 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])];
@@ -2147,12 +2446,14 @@ probeLookups = []) => {
             ...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) {
-        if (error === unsupported)
-            return null;
+        const reason = typeof error === "object" && error !== null ? reasons.get(error) : undefined;
+        if (reason !== undefined)
+            return reason;
         throw error;
     }
 };