@adobe/ecs 0.1.0 → 0.2.0

package/src/implementation/world/wasm-kernels.test.ts

@@ -1,7 +1,7 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import { Component } from "../../interface/component/component.js";
 import { Entity } from "../../interface/entity/entity.js";
-import { Resource } from "../../interface/resource/resource.js";
 import type { Schema } from "../../interface/schema/schema.js";
 import { System } from "../../interface/system/system.js";
 import type { World } from "../../interface/world/world.js";
@@ -12,6 +12,7 @@ import { createWorld } from "./create.js";
 import { bindKernel } from "./kernels.js";
 import { createState } from "./state.js";
 import { workers } from "../../interface/resources/workers.js";
+import type { F32, I32 } from "../../interface/math/index.js";
 
 type Vec2 = readonly [number, number];
 const vec2 = { type: "array", items: { type: "number", precision: 1 }, minItems: 2, maxItems: 2 } as const satisfies Schema;
@@ -27,29 +28,21 @@ const target = Symbol("wasmTest/target");
 
 declare module "@adobe/ecs" {
     export interface Components {
-        [position]: { type: readonly [number, number] };
-        [velocity]: { type: readonly [number, number] };
-        [bounces]: { type: number };
+        [position]: { type: Schema.Type<{ type: "array"; items: { type: "number"; precision: 1 }; minItems: 2; maxItems: 2; layout: "storage" }> };
+        [velocity]: { type: Schema.Type<{ type: "array"; items: { type: "number"; precision: 1 }; minItems: 2; maxItems: 2 }> };
+        [bounces]: { type: I32 };
         [flipped]: { type: boolean };
         [score]: { type: number };
         [target]: { type: Entity };
     }
     export interface Resources {
-        [seconds]: { type: number };
-        [floor]: { type: number };
+        [seconds]: { type: number; default: 0.016666666666666666 };
+        [floor]: { type: F32; default: -2.5 };
     }
 }
 
-Component.register(position, { type: { ...vec2, layout: "storage" } });
-Component.register(velocity, { type: vec2 });
-Component.register(bounces, { type: { type: "integer", minimum: -2147483648, maximum: 2147483647 } });
-Component.register(flipped, { type: { type: "boolean" } });
-Component.register(score, { type: { type: "number" } });
-Component.register(target, { type: Entity.schema });
-Resource.register(seconds, { type: { type: "number", default: 1 / 60 } });
-Resource.register(floor, { type: { type: "number", precision: 1, default: -2.5 } });
 
-const seed = System.create({ name: "wasmTest/seed", input: { type: "object", properties: { count: { type: "integer" } } } }, ({ input, commands }) => {
+const seed = System.create({}, ({ commands }, input: { readonly count: number }) => {
     let previous = Entity.none;
     for (let i = 0; i < input.count; i++) {
         previous = commands.spawn([position, velocity, bounces, flipped, score, target])({ [position]: [i * 0.37, (i % 13) * 0.71], [velocity]: [Math.sin(i) * 3, Math.cos(i) * 5], [bounces]: 0, [flipped]: false, [score]: 0, [target]: previous });
@@ -57,7 +50,7 @@ const seed = System.create({ name: "wasmTest/seed", input: { type: "object", pro
 });
 
 /** Despawns every seventh entity and spawns replacements, so some targets go stale and their indexes are reused. */
-const cull = System.create({ name: "wasmTest/cull", input: { type: "object", properties: { frame: { type: "integer" } } }, components: { read: [position], has: [bounces] } }, (row, { input, commands }) => {
+const cull = System.create({ components: { with: [position, bounces] } }, (row, { commands }, input: { readonly frame: number }) => {
     if ((row.entity >>> 0) % 7 !== input.frame % 7) return;
     commands.despawn(row.entity);
     commands.spawn([position, velocity, bounces, flipped, score, target])({ [position]: row[position], [velocity]: [1, 1], [bounces]: 0, [flipped]: true, [score]: 0, [target]: row.entity });
@@ -66,10 +59,8 @@ const cull = System.create({ name: "wasmTest/cull", input: { type: "object", pro
 const halve = (value: number) => value * 0.5;
 
 const integrate = System.create({
-    name: "wasmTest/integrate",
-    kernel: "cpu",
-    components: { write: [position, velocity] },
-    resources: { read: [seconds] },
+    kernel: true,
+    components: { with: [position, velocity] },
 }, (row, { resources }) => {
     const [x, y] = row[position];
     const [vx, vy] = row[velocity];
@@ -79,10 +70,8 @@ const integrate = System.create({
 });
 
 const bounce = System.create({
-    name: "wasmTest/bounce",
-    kernel: "cpu",
-    components: { write: [position, velocity, bounces, flipped] },
-    resources: { read: [floor] },
+    kernel: true,
+    components: { with: [position, velocity, bounces, flipped] },
     after: [integrate],
 }, (row, { resources }) => {
     const [x, y] = row[position];
@@ -99,9 +88,8 @@ const bounce = System.create({
 });
 
 const tally = System.create({
-    name: "wasmTest/tally",
-    kernel: "cpu",
-    components: { read: [bounces, flipped, position], write: [score] },
+    kernel: true,
+    components: { with: [bounces, flipped, position, score] },
     after: [bounce],
 }, row => {
     let total = 0;
@@ -115,20 +103,16 @@ const tally = System.create({
 });
 
 const scale = System.create({
-    name: "wasmTest/scale",
-    kernel: "cpu",
-    input: { type: "object", properties: { factor: { type: "number" } } },
-    components: { write: [score] },
-}, (row, { input }) => {
+    kernel: true,
+    components: { with: [score] },
+}, (row, _context, input: { readonly factor: number }) => {
     row[score] = row[score] * input.factor;
 });
 
 /** Component-wise vector math: one f32x4 operation per row. */
 const drift = System.create({
-    name: "wasmTest/drift",
-    kernel: "cpu",
-    components: { read: [velocity], write: [position] },
-    resources: { read: [seconds] },
+    kernel: true,
+    components: { with: [velocity, position] },
     after: [tally],
 }, (row, { resources }) => {
     const [x, y] = row[position];
@@ -139,9 +123,8 @@ const drift = System.create({
 
 /** Runs only for rows whose bounces changed since it last ran. */
 const react = System.create({
-    name: "wasmTest/react",
-    kernel: "cpu",
-    components: { write: [score], changed: [bounces] },
+    kernel: true,
+    components: { with: [score], changed: [bounces] },
     after: [tally],
 }, row => {
     row[score] = row[score] + 1000;
@@ -149,10 +132,9 @@ const react = System.create({
 
 /** A lookup per row: found targets pull, missing or stale ones cost a point. */
 const chase = System.create({
-    name: "wasmTest/chase",
-    kernel: "cpu",
-    components: { read: [target], write: [score] },
-    lookup: { targets: { read: [position, flipped] } },
+    kernel: true,
+    components: { with: [target, score] },
+    lookup: { targets: { with: [position, flipped] } },
     after: [react, drift],
 }, (row, { lookup: { targets } }) => {
     const other = targets(row[target]);
@@ -164,7 +146,16 @@ const chase = System.create({
     row[score] = row[score] + (other[flipped] ? x : y);
 });
 
-const main = System.create({ name: "wasmTest/main", systems: [integrate, bounce, tally, drift, react, chase] });
+/** A resource passed to a function the build inlines, so the function's parameter holds it. */
+const along = (value: number, by: number) => value + by;
+const glide = System.create({
+    kernel: true,
+    components: { with: [score] },
+}, (row, { resources }) => {
+    row[score] = along(row[score], resources[seconds]);
+});
+
+const main = System.create({ systems: [integrate, bounce, tally, drift, react, chase] });
 
 const snapshotted = [position, velocity, bounces, flipped, score] as const;
 
@@ -190,21 +181,21 @@ const simulate = async (wasm: boolean, simd = false): Promise<unknown[]> => {
 };
 
 /** Counts the runs of rows whose score changed. */
-const recount = System.create({ name: "wasmTest/recount", kernel: "cpu", components: { write: [bounces], changed: [score] } }, row => {
+const recount = System.create({ kernel: true, components: { with: [bounces], changed: [score] } }, row => {
     row[bounces] += 1;
 });
 const chosen = new Set<Entity>();
-const rescore = System.create({ name: "wasmTest/rescore", components: { write: [score] } }, row => {
+const rescore = System.create({ components: { with: [score] } }, row => {
     if (chosen.has(row.entity)) row[score] += 1;
 });
 
 /** Keeps ticks of `score` without observing its changes, so kernels writing it mute their stamps. */
-const scoreAdded = System.create({ name: "wasmTest/scoreAdded", components: { added: [score] } }, () => {});
-const raise = System.create({ name: "wasmTest/raise", kernel: "cpu", components: { write: [score] } }, row => {
+const scoreAdded = System.create({ components: { added: [score] } }, () => {});
+const raise = System.create({ kernel: true, components: { with: [score] } }, row => {
     row[score] += 1;
 });
 let raised = 0;
-const countRaised = System.create({ name: "wasmTest/countRaised", components: { changed: [score] } }, () => { raised++; });
+const countRaised = System.create({ components: { changed: [score] } }, () => { raised++; });
 
 describe("WASM kernels", () => {
     it("stamp what they write once a change filter observes a component that already kept ticks", async () => {
@@ -251,6 +242,21 @@ describe("WASM kernels", () => {
         expect(wasmOf(chase)).not.toBeNull();
     });
 
+    it("read a resource passed to a function as its parameter, as the JS kernels do", async () => {
+        const definition = definitionOf(glide);
+        const description = kernelOf(glide);
+        if (definition === undefined || definition.kind === "composite" || description === undefined) throw new Error("not a compiled leaf");
+        expect(bindKernel(createState(), definition, description).wasm).not.toBeNull();
+        const scores: (readonly unknown[])[] = [];
+        for (const wasm of [false, true]) {
+            await using ecs = createWorld({ [workers]: 0, [seconds]: 0.25 }, { wasm });
+            await ecs.run(seed, { count: 3 });
+            await ecs.run(glide);
+            scores.push(await readEach(ecs, await select(ecs, { required: [score] }), score));
+        }
+        expect(scores).toEqual([[0.25, 0.25, 0.25], [0.25, 0.25, 0.25]]);
+    });
+
     it("give bit-identical results to the JS kernels without SIMD", async () => {
         const javascript = await simulate(false);
         expect(javascript.some(values => JSON.stringify(values).includes("true"))).toBe(true);

package/src/implementation/world/wasm.test.ts

@@ -1,3 +1,4 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
 import { describe, expect, it } from "vitest";
 import type { Program } from "./kernel.js";
 import { generateWasm, importsOf, type WasmColumn } from "./wasm.js";
@@ -137,12 +138,14 @@ describe("generateWasm with SIMD", () => {
         const floats = columns.map((_, k) => new Float32Array(memory.buffer, bases[k], 512));
         const ticks = new Float64Array(memory.buffer, 4096 * 8, 64);
         const chunks = new Float64Array(memory.buffer, 4096 * 9, 4);
+        const blocks = new Float64Array(memory.buffer, 4096 * 10, 4);
         fill(floats, ticks);
         const runKernel: unknown = new WebAssembly.Instance(new WebAssembly.Module(kernel.bytes), { env: { memory }, math: importsOf(kernel.imports) }).exports.run;
         if (typeof runKernel !== "function") throw new Error("no run export");
-        // f64 columns are ticks, then their chunks.
-        runKernel(0, rows, tick, -1, ...bases.map((base, k) => columns[k].view !== "f64" ? base : columns[k].component === -2 ? 4096 * 9 : 4096 * 8));
-        return { kernel, floats, ticks, chunks };
+        // f64 columns are ticks, then their chunks, then their blocks.
+        const tickBase = (component: number): number => component === -3 ? 4096 * 10 : component === -2 ? 4096 * 9 : 4096 * 8;
+        runKernel(0, rows, tick, -1, ...bases.map((base, k) => columns[k].view !== "f64" ? base : tickBase(columns[k].component)));
+        return { kernel, floats, ticks, chunks, blocks };
     };
     const column = (component: number, stride: number, offset: number): WasmColumn => ({ view: "f32", stride, offset, boolean: false, component });
     const read = (k: number): Expression => ({ kind: "column", column: k });
@@ -200,7 +203,7 @@ describe("generateWasm with SIMD", () => {
                         column: leaf,
                         value: add(add(local(leaf), { kind: "binary", operator: "*", left: local(leaves + leaf), right: { kind: "args", path: [] } }), { kind: "number", value: leaf + 1 }),
                     })),
-                    { kind: "stamp", column: 2 * leaves, chunks: 2 * leaves + 1 },
+                    { kind: "stamp", column: 2 * leaves, chunks: 2 * leaves + 1, blocks: 2 * leaves + 2 },
                 ],
             };
             const columns: WasmColumn[] = [
@@ -208,6 +211,7 @@ describe("generateWasm with SIMD", () => {
                 ...Array.from({ length: leaves }, (_, leaf) => column(1, stride, 4 * leaf)),
                 { view: "f64", stride: 8, offset: 0, boolean: false, component: -1 },
                 { view: "f64", stride: 8, offset: 0, boolean: false, component: -2 },
+                { view: "f64", stride: 8, offset: 0, boolean: false, component: -3 },
             ];
             const kernel = generateWasm(program, columns, () => "number");
             if (kernel === null) throw new Error("expected a kernel");
@@ -220,7 +224,7 @@ describe("generateWasm with SIMD", () => {
             const runKernel: unknown = new WebAssembly.Instance(new WebAssembly.Module(kernel.bytes), { env: { memory }, math: importsOf(kernel.imports) }).exports.run;
             if (typeof runKernel !== "function") throw new Error("no run export");
             const [start, end] = [3, 22];
-            runKernel(start, end, 7, -1, ...columns.slice(0, leaves).map(() => 4096), ...columns.slice(0, leaves).map(() => 8192), 16384, 20480, 0.5);
+            runKernel(start, end, 7, -1, ...columns.slice(0, leaves).map(() => 4096), ...columns.slice(0, leaves).map(() => 8192), 16384, 20480, 24576, 0.5);
             const row = (index: number): number => Math.floor(index / leaves);
             expect([...p]).toEqual([...p].map((_, i) => row(i) >= start && row(i) < end ? i + (2 * i + 100) * 0.5 + (i % leaves) + 1 : i));
             expect([...ticks]).toEqual([...ticks].map((_, i) => i >= start && i < end ? 7 : 1));
@@ -229,11 +233,12 @@ describe("generateWasm with SIMD", () => {
 
     it("blends stores and tick stamps under an if, per lane", () => {
         const positive: Expression = { kind: "binary", operator: ">", left: read(0), right: { kind: "number", value: 0 } };
-        const program: Program = { locals: 0, body: [{ kind: "if", test: positive, consequent: [{ kind: "store", column: 1, value: read(0) }, { kind: "stamp", column: 2, chunks: 3 }], alternate: [] }] };
+        const program: Program = { locals: 0, body: [{ kind: "if", test: positive, consequent: [{ kind: "store", column: 1, value: read(0) }, { kind: "stamp", column: 2, chunks: 3, blocks: 4 }], alternate: [] }] };
         const ticksColumn: WasmColumn = { view: "f64", stride: 8, offset: 0, boolean: false, component: -1 };
         const chunksColumn: WasmColumn = { view: "f64", stride: 8, offset: 0, boolean: false, component: -2 };
+        const blocksColumn: WasmColumn = { view: "f64", stride: 8, offset: 0, boolean: false, component: -3 };
         const inputs = [1, -1, 2, -2, 0, 3, NaN, 4, -5, 6];
-        const { kernel, floats, ticks, chunks } = runVector(program, [column(0, 4, 0), column(1, 4, 0), ticksColumn, chunksColumn], ([input, out], tickValues) => {
+        const { kernel, floats, ticks, chunks, blocks } = runVector(program, [column(0, 4, 0), column(1, 4, 0), ticksColumn, chunksColumn, blocksColumn], ([input, out], tickValues) => {
             input.set(inputs);
             out.fill(-7);
             tickValues.fill(1);
@@ -242,6 +247,32 @@ describe("generateWasm with SIMD", () => {
         expect([...floats[1].subarray(0, 10)]).toEqual(inputs.map(x => x > 0 ? x : -7));
         expect([...ticks.subarray(0, 10)]).toEqual(inputs.map(x => x > 0 ? 7 : 1));
         expect(chunks[0]).toBe(7);
+        expect(blocks[0]).toBe(7);
+    });
+
+    /** Runs `out = in` with its stamps where `in > 0`, rows `start` to `end` of 2048, four at a time; the blocks then stamped. */
+    const stampedFourAtATime = (start: number, end: number, positive: readonly number[]): number[] => {
+        const test: Expression = { kind: "binary", operator: ">", left: read(0), right: { kind: "number", value: 0 } };
+        const program: Program = { locals: 0, body: [{ kind: "if", test, consequent: [{ kind: "store", column: 1, value: read(0) }, { kind: "stamp", column: 2, chunks: 3, blocks: 4 }], alternate: [] }] };
+        const dense = (component: number): WasmColumn => ({ view: "f64", stride: 8, offset: 0, boolean: false, component });
+        const kernel = generateWasm(program, [column(0, 4, 0), column(1, 4, 0), dense(-1), dense(-2), dense(-3)], () => "number");
+        if (kernel === null) throw new Error("expected a kernel");
+        expect(kernel.vectorized).toBe(true);
+        const memory = new WebAssembly.Memory({ initial: 2, maximum: 65536, shared: true });
+        const input = new Float32Array(memory.buffer, 0, 2048).fill(-1);
+        for (const row of positive) input[row] = 1;
+        const blocks = new Float64Array(memory.buffer, 65536 + 1024, 32);
+        const runKernel = new WebAssembly.Instance(new WebAssembly.Module(kernel.bytes), { env: { memory }, math: importsOf(kernel.imports) }).exports.run;
+        if (typeof runKernel !== "function") throw new Error("no run export");
+        runKernel(start, end, 7, -1, 0, 8192, 16384, 65536, 65536 + 1024);
+        return [...blocks].flatMap((tick, block) => tick === 7 ? [block] : []);
+    };
+
+    it("stamps the blocks of rows a conditional write reaches four rows at a time", () => {
+        // 300 rows are 75 whole groups, so no row runs one at a time.
+        expect(stampedFourAtATime(0, 300, [200])).toContain(200 >> 6);
+        // From row 1 the last group, rows 61 to 64, straddles blocks 0 and 1, and only its last row writes.
+        expect(stampedFourAtATime(1, 65, [64])).toEqual([0, 1]);
     });
 
     it("stays scalar for operations without an exact f32x4 equivalent", () => {
@@ -252,7 +283,7 @@ describe("generateWasm with SIMD", () => {
 });
 
 describe("generateWasm with change filters", () => {
-    it("runs only rows with a newer tick, skipping chunks whose tick isn't newer", () => {
+    it("runs only rows with a newer tick, skipping chunks and blocks whose tick isn't newer", () => {
         for (const simd of [false, true]) {
             // out = in, for rows whose filter tick is newer than lastRun 5.
             const columns: WasmColumn[] = [{ view: "f32", stride: 4, offset: 0, boolean: false, component: 0 }, { view: "f32", stride: 4, offset: 0, boolean: false, component: 1 }];
@@ -265,46 +296,107 @@ describe("generateWasm with change filters", () => {
             const output = new Float32Array(memory.buffer, 16384, rows).fill(-1);
             const ticks = new Float64Array(memory.buffer, 32768, rows);
             const chunks = new Float64Array(memory.buffer, 65536, 3);
-            // Chunk 0's chunk tick is stale-new (8) but its rows are old; chunk 1 has three new rows; chunk 2 is old throughout.
+            const blocks = new Float64Array(memory.buffer, 66560, 48);
+            // Chunk 0's chunk and block ticks are stale-new (8) but its rows are old; chunk 1 has three new rows in
+            // blocks marked new; chunk 2 is old throughout.
             chunks.set([8, 9, 3]);
-            for (const row of [1030, 1500, 2047]) ticks[row] = 9;
+            blocks.fill(8, 0, 16).fill(3, 16);
+            for (const row of [1030, 1500, 2047]) {
+                ticks[row] = 9;
+                blocks[row >> 6] = 9;
+            }
+            ticks[1100] = 9;
             ticks[2050] = 9;
             const run = new WebAssembly.Instance(new WebAssembly.Module(kernel.bytes), { env: { memory }, math: importsOf(kernel.imports) }).exports.run;
             if (typeof run !== "function") throw new Error("no run export");
-            run(0, rows, 10, 5, 0, 16384, 32768, 65536);
+            run(0, rows, 10, 5, 0, 16384, 32768, 65536, 66560);
             const written = [...output].flatMap((value, row) => value === -1 ? [] : [row]);
-            // Row 2050 has a new tick, but its chunk says nothing in it changed, so it's skipped by design.
+            // Rows 1100 and 2050 have new ticks, but their block or chunk says nothing in it changed, so they're skipped by design.
             expect([simd, kernel.vectorized, written]).toEqual([simd, false, [1030, 1500, 2047]]);
+            // From a start inside a block, that block's tick is still checked.
+            output.fill(-1);
+            run(1029, 1040, 10, 5, 0, 16384, 32768, 65536, 66560);
+            expect([...output].flatMap((value, row) => value === -1 ? [] : [row])).toEqual([1030]);
             // lastRun below 0 passes everything.
             output.fill(-1);
-            run(0, rows, 10, -1, 0, 16384, 32768, 65536);
+            run(0, rows, 10, -1, 0, 16384, 32768, 65536, 66560);
             expect(output.every((value, row) => value === row)).toBe(true);
         }
     });
 });
 
-describe("generateWasm chunk stamps", () => {
+describe("generateWasm with up", () => {
+    it("refuses change filters, which its runner applies by listing only passing rows", () => {
+        const columns: WasmColumn[] = [{ view: "f32", stride: 4, offset: 0, boolean: false, component: 0 }];
+        const program: Program = { locals: 0, up: true, body: [{ kind: "store", column: 0, value: { kind: "number", value: 1 } }] };
+        expect(() => generateWasm(program, columns, () => "number", true, 1)).toThrow("takes no change filters");
+        expect(generateWasm(program, columns, () => "number", true, 0)).not.toBeNull();
+    });
+});
+
+describe("generateWasm with several change filters", () => {
+    it("runs rows either filter passes, a chunk with most blocks passing as one run", () => {
+        for (const simd of [false, true]) {
+            const columns: WasmColumn[] = [{ view: "f32", stride: 4, offset: 0, boolean: false, component: 0 }, { view: "f32", stride: 4, offset: 0, boolean: false, component: 1 }];
+            const kernel = generateWasm({ locals: 0, body: [{ kind: "store", column: 1, value: { kind: "column", column: 0 } }] }, columns, () => "number", simd, 2);
+            if (kernel === null) throw new Error("expected a kernel");
+            const rows = 2100;
+            const memory = new WebAssembly.Memory({ initial: 4, maximum: 65536, shared: true });
+            const input = new Float32Array(memory.buffer, 0, rows);
+            for (let row = 0; row < rows; row++) input[row] = row;
+            const output = new Float32Array(memory.buffer, 16384, rows).fill(-1);
+            // Each filter's rows, chunks and blocks.
+            const ticks = [new Float64Array(memory.buffer, 32768, rows).fill(1), new Float64Array(memory.buffer, 65536 + 4096, rows).fill(1)];
+            const chunks = [new Float64Array(memory.buffer, 65536, 3).fill(1), new Float64Array(memory.buffer, 65536 + 64, 3).fill(1)];
+            const blocks = [new Float64Array(memory.buffer, 65536 + 1024, 48).fill(1), new Float64Array(memory.buffer, 65536 + 2048, 48).fill(1)];
+            const mark = (filter: number, row: number): void => {
+                ticks[filter][row] = chunks[filter][row >> 10] = blocks[filter][row >> 6] = 9;
+            };
+            // Chunk 0: the first filter marks ten blocks of sixteen, so the chunk runs whole, and a row in an
+            // unmarked block with a new tick runs too. Chunk 1: each filter marks a row; a new tick in an unmarked
+            // block is skipped.
+            for (let block = 0; block < 10; block++) mark(0, block * 64 + 1);
+            ticks[1][900] = 9;
+            chunks[1][0] = 9;
+            mark(0, 1030);
+            mark(1, 1500);
+            ticks[1][1700] = 9;
+            const run = new WebAssembly.Instance(new WebAssembly.Module(kernel.bytes), { env: { memory }, math: importsOf(kernel.imports) }).exports.run;
+            if (typeof run !== "function") throw new Error("no run export");
+            run(0, rows, 10, 5, 0, 16384, 32768, 65536 + 4096, 65536, 65536 + 64, 65536 + 1024, 65536 + 2048);
+            const written = [...output].flatMap((value, row) => value === -1 ? [] : [row]);
+            expect([simd, written]).toEqual([simd, [...Array.from({ length: 10 }, (_, block) => block * 64 + 1), 900, 1030, 1500]]);
+        }
+    });
+});
+
+describe("generateWasm chunk and block stamps", () => {
     const columns: WasmColumn[] = [
         { view: "f32", stride: 4, offset: 0, boolean: false, component: 0 },
         { view: "f64", stride: 8, offset: 0, boolean: false, component: -1 },
         { view: "f64", stride: 8, offset: 0, boolean: false, component: -2 },
+        { view: "f64", stride: 8, offset: 0, boolean: false, component: -3 },
     ];
-    const run = (program: Program, start: number, end: number): number[] => {
+    /** The blocks whose tick is 7. */
+    const stampedBlocks = (blocks: Float64Array): number[] => [...blocks].flatMap((tick, block) => tick === 7 ? [block] : []);
+    const run = (program: Program, start: number, end: number): { readonly chunks: number[]; readonly blocks: number[] } => {
         const kernel = generateWasm(program, columns, () => "number");
         if (kernel === null) throw new Error("expected a kernel");
         const memory = new WebAssembly.Memory({ initial: 4, maximum: 65536, shared: true });
         new Float32Array(memory.buffer, 0, 4096).fill(1);
         const chunks = new Float64Array(memory.buffer, 65536, 4);
+        const blocks = new Float64Array(memory.buffer, 66560, 64);
         const runKernel = new WebAssembly.Instance(new WebAssembly.Module(kernel.bytes), { env: { memory }, math: importsOf(kernel.imports) }).exports.run;
         if (typeof runKernel !== "function") throw new Error("no run export");
-        runKernel(start, end, 7, -1, 0, 32768, 65536);
-        return [...chunks];
+        runKernel(start, end, 7, -1, 0, 32768, 65536, 66560);
+        return { chunks: [...chunks], blocks: stampedBlocks(blocks) };
     };
-    const stamp: Program.Statement = { kind: "stamp", column: 1, chunks: 2 };
+    const stamp: Program.Statement = { kind: "stamp", column: 1, chunks: 2, blocks: 3 };
+    const range = (first: number, last: number): number[] => Array.from({ length: last - first + 1 }, (_, k) => first + k);
 
-    it("stamps every chunk of the range once when every row stamps", () => {
-        expect(run({ locals: 0, body: [stamp] }, 1000, 2100)).toEqual([7, 7, 7, 0]);
-        expect(run({ locals: 0, body: [stamp] }, 5, 5)).toEqual([0, 0, 0, 0]);
+    it("stamps every chunk and block of the range once when every row stamps", () => {
+        expect(run({ locals: 0, body: [stamp] }, 1000, 2100)).toEqual({ chunks: [7, 7, 7, 0], blocks: range(1000 >> 6, 2099 >> 6) });
+        expect(run({ locals: 0, body: [stamp] }, 5, 5)).toEqual({ chunks: [0, 0, 0, 0], blocks: [] });
     });
 
     it("stamps per row when a row can end before its stamp", () => {
@@ -322,10 +414,12 @@ describe("generateWasm chunk stamps", () => {
         const values = new Float32Array(memory.buffer, 0, 4096).fill(1);
         values.fill(2, 1024, 2048);
         const chunks = new Float64Array(memory.buffer, 65536, 4);
+        const blocks = new Float64Array(memory.buffer, 66560, 64);
         const runKernel = new WebAssembly.Instance(new WebAssembly.Module(kernel.bytes), { env: { memory }, math: importsOf(kernel.imports) }).exports.run;
         if (typeof runKernel !== "function") throw new Error("no run export");
-        runKernel(0, 3000, 7, -1, 0, 32768, 65536);
+        runKernel(0, 3000, 7, -1, 0, 32768, 65536, 66560);
         expect([...chunks]).toEqual([7, 0, 7, 0]);
+        expect(stampedBlocks(blocks)).toEqual([...range(0, 15), ...range(32, 2999 >> 6)]);
     });
 });
 
@@ -379,3 +473,87 @@ describe("generateWasm reductions", () => {
         }
     });
 });
+
+describe("generateWasm with f64 lanes, as kernels computing at the body's precision run", () => {
+    const column = (component: number, stride: number, offset: number): WasmColumn => ({ view: "f32", stride, offset, boolean: false, component });
+    const ticks = (component: number): WasmColumn => ({ view: "f64", stride: 8, offset: 0, boolean: false, component });
+    const read = (k: number): Expression => ({ kind: "column", column: k });
+    const number = (value: number): Expression => ({ kind: "number", value });
+    const binary = (operator: "+" | "-" | "*" | "/" | ">" | "<=", left: Expression, right: Expression): Expression => ({ kind: "binary", operator, left, right });
+    const math = (name: string, ...parameters: Expression[]): Expression => ({ kind: "math", name, arguments: parameters });
+
+    /**
+     * Runs `program` over rows `start` to `end` with f64 lanes, and as scalar WASM, which is JS's semantics; returns
+     * whether the lanes ran, and each run's memory as bits, so NaN and -0 compare exactly.
+     */
+    const both = (program: Program, columns: readonly WasmColumn[], fill: (floats: readonly Float32Array[]) => void, start: number, end: number) => {
+        const results = [true, false].map(simd => {
+            const kernel = generateWasm(program, columns, () => "number", simd, 0, [], [], [], [], [], false);
+            if (kernel === null) throw new Error("expected a kernel");
+            const memory = new WebAssembly.Memory({ initial: 1, maximum: 65536, shared: true });
+            // f32 components at 4096 × (component + 1); ticks, then their chunks, then their blocks, after them.
+            const baseOf = (info: WasmColumn): number => info.view === "f64" ? 4096 * (8 - info.component) : 4096 * (info.component + 1);
+            const floats = [0, 1, 2].map(component => new Float32Array(memory.buffer, 4096 * (component + 1), 1024));
+            new Float64Array(memory.buffer, 4096 * 9, 1536).fill(1);
+            fill(floats);
+            const run: unknown = new WebAssembly.Instance(new WebAssembly.Module(kernel.bytes), { env: { memory }, math: importsOf(kernel.imports) }).exports.run;
+            if (typeof run !== "function") throw new Error("no run export");
+            run(start, end, 7, -1, ...columns.map(baseOf), 0.75);
+            return { vectorized: kernel.vectorized, bits: [...new Uint32Array(memory.buffer, 4096, 4096 * 3)] };
+        });
+        return { vectorized: results[0].vectorized, same: results[0].bits.every((bits, i) => bits === results[1].bits[i]) };
+    };
+    /** Values where f32 arithmetic loses what f64 keeps: cancellation, rounding at each step, NaN, infinities and -0. */
+    const hard = (i: number): number => [1 + 2 ** -23, 1 + 2 ** -22, 3.4e38, -0, NaN, Infinity, 1e-45, 0.1, -7.25, 16777217][i % 10] * (1 + (i % 7) * 2 ** -20);
+
+    it("computes dense f32 columns two rows at a time in f64, as the body does, through the tail", () => {
+        // out = a * a - b, which cancels in f32; and out2 = sqrt(|a|) / b + min(a, args) * fround(b) - floor(a).
+        const program: Program = {
+            locals: 0,
+            body: [
+                { kind: "store", column: 2, value: binary("-", binary("*", read(0), read(0)), read(1)) },
+                { kind: "store", column: 3, value: binary("-", binary("+", binary("/", math("sqrt", math("abs", read(0))), read(1)), binary("*", math("min", read(0), { kind: "args", path: [] }), math("fround", read(1)))), math("floor", read(0))) },
+            ],
+        };
+        const columns = [column(0, 4, 0), column(1, 4, 0), column(2, 4, 0), column(2, 4, 2048)];
+        for (const [start, end] of [[0, 300], [3, 22], [1, 2]] as const) {
+            expect([start, end, both(program, columns, ([a, b]) => { for (let i = 0; i < 1024; i++) { a[i] = hard(i); b[i] = hard(i + 1); } }, start, end)]).toEqual([start, end, { vectorized: true, same: true }]);
+        }
+    });
+
+    it("blends stores and stamps under an if per lane, in f64", () => {
+        const program: Program = {
+            locals: 1,
+            body: [
+                { kind: "set", local: 0, value: binary("*", read(0), read(0)) },
+                { kind: "if", test: binary(">", { kind: "local", local: 0 }, read(1)), consequent: [{ kind: "store", column: 2, value: binary("-", { kind: "local", local: 0 }, read(1)) }, { kind: "stamp", column: 3, chunks: 4, blocks: 5 }], alternate: [{ kind: "store", column: 2, value: { kind: "conditional", test: binary("<=", read(0), number(0)), consequent: number(-1), alternate: read(1) } }] },
+            ],
+        };
+        const columns = [column(0, 4, 0), column(1, 4, 0), column(2, 4, 0), ticks(-1), ticks(-2), ticks(-3)];
+        expect(both(program, columns, ([a, b]) => { for (let i = 0; i < 1024; i++) { a[i] = hard(i); b[i] = hard(i + 3); } }, 5, 133)).toEqual({ vectorized: true, same: true });
+    });
+
+    // A padded vec3's elements aren't whole vectors, and f64 lanes don't fuse within a row, so it runs a row at a time.
+    for (const [name, stride, leaves, vectorized] of [["vec2", 8, 2, true], ["tight vec3", 12, 3, true], ["padded vec3", 16, 3, false]] as const) {
+        it(`computes ${name} elements ${vectorized ? "in f64 lanes" : "a row at a time"}, as the body does`, () => {
+            // p = p * v - v * args, leaf by leaf, with p.x and v.x reading cancelling values.
+            const all = Array.from({ length: leaves }, (_, leaf) => leaf);
+            const program: Program = { locals: 0, body: all.map(leaf => ({ kind: "store", column: leaf, value: binary("-", binary("*", read(leaf), read(leaves + leaf)), binary("*", read(leaves + leaf), { kind: "args", path: [] })) })) };
+            const columns = [...all.map(leaf => column(0, stride, 4 * leaf)), ...all.map(leaf => column(1, stride, 4 * leaf))];
+            expect(both(program, columns, ([p, v]) => { for (let i = 0; i < 1024; i++) { p[i] = hard(i); v[i] = hard(i + 1); } }, 1, 63)).toEqual({ vectorized, same: true });
+        });
+    }
+
+    it("leaves explicit kernels' f32 lanes, which round each step", () => {
+        const program: Program = { locals: 0, body: [{ kind: "store", column: 2, value: binary("-", binary("*", read(0), read(0)), read(1)) }] };
+        const columns = [column(0, 4, 0), column(1, 4, 0), column(2, 4, 0)];
+        const kernel = generateWasm(program, columns, () => "number", true, 0, [], [], [], [], [], true);
+        const memory = new WebAssembly.Memory({ initial: 1, maximum: 65536, shared: true });
+        new Float32Array(memory.buffer, 4096, 4).fill(1 + 2 ** -23);
+        new Float32Array(memory.buffer, 8192, 4).fill(1 + 2 ** -22);
+        const run: unknown = kernel === null ? null : new WebAssembly.Instance(new WebAssembly.Module(kernel.bytes), { env: { memory }, math: importsOf(kernel.imports) }).exports.run;
+        if (typeof run !== "function") throw new Error("no run export");
+        run(0, 4, 7, -1, 4096, 8192, 12288);
+        expect([kernel?.vectorized, new Float32Array(memory.buffer, 12288, 1)[0]]).toEqual([true, 0]);
+    });
+});