@adobe/ecs 0.0.0-stage → 0.2.0

package/src/implementation/compiler/predicates.test.ts

@@ -0,0 +1,90 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { describe, expect, test } from 'vitest';
+import { parseAst } from 'vite';
+import { transformKernels } from './transform.js';
+import { createLinker } from './link.js';
+import { nodeCopies, ownCopy } from './paths.js';
+import { estreeOf } from './estree.js';
+
+const parse = (code: string) => estreeOf(parseAst(code));
+
+const header = `import { System, Vec2 } from "ecs";
+import { near, drift } from "./helpers.js";
+const cell = Symbol();
+const value = Symbol();
+const camera = Symbol();
+const range = 3;
+`;
+
+/** Modules besides the one transformed. */
+const files: { readonly [file: string]: string } = {
+    "/helpers.js": `const limit = 2;\nexport const near = (x, y) => Math.abs(x - y) <= limit;\nlet offset = 0;\nexport const drift = x => x + offset;\n`,
+};
+
+const transform = (source: string) => transformKernels(`${header}${source}`, "/test.js", parse, async specifier => specifier === "ecs" ? ownCopy : null, index => JSON.stringify(`kernel:${index}`), createLinker({
+    packages: nodeCopies,
+    resolve: async (specifier, importer) => {
+        if (specifier === "ecs") return ownCopy.index;
+        if (specifier === "./helpers.js" && importer === "/test.js") return "/helpers.js";
+        if (!specifier.startsWith(".")) return { error: `${specifier} can't be resolved` };
+        const path = resolve(dirname(importer), specifier);
+        const typescript = path.replace(/\.js$/, ".ts");
+        return existsSync(typescript) ? typescript : path;
+    },
+    load: async file => {
+        const code = files[file] ?? await readFile(file, "utf8");
+        if (!file.endsWith(".ts")) return { code };
+        const { transformWithOxc } = await import("vite");
+        return { code: (await transformWithOxc(code, file, { lang: "ts" })).code };
+    },
+}, parse));
+
+/** What the build gives a system's declaration, or why it fails. */
+const built = async (where: string, wrap = (system: string): string => `export const visible = ${system};`): Promise<string> => {
+    const result = await transform(wrap(`System.create({ kernel: false, components: { with: [value], where: { [cell]: ${where} } } }, row => { void row[value]; })`));
+    if (result === null) return "untransformed";
+    return "failure" in result ? result.failure.message : result.code;
+};
+
+describe("where predicates", () => {
+    test("read their value, resources, literals, module constants and pure functions, which the build infers the resources of", async () => {
+        expect(await built(`(at, { resources }) => near(at[0], resources[camera].x) && Math.abs(at[1]) < range`)).toContain(`where: [camera]`);
+        expect(await built(`([x, y]) => Vec2.length([x, y]) < range`)).toContain(`where: []`);
+        expect(await built(`function (at, context) { const { resources } = context; return at[0] < resources[camera].x; }`)).toContain(`where: [camera]`);
+    });
+    test("fail the build where they read what may change outside the world", async () => {
+        expect(await built(`at => at[0] < limit`, system => `let limit = 2;\nexport const visible = ${system};`)).toContain("a where predicate reads limit, a module variable that may change");
+        expect(await built(`at => at[0] < bounds.x`, system => `const bounds = { x: 2 };\nexport const visible = ${system};`)).toContain("a where predicate reads bounds, which holds values that may change");
+        expect(await built(`at => at[0] < window.innerWidth`)).toContain("a where predicate reads the global window, which may change");
+        expect(await built(`at => at[0] < width`, system => `export const make = (width) => ${system.replace("export const visible = ", "")};`)).toContain("a where predicate reads width, which a function around it declares and may change");
+        expect(await built(`at => drift(at[0]) < range`)).toContain("a where predicate reads offset, a module variable that may change");
+        expect(await built(`(at, { resources }) => { resources[camera] = at; return true; }`)).toContain("a where predicate writes through resources, which it only reads");
+    });
+    const holes: readonly { readonly what: string; readonly where: string; readonly wrap?: (system: string) => string; readonly fails: string }[] = [
+        { what: "Math.random", where: "at => at[0] < Math.random()", fails: "a where predicate reads Math.random, which isn't pure" },
+        { what: "Math.random by another name", where: "at => { const draw = Math.random; return at[0] < draw(); }", fails: "a where predicate reads Math.random, which isn't pure" },
+        { what: "assigning into its value", where: "at => { at[0] = 1; return true; }", fails: "a where predicate writes through at, which it only reads" },
+        { what: "sorting its value", where: "at => { at.sort(); return true; }", fails: "a where predicate calls at.sort, which may change what it reads" },
+        { what: "setting a resource's value", where: "(at, { resources }) => { resources[camera].set(at); return true; }", fails: "a where predicate calls resources[camera].set, which may change what it reads" },
+        { what: "assigning a global's member", where: "at => { Math.PI = 3; return at[0] < 1; }", fails: "a where predicate writes through Math, which it only reads" },
+        { what: "assigning through a global's prototype", where: "at => { Number.prototype.x = 1; return at[0] < 1; }", fails: "a where predicate writes through Number, which it only reads" },
+        { what: "counting on a function object", where: "at => { count.n++; return at[0] < 1; }", wrap: system => `function count() {}\nexport const visible = ${system};`, fails: "a where predicate writes through count, which it only reads" },
+        { what: "importing a module", where: `at => { void import("./helpers.js"); return at[0] < 1; }`, fails: "a where predicate imports a module, which may run anything" },
+        { what: "deleting from its value", where: "at => { delete at.x; return true; }", fails: "a where predicate writes through at, which it only reads" },
+        { what: "a helper assigning into what it's given", where: "at => bump(at)", wrap: system => `const bump = values => { values[0] = 1; return true; };\nexport const visible = ${system};`, fails: "a where predicate writes through values, which it only reads" },
+    ];
+    for (const { what, where, wrap, fails } of holes) {
+        test(`fail the build on ${what}`, async () => {
+            expect(await built(where, wrap)).toContain(fails);
+        });
+    }
+    test("may change what they make of their own, and call the pure members of Math and Number and any other method that doesn't change what it's called on", async () => {
+        expect(await built(`at => { const own = [at[0], at[1]]; own.sort(); own[0] = Math.max(own[0], Number.parseFloat("1")); let n = 0; n++; return own[0] + n < Math.PI; }`)).toContain(`where: []`);
+        expect(await built(`at => at.map(x => x * 2).includes(4)`)).toContain(`where: []`);
+        // A function a resource holds, which the world calls as written.
+        expect(await built(`(at, { resources }) => resources[camera].sees(at)`)).toContain(`where: [camera]`);
+    });
+});

package/src/implementation/compiler/predicates.ts

@@ -0,0 +1,250 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Expression, FunctionDeclaration, MaybeNamedFunctionDeclaration, MemberExpression, Node, ObjectExpression } from 'estree';
+import { children, declaredIn, isFunction, patternNames } from './estree.js';
+import { fail, within } from './failure.js';
+import { resolveBinding, type Link } from './link.js';
+import type { Module, ModuleBinding } from './module-scope.js';
+import { frameIn } from './module-value.js';
+
+// What a `where` predicate may read: its value, the world's resources, literals, and module-scope constants and pure
+// functions. The world runs it as written whenever a resource it reads changed, so anything else that may change, a
+// module variable, a closure over a function's state or a global, would make its cached result wrong.
+
+/** Globals a predicate may read: pure functions and constants of the language, and namespaces of them. */
+const pureGlobals: ReadonlySet<string> = new Set(["Math", "Number", "Infinity", "NaN", "undefined", "isFinite", "isNaN"]);
+
+/** By namespace global, the members a predicate may read: each pure, or a constant; `Math.random` isn't. */
+const pureMembers: ReadonlyMap<string, ReadonlySet<string>> = new Map([
+    ["Math", new Set([
+        "abs", "acos", "acosh", "asin", "asinh", "atan", "atan2", "atanh", "cbrt", "ceil", "clz32", "cos", "cosh", "exp", "expm1", "floor", "fround",
+        "hypot", "imul", "log", "log10", "log1p", "log2", "max", "min", "pow", "round", "sign", "sin", "sinh", "sqrt", "tan", "tanh", "trunc",
+        "E", "LN10", "LN2", "LOG10E", "LOG2E", "PI", "SQRT1_2", "SQRT2",
+    ])],
+    ["Number", new Set([
+        "EPSILON", "MAX_SAFE_INTEGER", "MAX_VALUE", "MIN_SAFE_INTEGER", "MIN_VALUE", "NaN", "NEGATIVE_INFINITY", "POSITIVE_INFINITY",
+        "isFinite", "isInteger", "isNaN", "isSafeInteger", "parseFloat", "parseInt",
+    ])],
+]);
+
+/** Methods that change what they're called on, of arrays, typed arrays, maps, sets and data views, which a predicate may call only on what it made. */
+const mutatingMethods: ReadonlySet<string> = new Set(["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin", "set", "add", "delete", "clear"]);
+
+/** Whether a method may change what it's called on: a known one, or a data view's setter. */
+const mutates = (name: string | null): boolean => name === null || mutatingMethods.has(name) || /^set[A-Z]/.test(name);
+
+/** A function declaration with a name, which `export default` may leave out. */
+const isNamed = (node: FunctionDeclaration | MaybeNamedFunctionDeclaration): node is FunctionDeclaration => node.id !== null;
+
+/** Whether `node`, a child of `parent`, names a property or declares a binding, rather than referring to one. */
+const isName = (node: Node, parent: Node | undefined): boolean => {
+    switch (parent?.type) {
+        case "MemberExpression": return parent.property === node && !parent.computed;
+        case "Property": return parent.key === node && !parent.computed && !parent.shorthand;
+        case "MethodDefinition": case "PropertyDefinition": return parent.key === node && !parent.computed;
+        case "LabeledStatement": case "BreakStatement": case "ContinueStatement": return true;
+        default: return false;
+    }
+};
+
+/** The identifiers a function refers to that it doesn't declare, each at its first reference. */
+const freeNames = (fn: Node): ReadonlyMap<string, Node> => {
+    const declared = new Set<string>();
+    declaredIn(fn, name => declared.add(name));
+    if (fn.type === "ArrowFunctionExpression" || fn.type === "FunctionExpression" || fn.type === "FunctionDeclaration") {
+        for (const parameter of fn.params) for (const name of patternNames(parameter)) declared.add(name);
+    }
+    const free = new Map<string, Node>();
+    const visit = (node: Node, parent: Node | undefined): void => {
+        if (node.type === "ThisExpression") fail(node, "a where predicate reads its value and resources, never this");
+        if (node.type === "Identifier" && !isName(node, parent) && !declared.has(node.name) && !free.has(node.name)) free.set(node.name, node);
+        for (const child of children(node)) visit(child, node);
+    };
+    visit(fn, undefined);
+    return free;
+};
+
+/** A member's name, when it's written as one or as a string literal; null for one computed otherwise. */
+const memberName = (node: MemberExpression): string | null =>
+    !node.computed && node.property.type === "Identifier" ? node.property.name
+    : node.computed && node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value
+    : null;
+
+/** An expression as the build prints it in a failure: a name and its members, or "it" for anything else. */
+const textOf = (node: Node): string => {
+    if (node.type === "Identifier") return node.name;
+    if (node.type === "MemberExpression") {
+        const name = memberName(node);
+        const object = textOf(node.object);
+        if (name !== null && !node.computed) return `${object}.${name}`;
+        return `${object}[${node.property.type === "Identifier" ? node.property.name : name === null ? "…" : JSON.stringify(name)}]`;
+    }
+    return "it";
+};
+
+/** The innermost object of a chain of members: what a write or call through it reaches. */
+const rootOf = (node: Node): Node => node.type === "MemberExpression" ? rootOf(node.object) : node;
+
+/**
+ * Fails the build where a function writes through anything but what it made of its own, calls a method that changes
+ * what it's called on, a known one or one computed by name, on anything else, reads a member of `Math` or `Number` that isn't pure, or imports a module. What it makes of its
+ * own is a local holding an object or array it wrote out, never assigned anything else; every other value, its value,
+ * resources, parameters, globals and functions among them, may be shared. `global(name)` says whether a name it doesn't
+ * declare is a global, and `imported(name)` whether it's an import, whose members the reads check holds to the
+ * package's own namespaces and functions, which are fixed.
+ */
+const checkEffects = (fn: Node, global: (name: string) => boolean, imported: (name: string) => boolean): void => {
+    const declared = new Set<string>();
+    declaredIn(fn, name => declared.add(name));
+    // Names declared with an object or array it writes out, then never assigned.
+    const own = new Set<string>();
+    const shared = new Set<string>();
+    const scan = (node: Node): void => {
+        if (node.type === "VariableDeclarator") {
+            if (node.id.type === "Identifier" && (node.init?.type === "ObjectExpression" || node.init?.type === "ArrayExpression")) own.add(node.id.name);
+            else for (const name of patternNames(node.id)) shared.add(name);
+        }
+        if (node.type === "AssignmentExpression" && node.left.type === "Identifier") shared.add(node.left.name);
+        for (const child of children(node)) scan(child);
+    };
+    scan(fn);
+    if (fn.type === "ArrowFunctionExpression" || fn.type === "FunctionExpression" || fn.type === "FunctionDeclaration") {
+        for (const parameter of fn.params) for (const name of patternNames(parameter)) shared.add(name);
+    }
+    const isOwn = (node: Node): boolean => {
+        const root = rootOf(node);
+        return root.type === "Identifier" && own.has(root.name) && !shared.has(root.name) && declared.has(root.name);
+    };
+    const written = (target: Node): void => {
+        if (target.type === "MemberExpression") {
+            if (!isOwn(target)) fail(target, `a where predicate writes through ${textOf(rootOf(target))}, which it only reads`);
+            return;
+        }
+        if (target.type === "ObjectPattern" || target.type === "ArrayPattern" || target.type === "AssignmentPattern" || target.type === "RestElement") {
+            for (const child of children(target)) written(child);
+        }
+        if (target.type === "Property") written(target.value);
+    };
+    const visit = (node: Node): void => {
+        switch (node.type) {
+            case "ImportExpression": return fail(node, "a where predicate imports a module, which may run anything");
+            case "AssignmentExpression": written(node.left); break;
+            case "UpdateExpression": written(node.argument); break;
+            case "UnaryExpression": if (node.operator === "delete") written(node.argument); break;
+            case "ForInStatement": case "ForOfStatement": if (node.left.type !== "VariableDeclaration") written(node.left); break;
+            case "MemberExpression": {
+                const { object } = node;
+                if (object.type === "Identifier" && !declared.has(object.name) && global(object.name)) {
+                    const members = pureMembers.get(object.name);
+                    const name = memberName(node);
+                    if (members !== undefined && (name === null || !members.has(name))) fail(node, `a where predicate reads ${textOf(node)}, which isn't pure`);
+                }
+                break;
+            }
+            case "CallExpression": {
+                const { callee } = node;
+                if (callee.type === "MemberExpression" && !isOwn(callee)) {
+                    const root = rootOf(callee);
+                    const name = memberName(callee);
+                    // A namespace global's members are pure where they're read, above.
+                    const free = root === callee.object && root.type === "Identifier" && !declared.has(root.name);
+                    const namespace = free && ((global(root.name) && pureMembers.has(root.name)) || imported(root.name));
+                    if (!namespace && mutates(name)) fail(callee, `a where predicate calls ${textOf(callee)}, which may change what it reads`);
+                }
+                break;
+            }
+            default: break;
+        }
+        for (const child of children(node)) visit(child);
+    };
+    visit(fn);
+};
+
+/** Whether an expression is a literal: a number, string, boolean or `null`, possibly negated, or a template without expressions. */
+const isLiteral = (node: Expression): boolean =>
+    node.type === "Literal" ? node.value === null || ["number", "string", "boolean"].includes(typeof node.value)
+    : node.type === "UnaryExpression" ? (node.operator === "-" || node.operator === "+") && isLiteral(node.argument)
+    : node.type === "TemplateLiteral" && node.expressions.length === 0;
+
+/** Whether an expression is a `Symbol(...)` call: a key, which a predicate indexes resources by. */
+const isSymbolCall = (node: Expression): boolean => node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "Symbol";
+
+/**
+ * Fails the build where a predicate reads anything but its value, resources, literals, and module-scope constants and
+ * pure functions: `outer`, the names declared by functions around it, are state that may change. Functions it calls
+ * are checked the same, in their own modules, through `link`; without one, only the package's own imports are read.
+ */
+export const checkPredicate = (fn: Node, module: Module, link: Link | null, outer: ReadonlySet<string>, packageSpecifier: (specifier: string) => boolean): void => {
+    const checked = new Set<Node>();
+    const check = (node: Node, at: Module, around: ReadonlySet<string>): void => {
+        if (checked.has(node)) return;
+        checked.add(node);
+        checkEffects(node, name => !around.has(name) && at.bindings.get(name) === undefined, name => {
+            const kind = at.bindings.get(name)?.kind;
+            return kind === "import" || kind === "importNamespace";
+        });
+        for (const [name, reference] of freeNames(node)) {
+            if (around.has(name)) fail(reference, `a where predicate reads ${name}, which a function around it declares and may change; read only its value, resources and module-scope constants`);
+            const binding = at.bindings.get(name);
+            if (binding === undefined) {
+                if (pureGlobals.has(name)) continue;
+                fail(reference, `a where predicate reads the global ${name}, which may change; read only its value, resources and module-scope constants`);
+            }
+            else definition(reference, name, binding, at);
+        }
+    };
+    const definition = (reference: Node, name: string, binding: ModuleBinding, at: Module): void => {
+        switch (binding.kind) {
+            case "const": {
+                const { init } = binding;
+                if (isLiteral(init) || isSymbolCall(init)) return;
+                if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") {
+                    if (init.async || init.generator) fail(reference, `a where predicate calls ${name}, which isn't a plain function`);
+                    return void within(reference, frameIn(at, name), () => check(init, at, new Set()));
+                }
+                return fail(reference, `a where predicate reads ${name}, which holds values that may change; read only its value, resources and module-scope constants`);
+            }
+            case "function": {
+                const { node } = binding;
+                if (!isNamed(node)) return fail(reference, `a where predicate calls ${name}, which the build can't read`);
+                return void within(reference, frameIn(at, name), () => check(node, at, new Set()));
+            }
+            case "import": case "importNamespace": {
+                if (link === null) {
+                    if (packageSpecifier(binding.specifier)) return;
+                    return fail(reference, `a where predicate reads ${name}, imported from a module this build doesn't read`);
+                }
+                const resolved = resolveBinding(link, at, name, binding);
+                if (resolved.kind === "namespace" || (resolved.kind === "binding" && link.packages.packagePathOf(resolved.module.file)?.startsWith("interface/") === true)) {
+                    // The package's own namespaces and functions are fixed.
+                    if (resolved.kind === "namespace" ? link.packages.packagePathOf(resolved.file)?.startsWith("interface/") === true : true) return;
+                    return fail(reference, `a where predicate reads the namespace ${name}, whose members the build doesn't check`);
+                }
+                if (resolved.kind === "error") return fail(reference, `a where predicate reads ${name}, which the build can't read: ${resolved.error}`);
+                return void within(reference, frameIn(resolved.module, resolved.name), () => definition(reference, resolved.name, resolved.binding, resolved.module));
+            }
+            case "other":
+                return fail(reference, `a where predicate reads ${name}, a module variable that may change; read only its value, resources and module-scope constants`);
+        }
+    };
+    check(fn, module, outer);
+};
+
+/** The predicates of a declaration's `components.where`: each value that's a function in place or a module function by name. */
+export const predicatesOf = (declaration: ObjectExpression, module: Module): readonly Node[] => {
+    const components = declaration.properties.find(property => property.type === "Property" && !property.computed && property.key.type === "Identifier" && property.key.name === "components");
+    if (components?.type !== "Property" || components.value.type !== "ObjectExpression") return [];
+    const where = components.value.properties.find(property => property.type === "Property" && !property.computed && property.key.type === "Identifier" && property.key.name === "where");
+    if (where?.type !== "Property" || where.value.type !== "ObjectExpression") return [];
+    const predicates: Node[] = [];
+    for (const property of where.value.properties) {
+        if (property.type !== "Property") continue;
+        const { value } = property;
+        if (isFunction(value)) predicates.push(value);
+        else if (value.type === "Identifier") {
+            const binding = module.bindings.get(value.name);
+            if (binding?.kind === "function" && isNamed(binding.node)) predicates.push(binding.node);
+            else if (binding?.kind === "const" && isFunction(binding.init)) predicates.push(binding.init);
+        }
+    }
+    return predicates;
+};

package/src/implementation/compiler/print.ts

@@ -0,0 +1,124 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { blockShift, chunkShift, type Path } from '../world/kernel.js';
+import type { Expression, Statement } from './ir.js';
+import { resolve, type Out } from './out.js';
+import { rowLabel } from './statement.js';
+import type { Unit } from './unit.js';
+import { presence } from './columns.js';
+
+/** A number as JS source that reads back as the same f64. */
+export const printNumber = (value: number): string =>
+    Number.isNaN(value) ? "NaN" : value === Infinity ? "Infinity" : Object.is(value, -0) ? "(-0)" : value < 0 ? `(${String(value)})` : String(value);
+
+const printPath = (path: Path): string => path.map(item => `[${JSON.stringify(item)}]`).join("");
+
+/** The presence of the optional component the key at `key` names. */
+const presenceOf = (unit: Unit, key: number): Expression => presence(unit, unit.keys[key] ?? "");
+
+export const localName = (unit: Unit, local: number): string => `${unit.names.get(local) ?? "t"}_${local}`;
+
+/** Prints an expression. `observed` converts boolean column reads. */
+export const printExpression = (unit: Unit, expression: Expression, observed: boolean): string => {
+    const print = (item: Expression): string => printExpression(unit, item, observed);
+    switch (expression.kind) {
+        case "number": return printNumber(expression.value);
+        case "boolean": return String(expression.value);
+        case "column": {
+            const column = expression.column;
+            // In the loop for archetypes without every optional component, theirs read undefined without a load.
+            if (unit.presentAs === false && unit.optionalColumns.has(column)) return "undefined";
+            // An optional component's column is empty in an archetype without it, where it reads undefined.
+            const read = observed
+                ? (unit.booleans.add(column), `(b${column} ? c${column}[x${column}] !== 0 : c${column}[x${column}])`)
+                : `c${column}[x${column}]`;
+            const key = unit.optionalColumns.get(column);
+            return key !== undefined && observed ? `(${print(presenceOf(unit, key))} ? ${read} : undefined)` : read;
+        }
+        case "present": return unit.presentAs === null ? `q${expression.column}` : String(unit.presentAs);
+        case "upColumn": {
+            const column = expression.column;
+            const read = `u${column}[p * us${column} + uo${column}]`;
+            if (!observed) return read;
+            unit.upBooleans.add(column);
+            return `(ub${column} ? ${read} !== 0 : ${read})`;
+        }
+        case "resource": return `r${expression.index}${printPath(expression.path)}`;
+        case "args": return `args${printPath(expression.path)}`;
+        case "shared": return `h${expression.index}${printPath(expression.path)}`;
+        case "local": return localName(unit, expression.local);
+        case "unary": return `(${expression.operator}${print(expression.operand)})`;
+        case "binary": case "logical": return `(${print(expression.left)} ${expression.operator} ${print(expression.right)})`;
+        case "conditional": return `(${print(expression.test)} ? ${print(expression.consequent)} : ${print(expression.alternate)})`;
+        case "math": return `Math.${expression.name}(${expression.arguments.map(print).join(", ")})`;
+        case "observe": return printExpression(unit, expression.value, true);
+        case "lane": return print(expression.value);
+        // Lookups through indexes read through their reader, `l${lookup}`, and the handles each site holds.
+        case "listLength": return `l${expression.lookup}.length(${localName(unit, expression.list)})`;
+        case "listChanged": return `l${expression.lookup}.changed(${localName(unit, expression.list)})`;
+        case "rowLeaf": return `l${expression.lookup}.leaf(${localName(unit, expression.row)}, ${expression.leaf})`;
+        case "rowEntity": return `l${expression.lookup}.entity(${localName(unit, expression.row)})`;
+        case "rowFound": return `(${localName(unit, expression.row)}.f === 1 ? true : null)`;
+        case "nullish": return expression.value;
+        case "string": return JSON.stringify(expression.value);
+        case "element": return `${print(expression.object)}${expression.optional ? "?." : ""}[${print(expression.index)}]`;
+        case "array": return `[${expression.items.map(print).join(", ")}]`;
+        case "record": return `{ ${expression.fields.map(([name, item]) => `${JSON.stringify(name)}: ${print(item)}`).join(", ")} }`;
+    }
+};
+
+type Labels = ReadonlyMap<number, "block" | "loop">;
+
+const printStatement = (unit: Unit, statement: Statement, labels: Labels): string => {
+    const value = (item: Expression): string => printExpression(unit, item, false);
+    const branch = (label: number): string => `${labels.get(label) === "loop" ? "continue" : "break"} label_${label};`;
+    switch (statement.kind) {
+        case "set": {
+            const declare = statement.declare === undefined ? "" : `${statement.declare} `;
+            return `${declare}${localName(unit, statement.local)} = ${printExpression(unit, statement.value, unit.observed.has(statement.local))};`;
+        }
+        case "declare": return `let ${statement.locals.map(item => localName(unit, item)).join(", ")};`;
+        case "store": {
+            const { column } = statement;
+            const store = `c${column}[x${column}] = ${value(statement.value)};`;
+            // Assigning an optional component an entity lacks fails its system, as a body run as written does.
+            const key = unit.optionalColumns.get(column);
+            if (key === undefined) return store;
+            const present = printExpression(unit, presenceOf(unit, key), false);
+            return present === "true" ? store : present === "false" ? `absent(${key});` : `if (${present}) ${store} else absent(${key});`;
+        }
+        case "stamp": {
+            const row = `c${statement.column}[x${statement.column}] = tick;`;
+            return unit.stampedPerCall.has(statement.chunks) ? row : `${row}\nc${statement.blocks}[i >> ${blockShift}] = tick;\nc${statement.chunks}[i >> ${chunkShift}] = tick;`;
+        }
+        case "if": {
+            const alternate = printStatements(unit, statement.alternate, labels);
+            return `if (${value(statement.test)}) {\n${printStatements(unit, statement.consequent, labels)}\n}${alternate === "" ? "" : ` else {\n${alternate}\n}`}`;
+        }
+        case "block":
+            return `label_${statement.label}: {\n${printStatements(unit, statement.body, new Map([...labels, [statement.label, "block"]]))}\n}`;
+        case "loop": {
+            // `for (;;)` repeats where a WASM loop falls off its end, so a trailing branch back is implicit, and otherwise the loop exits.
+            const body = resolve(statement.body);
+            const last = body[body.length - 1];
+            const repeats = last?.kind === "branch" && last.label === statement.label;
+            const inner = new Map([...labels, [statement.label, "loop" as const]]);
+            const printed = printStatements(unit, repeats ? body.slice(0, -1) : body, inner);
+            return `label_${statement.label}: for (;;) {\n${printed}${repeats ? "" : `\nbreak label_${statement.label};`}\n}`;
+        }
+        case "branch": return branch(statement.label);
+        case "branchIf": return `if (${value(statement.test)}) ${branch(statement.label)}`;
+        case "next": return `continue ${rowLabel};`;
+        case "intrinsic": return printStatements(unit, statement.body, labels);
+        case "lookup": return `const ${localName(unit, statement.local)} = l${statement.lookup}(${value(statement.entity)});`;
+        case "probe": return `l${statement.lookup}.probe(${[statement.probe, localName(unit, statement.list), localName(unit, statement.first), ...statement.values.map(value)].join(", ")});`;
+        case "listRow": return `l${statement.lookup}.row(${localName(unit, statement.row)}, ${localName(unit, statement.list)}, ${value(statement.index)});`;
+        case "spawn": return `const ${localName(unit, statement.local)} = spawn${statement.list}(${statement.values.map(value).join(", ")});`;
+        case "begin": return `commands.begin(${statement.command}, ${value(statement.entity)});`;
+        case "value": return `commands.value(${statement.key}, ${value(statement.value)});`;
+        case "component": return `commands.component(${statement.key});`;
+    }
+};
+
+/** Prints statements as JS. */
+export const printStatements = (unit: Unit, statements: Out | readonly Statement[], labels: Labels = new Map()): string =>
+    resolve([...statements]).map(statement => printStatement(unit, statement, labels)).join("\n");