@adobe/ecs 0.2.0 → 0.2.3

package/src/implementation/world/run-results.test.ts

@@ -30,11 +30,11 @@ const spawn = System.create(({ commands }) => {
 const raise = System.create(({ resources }) => {
     resources[level] += 1;
 });
-const count = System.create({ observer: true, components: { with: [amount] } }, () => {
+const count = System.create({ readonly: true, components: { with: [amount] } }, () => {
     counted++;
 });
 let counted = 0;
-const readLevel = System.create({ observer: true }, ({ resources }) => resources[level]);
+const readLevel = System.create({ readonly: true }, ({ resources }) => resources[level]);
 const broken = System.create(() => {
     throw new Error("broken");
 });
@@ -57,7 +57,7 @@ describe("a run", () => {
         expect(await world.run(System.create({ components: { with: [amount] } }, row => row[amount]))).toBeUndefined();
         expect(await world.run(System.create([readLevel, raise]))).toBeUndefined();
         expect(await world.run(raise)).toBeUndefined();
-        const whenChanged = System.create({ observer: true, resources: { changed: [level] } }, ({ resources }) => resources[level]);
+        const whenChanged = System.create({ readonly: true, resources: { changed: [level] } }, ({ resources }) => resources[level]);
         expect(await world.run(whenChanged)).toBe(2);
         // Unchanged since it last ran: skipped.
         expect(await world.run(whenChanged)).toBeUndefined();
@@ -94,7 +94,7 @@ describe("a run", () => {
     it("rejects when its own observer system fails, and reports one added out of band", async () => {
         using reported = catchOutOfBand();
         await using world = inline();
-        const failingObserver = System.create({ observer: true }, () => {
+        const failingObserver = System.create({ readonly: true }, () => {
             throw new Error("observer failed");
         });
         await expect(world.run(failingObserver)).rejects.toThrow(/observer failed/);
@@ -144,7 +144,7 @@ const spawnTwins = System.create(({ commands }) => {
     commands.spawn([serial])({ [serial]: 1 });
     commands.spawn([serial])({ [serial]: 1 });
 });
-const findTwin = System.create({ observer: true, lookup: { twins: { index: bySerial } } }, ({ lookup }) => lookup.twins(1)?.entity ?? null);
+const findTwin = System.create({ readonly: true, lookup: { twins: { index: bySerial } } }, ({ lookup }) => lookup.twins(1)?.entity ?? null);
 const setGate = System.create({}, ({ resources }, input: { readonly open: boolean }) => {
     resources[gate] = input.open;
 });
@@ -207,10 +207,10 @@ describe("a run's observer pass", () => {
     it("fails the run for its own observer system, and reports one added out of band, in one run", async () => {
         using reported = catchOutOfBand();
         await using world = inline();
-        const ownFails = System.create({ observer: true }, () => {
+        const ownFails = System.create({ readonly: true }, () => {
             throw new Error("own failed");
         });
-        const addedFails = System.create({ observer: true }, () => {
+        const addedFails = System.create({ readonly: true }, () => {
             throw new Error("added failed");
         });
         world.add(addedFails);
@@ -255,7 +255,7 @@ describe("out-of-band reports", () => {
     it("aren't made again for a system skipped between its failures", async () => {
         using reported = catchOutOfBand();
         await using world = inline();
-        const failsWhenChanged = System.create({ observer: true, resources: { changed: [level] } }, () => {
+        const failsWhenChanged = System.create({ readonly: true, resources: { changed: [level] } }, () => {
             throw new Error("changed failed");
         });
         world.add(failsWhenChanged);
@@ -294,7 +294,7 @@ describe("out-of-band reports", () => {
         using reported = catchOutOfBand();
         const world = inline();
         let failing = false;
-        const failsAdded = System.create({ observer: true }, () => {
+        const failsAdded = System.create({ readonly: true }, () => {
             if (failing) throw new Error("added failed");
         });
         world.add(failsAdded);
@@ -331,7 +331,7 @@ describe("out-of-band reports", () => {
     it("aren't made again for a row system whose change filter passed no row between its failures", async () => {
         using reported = catchOutOfBand();
         await using world = inline();
-        const failsOnChange = System.create({ observer: true, components: { with: [amount], changed: [amount] } }, () => {
+        const failsOnChange = System.create({ readonly: true, components: { with: [amount], changed: [amount] } }, () => {
             throw new Error("row failed");
         });
         const bump = System.create({ components: { with: [amount] } }, row => {

package/src/implementation/world/runner.ts

@@ -260,7 +260,7 @@ export const createRunner = (state: State, leaf: Leaf, since = 0): Runner => {
         : createOrderedRender(indexLookups.ordered, ordered, accessors.map(accessor => idOf(state, accessor.component)), declaration.shader?.group ?? 0, `${leafNumber}:`);
     const touches = [...new Set([...query?.read ?? [], ...query?.write ?? []])].map(key => idOf(state, key));
     const writes = (query?.write ?? []).map(key => idOf(state, key));
-    const looks = [...new Set([...Object.values(declaration.lookup ?? {}).flatMap(lookup => lookup.read ?? []), ...declaration.up?.read ?? []])].map(key => idOf(state, key));
+    const looks = [...new Set([...Object.values(declaration.lookup ?? {}).flatMap(lookup => lookup.read ?? []), ...declaration.up?.read ?? [], ...declaration.tables?.components ?? []])].map(key => idOf(state, key));
     /** Record keys by archetype. */
     const keys = new Map<Archetype, string>();
     const keyOf = (archetype: Archetype): string => {
@@ -339,7 +339,7 @@ export const createRunner = (state: State, leaf: Leaf, since = 0): Runner => {
     let runInput: unknown;
     const context = createContext(state, declaration, {
         targets: kernel === null ? targets : [],
-        commands: leaf.kind === "render" || declaration.kernel === "gpu" || declaration.observer === true ? undefined : commands,
+        commands: leaf.kind === "render" || declaration.kernel === "gpu" || declaration.readonly === true ? undefined : commands,
         indexes: indexLookups.byName,
         since: lookupSince,
     });
@@ -1343,7 +1343,7 @@ export const createRunner = (state: State, leaf: Leaf, since = 0): Runner => {
             return taken;
         },
         didRun: () => ran && (query === undefined || bodyRanOnRow()),
-        restart: declaration.observer !== true || !holdsNothing(holdings) ? null : since => {
+        restart: declaration.readonly !== true || !holdsNothing(holdings) ? null : since => {
             lastRun = since;
             holdings.removed = false;
             holdings.released = false;

package/src/implementation/world/shared-gpu.browser.test.ts

@@ -59,7 +59,7 @@ const fractions = System.create({ kernel: "gpu", components: { with: [scale, val
 });
 const fractionsOf = async (world: ReturnType<typeof createWorld>): Promise<readonly (readonly number[])[]> => {
     const read: [number, number[]][] = [];
-    await world.run(System.create({ observer: true, components: { with: [value, copied, product, sum, compound] } }, row => { read.push([row[value], [row[copied], row[product], row[sum], row[compound], row[value]]]); }));
+    await world.run(System.create({ readonly: true, components: { with: [value, copied, product, sum, compound] } }, row => { read.push([row[value], [row[copied], row[product], row[sum], row[compound], row[value]]]); }));
     return read.sort((a, b) => a[0] - b[0]).map(([, values]) => values);
 };
 
@@ -71,7 +71,7 @@ const device = async (): Promise<GPUDevice> => {
 
 const results = async (world: ReturnType<typeof createWorld>): Promise<readonly string[]> => {
     const read: [number, string][] = [];
-    await world.run(System.create({ observer: true, components: { with: [value, out, steps] } }, row => { read.push([row[value], `${row[out]} ${row[steps]}`]); }));
+    await world.run(System.create({ readonly: true, components: { with: [value, out, steps] } }, row => { read.push([row[value], `${row[out]} ${row[steps]}`]); }));
     return read.sort((a, b) => a[0] - b[0]).map(([, text]) => text);
 };
 

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

@@ -62,7 +62,7 @@ const wideOnGpu = System.create({ kernel: "gpu", components: { with: [wide, out]
 /** Every row's results, by its value. */
 const results = async (world: ReturnType<typeof createWorld>): Promise<readonly string[]> => {
     const read: [number, string][] = [];
-    await world.run(System.create({ observer: true, components: { with: [value, out, steps] } }, row => { read.push([row[value], `${row[out]} ${row[steps]}`]); }));
+    await world.run(System.create({ readonly: true, components: { with: [value, out, steps] } }, row => { read.push([row[value], `${row[out]} ${row[steps]}`]); }));
     return read.sort((a, b) => a[0] - b[0]).map(([, text]) => text);
 };
 
@@ -98,7 +98,7 @@ describe("a kernel reading a shared component", () => {
         await world.run(spawn);
         expect((await runReported(world, moving)).failures).toEqual([]);
         const scales: number[] = [];
-        await world.run(System.create({ observer: true, components: { with: [scale] } }, row => { scales.push(row[scale]); }));
+        await world.run(System.create({ readonly: true, components: { with: [scale] } }, row => { scales.push(row[scale]); }));
         expect(new Set(scales)).toEqual(new Set([2]));
         // A kernel built without knowing a component is shared, naming it in a command, fails where it registers.
         const description = kernelOf(compute);

package/src/implementation/world/shared-workers.fixture.ts

@@ -39,7 +39,7 @@ const written = System.create({ kernel: false, components: { with: [scale, cell,
     row[steps] = x * 1000 + y;
 });
 const read: [number, string][] = [];
-const results = System.create({ observer: true, components: { with: [value, out, steps] } }, row => { read.push([row[value], `${row[out]} ${row[steps]}`]); });
+const results = System.create({ readonly: true, components: { with: [value, out, steps] } }, row => { read.push([row[value], `${row[out]} ${row[steps]}`]); });
 
 const outcome = async (system: typeof compute, wasm: boolean): Promise<readonly string[]> => {
     await using world = createWorld({ [workers]: 2 }, { minimumChunk: 2, wasm });
@@ -66,7 +66,7 @@ export const whereOnWorkers = async (wasm: boolean): Promise<{ readonly written:
     await world.run(negative);
     let written = 0;
     let left = 0;
-    await world.run(System.create({ observer: true, components: { with: [value, out] } }, row => {
+    await world.run(System.create({ readonly: true, components: { with: [value, out] } }, row => {
         if (row[out] === 0 && row[value] !== 0) left++;
         else written++;
     }));

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

@@ -39,7 +39,7 @@ const inline = () => createWorld({ [workers]: 0 });
 
 // Systems a joined thread runs, which it names by the ids the build gives them at the top level.
 const heard: string[] = [];
-export const listen = System.create({ observer: true, components: { with: [team, health] } }, row => { heard.push(`${row[team]} ${row[health]}`); });
+export const listen = System.create({ readonly: true, components: { with: [team, health] } }, row => { heard.push(`${row[team]} ${row[health]}`); });
 export const spawnBanners = System.create(({ commands }) => {
     commands.spawn([team, health, banner], { [team]: "red" })({ [health]: 1 });
     commands.spawn([team, health, banner], { [team]: "blue" })({ [health]: 2 });
@@ -60,11 +60,11 @@ export const spawnThere = System.create({ components: { with: [banner] } }, (row
     commands.spawn([health, marker], base)({ [marker]: 1 });
     commands.spawn([health], base)({});
 });
-export const readBanners = System.create({ observer: true, components: { with: [banner] } }, row => { banners.push(row[banner]?.text ?? "none"); });
+export const readBanners = System.create({ readonly: true, components: { with: [banner] } }, row => { banners.push(row[banner]?.text ?? "none"); });
 
 /** Every entity's team and health, and whether it's armed, sorted by health. */
 const rowsOf = async (world: ReturnType<typeof inline>): Promise<readonly string[]> => {
-    const read = System.create({ observer: true, components: { with: [team, health], optional: [armed] } }, (row) => {
+    const read = System.create({ readonly: true, components: { with: [team, health], optional: [armed] } }, (row) => {
         found.push(`${row[team]} ${row[health]}${row[armed] === true ? " armed" : ""}`);
     });
     const found: string[] = [];
@@ -116,7 +116,7 @@ describe("a shared component", () => {
         // Three cells' worth of [1, 2] and [2, 1], three weights and one style.
         expect((await world.tables()).archetypes - before).toBe(2 + 3 + 1);
         const read: string[] = [];
-        await world.run(System.create({ observer: true, components: { with: [health], optional: [cell, weight, style] } }, row => {
+        await world.run(System.create({ readonly: true, components: { with: [health], optional: [cell, weight, style] } }, row => {
             if (row[health] === 0) return;
             read.push(`${row[health]}: ${JSON.stringify(row[cell] ?? row[style] ?? null)} ${String(row[weight])}`);
         }));
@@ -216,8 +216,8 @@ describe("a shared component", () => {
             commands.spawn([team, health], { [team]: "red" })({ [health]: 2 });
         }));
         const changes: string[] = [];
-        const watch = System.create({ observer: true, components: { with: [health], changed: [team] } }, row => { changes.push(`changed ${row[health]}`); });
-        const adds = System.create({ observer: true, components: { with: [health], added: [team] } }, row => { changes.push(`added ${row[health]}`); });
+        const watch = System.create({ readonly: true, components: { with: [health], changed: [team] } }, row => { changes.push(`changed ${row[health]}`); });
+        const adds = System.create({ readonly: true, components: { with: [health], added: [team] } }, row => { changes.push(`added ${row[health]}`); });
         world.add(watch);
         world.add(adds);
         await world.run(System.create(() => {}));
@@ -294,7 +294,7 @@ describe("a shared component", () => {
         }));
         await world.run(System.create({ components: { with: [weight, health] } }, row => { row[health] *= row[weight]; }));
         const read: number[] = [];
-        await world.run(System.create({ observer: true, components: { with: [health] } }, row => { read.push(row[health]); }));
+        await world.run(System.create({ readonly: true, components: { with: [health] } }, row => { read.push(row[health]); }));
         expect(read.sort()).toEqual([2, 3]);
     });
 
@@ -338,7 +338,7 @@ describe("a shared component", () => {
         await world.run(writeBanners);
         await world.run(spawnThere);
         const found: string[] = [];
-        await world.run(System.create({ observer: true, components: { with: [health], optional: [marker, team] } }, row => {
+        await world.run(System.create({ readonly: true, components: { with: [health], optional: [marker, team] } }, row => {
             if (row[team] === undefined) found.push(`${row[health]} ${row[marker] ?? "none"}`);
         }));
         expect(found.sort()).toEqual(["7 1", "7 1", "7 none", "7 none"]);

package/src/implementation/world/sharing.ts

@@ -613,7 +613,7 @@ export const createSharing = (host: SharingHost) => {
             const { components, resources } = declared;
             // Unnamed, so other systems' labels stay as they are; its own is the thread's.
             const declaration: Resolved = {
-                observer: true,
+                readonly: true,
                 // Its `where` runs on its thread; here, an empty one says it has one, which every archetype passes.
                 ...components === null ? {} : { components: { ...listed([["read", components.read], ["has", components.has], ["optional", components.optional], ["not", components.not], ["added", components.added], ["changed", components.changed]]), ...components.where ? { where: {} } : {} } },
                 ...resources === null ? {} : { resources: listed([["read", resources.read], ["changed", resources.changed], ["is", resources.is], ["not", resources.not]]) },

package/src/implementation/world/staging.ts

@@ -69,14 +69,15 @@ export const createBatch = (layouts: readonly Layout[], ids: readonly number[],
     return { ids: sorted, shared, archetype: null, columns: sorted.map(id => columnOf(layouts[id], id, initialCapacity)), entities: new Float64Array(initialCapacity), count: 0, capacity: initialCapacity, revive: null, generation: 0 };
 };
 
-const grow = (batch: SpawnBatch): void => {
+/** Grows a batch to hold at least `needed` rows: twice its capacity, or `needed` where that's more. */
+const grow = (batch: SpawnBatch, needed = batch.count + 1): void => {
     const { revive } = batch;
     if (revive !== null) {
         batch.revive = null;
         revive();
-        if (batch.count < batch.capacity) return;
+        if (needed <= batch.capacity) return;
     }
-    const capacity = batch.capacity * 2;
+    const capacity = Math.max(batch.capacity * 2, needed);
     for (const column of batch.columns) {
         const views = viewsOf(new ArrayBuffer(capacity * column.stride), 0, capacity * column.stride);
         views.u8.set(column.views.u8.subarray(0, batch.count * column.stride));
@@ -146,6 +147,18 @@ export const openRow = (batch: SpawnBatch): number => {
     return batch.count;
 };
 
+/** The first of the `n` rows the batch's next spawns write, growing it first to hold them. */
+export const openRows = (batch: SpawnBatch, n: number): number => {
+    if (batch.count + n > batch.capacity) grow(batch, batch.count + n);
+    return batch.count;
+};
+
+/** Claims the open rows for `entities`, once all their values are written. */
+export const claimRows = (batch: SpawnBatch, entities: Float64Array): void => {
+    batch.entities.set(entities, batch.count);
+    batch.count += entities.length;
+};
+
 /** Claims the open row for `entity`, once all its values are written. */
 export const claim = (batch: SpawnBatch, entity: number): void => {
     batch.entities[batch.count] = entity;

package/src/implementation/world/tables-read.ts

@@ -0,0 +1,59 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { labelOf } from '../../interface/registry/names.js';
+import type { Tables, TablesDeclaration } from '../../interface/system/tables.js';
+import type { Table } from '../../interface/world/table/table.js';
+import type { Storage } from './archetype.js';
+import { readCell } from './cells.js';
+import { resourceCell } from './resources.js';
+import { idOf, type Key, type State } from './state.js';
+
+// Reading tables, apart from spawning them: rows' contexts import it, and what spawning imports would make a cycle.
+
+/** What an archetype's storage of a component gives a table: a copy of its rows `0` to `count`. */
+const columnOf = (key: Key, storage: Storage, count: number): Table.Column => {
+    const { layout } = storage;
+    switch (layout.kind) {
+        case "linear": return { kind: "bytes", bytes: storage.views.u8.slice(0, count * layout.stride), stride: layout.stride };
+        case "constant": return { kind: "value", value: layout.value };
+        case "object":
+            if (storage.remote !== null) throw new Error(`Tables can't read "${labelOf(key)}": a joined thread fills its objects.`);
+            return { kind: "values", values: storage.values.slice(0, count) };
+        case "string": {
+            const values: unknown[] = new Array(count);
+            for (let row = 0; row < count; row++) values[row] = readCell(storage, row);
+            return { kind: "values", values };
+        }
+    }
+};
+
+/**
+ * A readonly system's `tables`: of each archetype matching `with` and `not` and holding any of `components`, its
+ * entities and a copy of the column of each of them it holds; and the value of each resource of `resources`.
+ */
+export const readTables = (state: State, declaration: TablesDeclaration): Tables => {
+    const asked = declaration.components.map(key => ({ key, id: idOf(state, key) }));
+    const required = (declaration.with ?? []).map(key => idOf(state, key));
+    const excluded = (declaration.not ?? []).map(key => idOf(state, key));
+    const archetypes: Table[] = [];
+    for (const archetype of state.archetypes) {
+        const { count } = archetype;
+        if (count === 0 || archetype.reclaimed) continue;
+        const { storageById } = archetype;
+        if (required.some(id => storageById[id] === undefined) || excluded.some(id => storageById[id] !== undefined)) continue;
+        const columns: { [key: symbol]: Table.Column } = {};
+        let held = false;
+        for (const { key, id } of asked) {
+            const storage = storageById[id];
+            if (storage === undefined) continue;
+            columns[key] = columnOf(key, storage, count);
+            held = true;
+        }
+        if (held) archetypes.push({ count, entities: archetype.entities.slice(0, count), columns });
+    }
+    const resources: { [key: symbol]: unknown } = {};
+    for (const key of declaration.resources ?? []) {
+        const cell = resourceCell(state, key);
+        resources[key] = readCell(cell.storage, cell.row);
+    }
+    return { archetypes, resources };
+};

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

@@ -0,0 +1,267 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it } from "vitest";
+import { clock, Component, Entity, Resource, System, workers } from "../../index.js";
+import type { Vec3 } from "../../interface/math/index.js";
+import type { Tables } from "../../interface/system/tables.js";
+import type { Table } from "../../interface/world/table/table.js";
+import { createWorld } from "./create.js";
+
+const position = Symbol("tablesTest/position");
+const label = Symbol("tablesTest/label");
+const tags = Symbol("tablesTest/tags");
+const team = Symbol("tablesTest/team");
+const pinned = Symbol("tablesTest/pinned");
+const parent = Symbol("tablesTest/parent");
+const target = Symbol("tablesTest/target");
+const link = Symbol("tablesTest/link");
+const friends = Symbol("tablesTest/friends");
+const hidden = Symbol("tablesTest/hidden");
+const buddy = Symbol("tablesTest/buddy");
+const score = Symbol("tablesTest/score");
+const title = Symbol("tablesTest/title");
+declare module "@adobe/ecs" {
+    interface Components {
+        [position]: { type: Vec3 };
+        [label]: { type: string };
+        [tags]: { type: readonly string[] };
+        [team]: { type: "red" | "blue"; shared: true };
+        [pinned]: { type: true };
+        [parent]: { type: Entity; reference: "owner" };
+        [target]: { type: Entity; reference: "weak" };
+        [link]: { type: { readonly to: Entity; readonly weight: number } };
+        [friends]: { type: readonly Entity[] };
+        [hidden]: { type: true };
+        [buddy]: { type: Entity };
+    }
+    interface Resources {
+        [score]: { type: number; default: 0 };
+        [title]: { type: string; default: "" };
+    }
+}
+
+const inline = () => createWorld({ [workers]: 0 });
+
+/** A readonly system's tables of these components. */
+const tablesOf = (components: readonly Component.Key[], resources: readonly Resource.Key[] = [], not: readonly Component.Key[] = []) =>
+    System.create({ readonly: true, tables: { components, resources, not } }, ({ tables }): Tables => tables);
+
+const spawnedBy: { spawned: Table.Spawned } = { spawned: { entities: [], dropped: 0 } };
+const given: { tables: readonly Table[]; resources?: { readonly [key: symbol]: unknown } } = { tables: [] };
+const spawnGiven = System.create(({ commands }) => {
+    spawnedBy.spawned = given.resources === undefined ? commands.spawnTables(given.tables) : commands.spawnTables(given.tables, given.resources);
+});
+const spawnTables = async (world: ReturnType<typeof inline>, tables: readonly Table[]): Promise<Table.Spawned> => {
+    given.tables = tables;
+    await world.run(spawnGiven);
+    return spawnedBy.spawned;
+};
+
+const values = System.create({ readonly: true, components: { with: [label], optional: [position, parent, target, link, friends, tags, buddy] } }, row => {
+    found.push({ entity: row.entity, label: row[label], position: row[position], parent: row[parent], target: row[target], link: row[link], friends: row[friends], tags: row[tags], buddy: row[buddy] });
+});
+type Found = { entity: Entity; label: string; position?: Vec3; parent?: Entity; target?: Entity; link?: { readonly to: Entity; readonly weight: number }; friends?: readonly Entity[]; tags?: readonly string[]; buddy?: Entity };
+const found: Found[] = [];
+const readAll = async (world: ReturnType<typeof inline>): Promise<Found[]> => {
+    found.length = 0;
+    await world.run(values);
+    return [...found].sort((a, b) => a.label.localeCompare(b.label));
+};
+
+describe("tables", () => {
+    it("give each archetype holding a component asked for, its entities, and a copy of each column in the world's layout", async () => {
+        await using world = inline();
+        await world.run(System.create(({ commands }) => {
+            commands.spawn([position, label])({ [position]: [1, 2, 3], [label]: "a" });
+            commands.spawn([position, label, tags])({ [position]: [4, 5, 6], [label]: "b", [tags]: ["x", "y"] });
+            commands.spawn([team, label], { [team]: "red" })({ [label]: "c" });
+            commands.spawn([pinned])();
+        }));
+        const { archetypes } = await world.run(tablesOf([position, label, tags, team, pinned]));
+        expect(archetypes.map(table => table.count)).toEqual([1, 1, 1, 1]);
+        const plain = archetypes.find(table => table.columns[tags] === undefined && table.columns[position] !== undefined);
+        const bytes = plain?.columns[position];
+        expect(bytes?.kind === "bytes" && [...new Float32Array(bytes.bytes.buffer, bytes.bytes.byteOffset, 3)]).toEqual([1, 2, 3]);
+        expect(bytes?.kind === "bytes" && bytes.stride).toBe(12);
+        const withTags = archetypes.find(table => table.columns[tags] !== undefined);
+        expect(withTags?.columns[tags]).toEqual({ kind: "values", values: [["x", "y"]] });
+        expect(withTags?.columns[label]).toEqual({ kind: "values", values: ["b"] });
+        const shared = archetypes.find(table => table.columns[team] !== undefined);
+        expect(shared?.columns[team]).toEqual({ kind: "value", value: "red" });
+        expect(archetypes.find(table => table.columns[pinned] !== undefined)?.columns[pinned]).toEqual({ kind: "value", value: true });
+    });
+
+    it("leave out archetypes not matching with and not, and give the values of resources asked for", async () => {
+        await using world = createWorld({ [workers]: 0, [score]: 7, [title]: "won" });
+        await world.run(System.create(({ commands }) => {
+            commands.spawn([label])({ [label]: "shown" });
+            commands.spawn([label, hidden])({ [label]: "hidden" });
+        }));
+        const { archetypes, resources } = await world.run(tablesOf([label], [score, title], [hidden]));
+        expect(archetypes.map(table => table.columns[label])).toEqual([{ kind: "values", values: ["shown"] }]);
+        expect(resources[score]).toBe(7);
+        expect(resources[title]).toBe("won");
+    });
+
+    it("spawn back as they were read, shared values and strings included", async () => {
+        await using from = inline();
+        await from.run(System.create(({ commands }) => {
+            commands.spawn([position, label, tags])({ [position]: [1, 2, 3], [label]: "a", [tags]: ["t"] });
+            commands.spawn([team, label], { [team]: "blue" })({ [label]: "b" });
+        }));
+        const { archetypes } = await from.run(tablesOf([position, label, tags, team]));
+        await using into = inline();
+        const { entities, dropped } = await spawnTables(into, archetypes);
+        expect([entities.map(list => list.length), dropped]).toEqual([[1, 1], 0]);
+        const again = await into.run(tablesOf([position, label, tags, team]));
+        expect(again.archetypes.map(table => ({ ...table, entities: [] }))).toEqual(archetypes.map(table => ({ ...table, entities: [] })));
+        expect(await readAll(into)).toMatchObject([{ label: "a", position: [1, 2, 3], tags: ["t"] }, { label: "b" }]);
+    });
+
+    it("rewrite entities in references, struct fields and arrays to those spawned for them, self references and cycles included", async () => {
+        await using from = inline();
+        await from.run(System.create(({ commands }) => {
+            const root = commands.spawn([label])({ [label]: "root" });
+            const child = commands.spawn([label, parent])({ [label]: "child", [parent]: root });
+            commands.spawn([label, target, link, friends])({ [label]: "other", [target]: child, [link]: { to: root, weight: 2 }, [friends]: [root, child] });
+            const a = commands.spawn([label, link])({ [label]: "self", [link]: { to: Entity.none, weight: 1 } });
+            commands.add(a, link, { to: a, weight: 1 });
+        }));
+        const before = await readAll(from);
+        const { archetypes } = await from.run(tablesOf([label, parent, target, link, friends]));
+        await using into = inline();
+        // Entities already in the world, so the new ones differ from the old.
+        await into.run(System.create(({ commands }) => { for (let i = 0; i < 5; i++) commands.spawn([pinned])(); }));
+        await spawnTables(into, archetypes);
+        const after = await readAll(into);
+        const old = new Map(before.map(entry => [entry.entity, entry.label]));
+        const now = new Map(after.map(entry => [entry.label, entry.entity]));
+        const translated = (entity: Entity | undefined): Entity | undefined => entity === undefined ? undefined : now.get(old.get(entity) ?? "");
+        expect(after.map(entry => entry.label)).toEqual(before.map(entry => entry.label));
+        for (const entry of before) {
+            const moved = after.find(other => other.label === entry.label);
+            expect(moved?.entity).not.toBe(entry.entity);
+            expect(moved?.parent).toBe(translated(entry.parent));
+            expect(moved?.target).toBe(translated(entry.target));
+            expect(moved?.link?.to).toBe(translated(entry.link?.to));
+            expect(moved?.friends).toEqual(entry.friends?.map(translated));
+        }
+        expect(after.find(entry => entry.label === "self")?.link?.to).toBe(now.get("self"));
+    });
+
+    it("leave out a weak reference to an entity outside the tables, its holder spawned without it", async () => {
+        await using world = inline();
+        await world.run(System.create(({ commands }) => {
+            const outside = commands.spawn([pinned])();
+            const inside = commands.spawn([label])({ [label]: "inside" });
+            commands.spawn([label, target])({ [label]: "away", [target]: outside });
+            commands.spawn([label, target])({ [label]: "near", [target]: inside });
+        }));
+        const { archetypes } = await world.run(tablesOf([label, target]));
+        await using other = inline();
+        expect((await spawnTables(other, archetypes)).dropped).toBe(0);
+        const read = await readAll(other);
+        expect(read.map(entry => [entry.label, entry.target === undefined ? "none" : read.find(found => found.entity === entry.target)?.label])).toEqual([["away", "none"], ["inside", "none"], ["near", "inside"]]);
+    });
+
+    it("spawn no row owned, directly or through others, by an entity outside the tables, saying how many", async () => {
+        await using world = inline();
+        await world.run(System.create(({ commands }) => {
+            const outside = commands.spawn([pinned])();
+            const top = commands.spawn([label, parent])({ [label]: "top", [parent]: outside });
+            const middle = commands.spawn([label, parent])({ [label]: "middle", [parent]: top });
+            commands.spawn([label, parent])({ [label]: "bottom", [parent]: middle });
+            const kept = commands.spawn([label])({ [label]: "kept" });
+            commands.spawn([label, parent, target])({ [label]: "kept child", [parent]: kept, [target]: middle });
+        }));
+        const { archetypes } = await world.run(tablesOf([label, parent, target]));
+        await using other = inline();
+        const { entities, dropped } = await spawnTables(other, archetypes);
+        expect(dropped).toBe(3);
+        expect(entities.flatMap(list => [...list]).filter(entity => entity === Entity.none).length).toBe(3);
+        const read = await readAll(other);
+        // The kept child's weak target was dropped, so it's spawned without it.
+        expect(read.map(entry => [entry.label, entry.parent === undefined ? null : read.find(found => found.entity === entry.parent)?.label, entry.target ?? null])).toEqual([["kept", null, null], ["kept child", "kept", null]]);
+    });
+
+    it("make any other entity value naming an entity outside the tables none: a whole component, a struct's field and an array's item", async () => {
+        await using world = inline();
+        await world.run(System.create(({ commands }) => {
+            const outside = commands.spawn([pinned])();
+            const inside = commands.spawn([label])({ [label]: "inside" });
+            commands.spawn([label, buddy, link, friends])({ [label]: "pointing", [buddy]: outside, [link]: { to: outside, weight: 1 }, [friends]: [outside, inside] });
+        }));
+        const { archetypes } = await world.run(tablesOf([label, buddy, link, friends]));
+        await using other = inline();
+        await spawnTables(other, archetypes);
+        const read = await readAll(other);
+        const inside = read.find(entry => entry.label === "inside")?.entity;
+        expect(read.find(entry => entry.label === "pointing")).toMatchObject({ buddy: Entity.none, link: { to: Entity.none, weight: 1 }, friends: [Entity.none, inside] });
+    });
+
+    it("set the resources they're given at the sync point, beside the entities", async () => {
+        await using world = createWorld({ [workers]: 0, [score]: 7 });
+        given.tables = [];
+        given.resources = { [score]: 12, [title]: "loaded" };
+        try {
+            await world.run(spawnGiven);
+        }
+        finally {
+            given.resources = undefined;
+        }
+        const { resources } = await world.run(tablesOf([label], [score, title]));
+        expect(resources[score]).toBe(12);
+        expect(resources[title]).toBe("loaded");
+    });
+
+    it("refuse a resource only the world writes or a value its type doesn't take, spawning nothing", async () => {
+        await using world = inline();
+        const table: Table = { count: 1, entities: new Float64Array([1]), columns: { [label]: { kind: "values", values: ["kept out"] } } };
+        given.tables = [table];
+        try {
+            given.resources = { [clock]: { now: 0, delta: 0, tick: 0 } };
+            await expect(world.run(spawnGiven)).rejects.toThrow(/clock" is written only by the world/);
+            given.resources = { [score]: "twelve" };
+            await expect(world.run(spawnGiven)).rejects.toThrow(/score" is given a value its type doesn't take/);
+            given.resources = { [position]: [0, 0, 0] };
+            await expect(world.run(spawnGiven)).rejects.toThrow(/position" isn't a registered resource/);
+        }
+        finally {
+            given.resources = undefined;
+        }
+        expect(await readAll(world)).toEqual([]);
+        expect((await world.run(tablesOf([label], [score]))).resources[score]).toBe(0);
+    });
+
+    it("fail a column that doesn't fit its component's layout or its table's count", async () => {
+        await using world = inline();
+        const table = (columns: Table["columns"], count = 1): Table => ({ count, entities: new Float64Array(count).fill(1), columns });
+        given.tables = [table({ [position]: { kind: "bytes", bytes: new Uint8Array(8), stride: 8 } })];
+        await expect(world.run(spawnGiven)).rejects.toThrow(/stride of 12 bytes in this world, not 8/);
+        given.tables = [table({ [position]: { kind: "bytes", bytes: new Uint8Array(24), stride: 12 } })];
+        await expect(world.run(spawnGiven)).rejects.toThrow(/gives 24 bytes for 1 rows of 12/);
+        given.tables = [table({ [label]: { kind: "values", values: ["a", "b"] } })];
+        await expect(world.run(spawnGiven)).rejects.toThrow(/gives 2 values for 1 rows/);
+        given.tables = [table({ [team]: { kind: "values", values: ["red"] } })];
+        await expect(world.run(spawnGiven)).rejects.toThrow(/shared component, so its column is one value/);
+        // Two rows of one entity can't both be what a reference to it names.
+        given.tables = [table({ [friends]: { kind: "values", values: [[]] } }, 1), table({ [friends]: { kind: "values", values: [[]] } }, 1)];
+        await expect(world.run(spawnGiven)).rejects.toThrow(/entity 1 is in two rows/);
+        expect(await readAll(world)).toEqual([]);
+    });
+
+    it("are read only by a readonly system without components", () => {
+        // @ts-expect-error: tables are read only by a readonly system, which the declaration's type says too.
+        expect(() => System.create({ tables: { components: [label] } }, () => {})).toThrow(/reads tables, which only a readonly system reads/);
+    });
+});
+
+describe("declarations", () => {
+    it("give every component and resource registered, with its schema and traits", () => {
+        const declared = Component.declarations().get(parent);
+        expect(declared?.type).toEqual({ type: "integer", format: "entity" });
+        expect(declared?.reference).toBe("owner");
+        expect(Resource.declarations().get(score)?.default).toBe(0);
+        const components: readonly symbol[] = [...Component.declarations().keys()];
+        expect(components.includes(score)).toBe(false);
+    });
+});