@adobe/ecs 0.2.1 → 0.2.4

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

@@ -149,8 +149,8 @@ const emitted = { seen: 0 };
 const countEmitted = System.create({ components: { added: [position], with: [spawned] } }, () => { emitted.seen++; });
 
 const gathered: Entity[] = [];
-const gatherPositioned = System.create({ observer: true, components: { with: [position] } }, row => { gathered.push(row.entity); });
-const gatherSpawned = System.create({ observer: true, components: { with: [spawned] } }, row => { gathered.push(row.entity); });
+const gatherPositioned = System.create({ readonly: true, components: { with: [position] } }, row => { gathered.push(row.entity); });
+const gatherSpawned = System.create({ readonly: true, components: { with: [spawned] } }, row => { gathered.push(row.entity); });
 
 /** The entities an observer row system passes, in storage order. */
 const storageOrder = async (world: World, gather: System<void>): Promise<Entity[]> => {

package/src/index.ts

@@ -3,9 +3,6 @@
  * A high-performance, multithreaded Entity Component System.
  * @module @adobe/ecs
  */
-import { create, join } from './implementation/index.js';
-import type { Create } from './interface/world/create.js';
-import type { Join } from './interface/world/join.js';
 import type { World as Created } from './interface/world/world.js';
 
 export * from './interface/index.js';
@@ -15,30 +12,8 @@ export type World = Created;
 
 /**
  * How a world is made, `World.create(resources?)`, on the thread that will run it, with resources starting at the given
- * values in place of their defaults; and how another thread joins one that shared itself with it,
- * `World.join(port, { threads })`.
+ * values in place of their defaults; how another thread joins one that shared itself with it,
+ * `World.join(port, { threads })`; and `World.Table`, an archetype's rows as a readonly system's `tables` copies them
+ * and `commands.spawnTables` spawns them.
  */
-export const World: {
-    /**
-     * Creates a world on this thread, synchronously, with resources starting at the given values in place of their
-     * defaults. This thread is its `"world"` thread for the world's life: it runs the sync points, the ticks and the GPU
-     * device, and fills every logical thread no joined thread claims. Keys are the resources' symbols, built-in ones
-     * included (`{ [workers]: 0 }`); string keys are never a resource's, so they're ignored. Throws for a symbol that isn't
-     * a resource, or is one only the world writes. While a declaration's trait or default doesn't hold, each call fails to
-     * compile, once, naming each such key, its members and what's wrong with them.
-     */
-    readonly create: Create;
-    /**
-     * Joins, from another thread, a world that `share` let join through the other end of `port`, claiming the logical
-     * `threads` this thread fills: their objects live here, and the systems and finalizers reading them run here. Resolves,
-     * once the world accepted the claim, to the same world: its `run` runs systems there, and its `add` and `remove` take
-     * observer systems, which run here after the world's sync points. Add them before awaiting anything else, so the
-     * world's `share` resolves with them in place. Its `dispose` disconnects this thread. Rejects with an `Error` saying
-     * why it didn't join: the world refused the claim, was disposed, or its thread ended first, as the platform reports it:
-     * the world's `Worker` failing to start or throwing first, a port closed, as in node, or, in a browser, the world's
-     * thread ending once it was shared through a port this thread listened on. A browser world's worker that the page ended
-     * before this thread heard from it isn't reported, so the join stays pending. Rejects too where memory can't be shared,
-     * as without cross-origin isolation.
-     */
-    readonly join: Join;
-} = { create, join };
+export * as World from './world.js';

package/src/interface/component/declarations.ts

@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Declared } from './declared.js';
+import { declaredOf } from '../registry/names.js';
+import type { Key } from './key.js';
+
+/** Every component its modules registered so far, with its declaration. */
+export const declarations = (): ReadonlyMap<Key, Declared> => {
+    // Registration takes only keys declared in `Components`, so each symbol registered as a component is one of its keys.
+    const found = declaredOf("component") as ReadonlyMap<Key, Declared>;
+    return found;
+};

package/src/interface/component/declared.ts

@@ -0,0 +1,9 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Schema } from '../schema/schema.js';
+import type { Key as TraitKey } from '../trait/key.js';
+
+/**
+ * A component's or resource's declaration as registered: its schema as `type` where its value is data, what it
+ * starts at as `default`, and its other traits, the built-in ones by name and those of your own by their keys.
+ */
+export type Declared = { readonly type?: Schema; readonly default?: unknown } & { readonly [T in TraitKey]?: unknown };

package/src/interface/component/index.ts

@@ -1,3 +1,5 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 export type { Key } from './key.js';
 export type { With } from './value.js';
+export { declarations } from './declarations.js';
+export type { Declared } from './declared.js';

package/src/interface/finalizer/body.ts

@@ -7,6 +7,8 @@ import type { LookupFunction } from '../system/values.js';
 import type { WriteResources } from '../system/body.js';
 import type { ChangesDeclaration, Declaration } from './declaration.js';
 import type { Essential, ReadonlyType } from '../component/value.js';
+import type { Resource } from '../resource/resource.js';
+import type { ReadonlyType as ResourceType } from '../resource/value.js';
 import type { Elsewhere, ThreadsOf } from '../system/threads.js';
 
 /**
@@ -29,7 +31,10 @@ export type Context<D extends Declaration | ChangesDeclaration> =
     & (true extends Elsewhere<ThreadsOf<D>> ? {} : { readonly commands: Commands });
 
 /** The components a changes finalizer sees. */
-export type Watched<D extends ChangesDeclaration> = Property<D, "watch"> extends readonly Essential[] ? Listed<D, "watch"> & Essential : Essential;
+export type Watched<D extends ChangesDeclaration> = Property<D, "watch"> extends readonly unknown[] ? Listed<D, "watch"> & Essential : Essential;
+
+/** The resources a changes finalizer sees: those it watches. */
+export type WatchedResources<D extends ChangesDeclaration> = Listed<D, "watch"> & Resource.Key;
 
 /** Entities whose components changed the same way: `from` and `to` are null for those spawned and despawned. */
 export type Group<C extends Component.Key> = {
@@ -42,9 +47,14 @@ export type Group<C extends Component.Key> = {
     readonly entities: readonly Entity[];
 };
 
-/** A sync point's structural changes to the watched components, and the values adds replace, before they apply. */
-export type ChangeSet<C extends Component.Key> = {
+/**
+ * A sync point's structural changes to the watched components, and the values adds replace, before they apply; and each
+ * watched resource written since the last sync point's finalizers ran, to a value that isn't equal to its last one,
+ * leaf by leaf for data and by identity for objects, with its value before and after.
+ */
+export type ChangeSet<C extends Component.Key, R extends Resource.Key = never> = {
     readonly groups: readonly Group<C>[];
+    readonly resources: readonly { readonly [K in R]: { readonly key: K; readonly previous: ResourceType<K>; readonly next: ResourceType<K> } }[R][];
     /** The value before the sync point, or null if the entity didn't have it. */
     previous<K extends C>(entity: Entity, component: K): ReadonlyType<K> | null;
     /** The value after it, or null if the entity won't have it. */

package/src/interface/finalizer/create.test.ts

@@ -75,7 +75,7 @@ describe("Finalizer.create and Finalizer.changes", () => {
         expect(() => untyped(Finalizer.create, { components: {} }, { resources: { reduce: [total] } })).toThrow("only systems contribute to a reduction");
         expect(() => untyped(Finalizer.create, { components: { with: [node, tags] } }, { read: [node, tags] })).toThrow('uses "typesFinalizerTest/node" on "main" and "typesFinalizerTest/tags" on "world"');
         expect(() => untyped(Finalizer.changes, { name: "derived", watch: [slot] })).toThrow("which is derived");
-        expect(() => untyped(Finalizer.changes, { name: "resource", watch: [time] })).toThrow("which isn't a registered component");
+        expect(() => untyped(Finalizer.changes, { name: "unregistered", watch: [Symbol("typesFinalizerTest/unregistered")] })).toThrow("which isn't a registered component or resource");
         expect(() => untyped(Finalizer.create, { components: { with: [time] } })).toThrow(`uses component "typesFinalizerTest/time", which isn't a registered component`);
         expect(() => untyped(Finalizer.create, { components: { with: [label] }, lookup: { others: { not: [Symbol("typesFinalizerTest/unregistered")] } } }, { read: [label] })).toThrow("which isn't a registered component");
         expect(programFinalizers()).toHaveLength(7);
@@ -93,6 +93,8 @@ describe("Finalizer.create and Finalizer.changes", () => {
             .toThrow('uses "typesFinalizerTest/tags" on "world" and "typesFinalizerTest/page" on "main"');
         expect(() => untyped(Finalizer.changes, {}, { resources: { read: [page] } }))
             .toThrow(`watches or reads values on thread "main"; a changes finalizer runs on the world's thread, in the sync point.`);
+        expect(() => untyped(Finalizer.changes, { name: "savePage", watch: [page] }))
+            .toThrow(`watches or reads values on thread "main"; a changes finalizer runs on the world's thread, in the sync point.`);
         // Reading another thread's values, without writing or looking up, it's created.
         const detach = Finalizer.create({ components: { with: [node] } }, row => { void row[node]; });
         expect(programFinalizers()).toHaveLength(8);

package/src/interface/finalizer/create.ts

@@ -8,9 +8,11 @@ import { checkWorldWritten } from '../registry/written.js';
 import { checkLookup } from '../registry/indexes.js';
 import type { Listed, Property } from '../system/property.js';
 import type { ThreadOfComponent } from '../component/value.js';
+import type { ThreadOfResource } from '../resource/value.js';
+import type { Resource } from '../resource/resource.js';
 import type { Component } from '../component/component.js';
 import type { Elsewhere, OneThread, ThreadedBy, ThreadsOf } from '../system/threads.js';
-import type { ChangeSet, Context, Row, Watched } from './body.js';
+import type { ChangeSet, Context, Row, Watched, WatchedResources } from './body.js';
 import type { Changes, Leaf } from './created.js';
 import type { ChangesDeclaration, Declaration, Resolved, ResolvedChanges } from './declaration.js';
 import { accessOf, compact, lookupsLists, resourceUses, type Access } from '../system/resolve.js';
@@ -26,7 +28,7 @@ type Remote<D> = true extends Elsewhere<ThreadsOf<D>>
     : {};
 
 /** A changes finalizer runs on the world's thread, in the sync point: it watches and reads no other thread's objects. */
-type OnWorld<D> = true extends Elsewhere<ThreadsOf<D> | ThreadOfComponent<Listed<D, "watch"> & Component.Key>>
+type OnWorld<D> = true extends Elsewhere<ThreadsOf<D> | ThreadOfComponent<Listed<D, "watch"> & Component.Key> | ThreadOfResource<Listed<D, "watch"> & Resource.Key>>
     ? { readonly "error: a changes finalizer watches and reads only the world's thread's objects": true }
     : {};
 
@@ -127,12 +129,12 @@ export const create = <const D extends Declaration>(
 
 /**
  * Declares a finalizer of each sync point's structural changes, which applies in every world, and returns it. It runs
- * on the world's thread. Throws as `create` does, for a watched component that isn't registered or is derived, and for
- * one watching or reading another thread's values.
+ * on the world's thread. Throws as `create` does, for a watched component that isn't registered or is derived, a
+ * watched key that's neither a component nor a resource, and for one watching or reading another thread's values.
  */
 export const changes = <const D extends ChangesDeclaration>(
     declared: D & Inferred & OnWorld<D>,
-    body: (changes: ChangeSet<Watched<D>>, context: Context<D>) => void,
+    body: (changes: ChangeSet<Watched<D>, WatchedResources<D>>, context: Context<D>) => void,
 ): Finalizer => {
     const id = takeIdOfDeclaration(declared);
     const name = nameOf(declared, id, "finalizer");
@@ -148,10 +150,13 @@ export const changes = <const D extends ChangesDeclaration>(
         for (const keys of [lookup.read, "has" in lookup ? lookup.has : undefined, "not" in lookup ? lookup.not : undefined]) requireRegistered("Finalizer", name, "component", keys);
     }
     for (const key of declaration.watch ?? []) {
-        if (kindOf(key) !== "component") throw new Error(`Finalizer "${name}" watches "${labelOf(key)}", which isn't a registered component: ${whyUnregistered(key)}.`);
+        const kind = kindOf(key);
+        if (kind !== "component" && kind !== "resource") throw new Error(`Finalizer "${name}" watches "${labelOf(key)}", which isn't a registered component or resource: ${whyUnregistered(key)}.`);
         if (declarationOf(key)?.derived === true) throw new Error(`Finalizer "${name}" watches "${labelOf(key)}", which is derived; it sees only components user code adds and removes.`);
     }
-    const thread = threadOf({ components: { read: declaration.watch }, resources: declaration.resources, lookup: declaration.lookup }, "Finalizer", name);
+    const watched = (kind: "component" | "resource"): readonly symbol[] => (declaration.watch ?? []).filter(key => kindOf(key) === kind);
+    const read = [...declaration.resources?.read ?? [], ...watched("resource")];
+    const thread = threadOf({ components: { read: watched("component") }, resources: { ...declaration.resources, read }, lookup: declaration.lookup }, "Finalizer", name);
     if (thread !== null && thread !== "world") throw new Error(`Finalizer "${name}" watches or reads values on thread "${thread}"; a changes finalizer runs on the world's thread, in the sync point.`);
     checkOrder(name, "world", declaration);
     return addFinalizer(finalizer, id);

package/src/interface/finalizer/declaration.ts

@@ -4,6 +4,7 @@ import type { SystemLookupLists, ResourceLists } from '../system/access.js';
 import type { Lookup } from '../system/access.js';
 import type { Finalizer } from './finalizer.js';
 import type { Essential } from '../component/value.js';
+import type { Resource } from '../resource/resource.js';
 
 /**
  * What every finalizer declares. What its body reads of its row and lookups, and reads and writes of resources, the
@@ -26,9 +27,10 @@ export type Declaration = Shared & {
 
 /**
  * A finalizer that sees each sync point's structural changes to the components it watches: by default, every one that
- * isn't derived or an object a joined thread fills.
+ * isn't derived or an object a joined thread fills; and the resources it watches, none by default, written since the
+ * last sync point's finalizers ran.
  */
-export type ChangesDeclaration = Shared & { readonly watch?: readonly Essential[] };
+export type ChangesDeclaration = Shared & { readonly watch?: readonly (Essential | Resource.Key)[] };
 
 type Key = symbol;
 

package/src/interface/index.type-test.ts

@@ -27,8 +27,8 @@ Rule.create({ components: { with: [position] }, derive: [slot] });
 declare const create: Create;
 declare const wgsl: typeof Gpu.wgsl;
 export const world = create({ [workers]: 4, [gpuDevice]: null });
-export const read = System.create({ observer: true, components: { with: [position, slot] } }, () => {});
-export const readOne = System.create({ observer: true, lookup: { at: { with: [position, slot] } } }, () => {});
+export const read = System.create({ readonly: true, components: { with: [position, slot] } }, () => {});
+export const readOne = System.create({ readonly: true, lookup: { at: { with: [position, slot] } } }, () => {});
 export const report = world.run(all);
 export const shader = wgsl(draw);
 export const added = world.add(read);

package/src/interface/indexes/create.test.ts

@@ -144,3 +144,13 @@ describe("systems ordering their rows by an index", () => {
         expect(() => untypedRender(Index.create({ key: [amount] }))).toThrow(/orders its rows by index "index #\d+", which isn't sorted/);
     });
 });
+
+describe("Index.declarationOf", () => {
+    it("gives an index's declaration as registered, its with and not as declared, and nothing for a value Index.create didn't return", () => {
+        const byName = Index.create({ key: [name], unique: true, components: { with: [shown], not: [parent] } });
+        expect(Index.declarationOf(byName)).toEqual({ key: [name], components: { with: [shown], not: [parent] }, unique: true });
+        const byCell = Index.create({ key: [cell, amount], sorted: true });
+        expect(Index.declarationOf(byCell)).toEqual({ key: [cell, amount], components: {}, sorted: true });
+        expect(Index.declarationOf({ name: "not an index" })).toBeUndefined();
+    });
+});

package/src/interface/indexes/declaration-of.ts

@@ -0,0 +1,34 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Component } from '../component/component.js';
+import { indexDefinitionOf } from '../registry/indexes.js';
+import { kindOf } from '../registry/names.js';
+import type { Index } from './index-type.js';
+
+/**
+ * An index's declaration as `Index.create` registered it: its key, the components it holds by besides its key and those
+ * it excludes, and whether it's sorted or unique.
+ */
+export type Declared = {
+    readonly key: readonly Component.Key[];
+    readonly components: { readonly with?: readonly Component.Key[]; readonly not?: readonly Component.Key[] };
+    readonly sorted?: boolean;
+    readonly unique?: boolean;
+};
+
+/** Registration takes only components for a key part, `with` and `not`. */
+const isComponent = (key: symbol): key is Component.Key => kindOf(key) === "component";
+
+/** The declaration `index` was created from, as registered, or undefined for a value `Index.create` didn't return. */
+export const declarationOf = <D extends object>(index: Index<D>): Declared | undefined => {
+    const created = indexDefinitionOf(index);
+    if (created === undefined) return undefined;
+    const { key, components, sorted, unique } = created.declaration;
+    const held = components?.has?.filter(isComponent);
+    const excluded = components?.not?.filter(isComponent);
+    return {
+        key: key.filter(isComponent),
+        components: { ...held === undefined ? {} : { with: held }, ...excluded === undefined ? {} : { not: excluded } },
+        ...sorted === undefined ? {} : { sorted },
+        ...unique === undefined ? {} : { unique },
+    };
+};

package/src/interface/indexes/index.ts

@@ -1,2 +1,3 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 export * from './create.js';
+export { declarationOf, type Declared } from './declaration-of.js';

package/src/interface/indexes/index.type-test.ts

@@ -219,7 +219,7 @@ System.create({
 
 // An index lookup's `changed: true` runs its system only when the index's entries changed since it last ran: its
 // lists' `changed` then reports entries alone. Observer systems and CPU kernels take it; it's not a list of components.
-System.create({ observer: true, lookup: { living: { index: living, changed: true } } }, ({ lookup }) => {
+System.create({ readonly: true, lookup: { living: { index: living, changed: true } } }, ({ lookup }) => {
     const rows = lookup.living();
     check<Equal<typeof rows.changed, boolean>>();
     check<Equal<typeof rows.length, number>>();

package/src/interface/registry/names.ts

@@ -61,6 +61,14 @@ const entryOf = (key: symbol): Entry | undefined => {
     return entries.get(key);
 };
 
+/** Every key registered as `kind`, each by the symbol a world gives its values by, with its declaration. */
+export const declaredOf = (kind: "component" | "resource"): ReadonlyMap<symbol, AnyDeclaration> => {
+    catchUp();
+    const found = new Map<symbol, AnyDeclaration>();
+    for (const entry of entries.values()) if (entry.kind === kind && entry.declaration !== undefined) found.set(entry.newest, entry.declaration);
+    return found;
+};
+
 /** Whether a key is a component, a resource or a trait. */
 export const kindOf = (key: unknown): Kind | undefined => typeof key === "symbol" ? entryOf(key)?.kind : undefined;
 

package/src/interface/registry/schedule.ts

@@ -4,8 +4,8 @@ import type { Definition } from '../system/definition.js';
 import type { Leaf } from '../system/leaf.js';
 import { firstItemOf } from './items.js';
 import { requireDefinition } from './program.js';
-import { firstKeyOf, labelOf, sameDeclaration } from './names.js';
-import { lookupKeysOf, orderKeysOf } from './indexes.js';
+import { declarationOf, firstKeyOf, labelOf, sameDeclaration } from './names.js';
+import { indexDefinitionOf, lookupKeysOf, orderKeysOf } from './indexes.js';
 
 type Key = symbol;
 
@@ -28,21 +28,34 @@ const checkInputs = (leaves: readonly Leaf[]): void => {
 
 /**
  * Leaves in run order, grouped into tiers. Leaves in one tier have no ordering path between them. `reductions` are the
- * resources its leaves reduce into, each with how many of them contribute. `observer` are its observer leaves, in no
- * tier: they run after its sync point, ordered with nothing.
+ * resources its leaves reduce into, each with how many of them contribute. `observer` are its readonly leaves, in no
+ * tier: they run after its sync point, ordered with nothing. `syncs` holds, after each tier, the reasons for a sync
+ * point there, which applies the commands so far before the next tier, or null for none.
  */
-export type Schedule = { readonly tiers: readonly (readonly Leaf[])[]; readonly reductions: ReadonlyMap<Key, number>; readonly observer: readonly Leaf[] };
+export type Schedule = {
+    readonly tiers: readonly (readonly Leaf[])[];
+    readonly reductions: ReadonlyMap<Key, number>;
+    readonly observer: readonly Leaf[];
+    readonly syncs: readonly (readonly SyncReason[] | null)[];
+};
 
 export const isLeaf = (system: Definition): system is Leaf => system.kind !== "composite";
 
-/** Whether a system is an observer leaf, which runs after a sync point rather than in a tier. */
-export const isObserver = (system: Definition): system is Leaf & { readonly declaration: { readonly observer: true } } => system.kind !== "composite" && system.declaration.observer === true;
+/** Whether a system is a readonly system leaf, which runs after a sync point rather than in a tier. */
+export const isObserver = (system: Definition): system is Leaf & { readonly declaration: { readonly readonly: true } } => system.kind !== "composite" && system.declaration.readonly === true;
 
 /** Each system is an interval, from its start node to its end node. */
 const start = (unit: number): number => 2 * unit;
 const end = (unit: number): number => 2 * unit + 1;
 
-type Graph = { readonly units: readonly Definition[]; readonly successors: readonly Set<number>[] };
+type Graph = {
+    readonly units: readonly Definition[];
+    readonly successors: readonly Set<number>[];
+    /** Each unit's members, by unit: none for a leaf. */
+    readonly members: readonly (readonly number[])[];
+    /** The units a list of systems names, readonly systems left out. */
+    readonly resolve: (systems: readonly object[] | undefined) => readonly number[];
+};
 
 /**
  * A leaf runs from its start to its end, and a composite spans its members. `after` and `before` order one system's end
@@ -65,7 +78,7 @@ const graphOf = (root: Definition): Graph => {
     };
     visit(root);
     const successors = units.flatMap(() => [new Set<number>(), new Set<number>()]);
-    // An observer system is ordered with nothing, so constraints naming one are ignored.
+    // A readonly system is ordered with nothing, so constraints naming one are ignored.
     const resolve = (systems: readonly object[] | undefined): readonly number[] =>
         (systems ?? []).flatMap(system => {
             const unit = indexOf.get(firstItemOf(system));
@@ -86,7 +99,7 @@ const graphOf = (root: Definition): Graph => {
             successors[end(unit)].add(end(other));
         }
     });
-    return { units, successors };
+    return { units, successors, members, resolve };
 };
 
 /** Kahn's algorithm over nodes. Throws on a cycle. */
@@ -165,6 +178,74 @@ const conflictOf = (a: Access, b: Access): Key | undefined => {
     return undefined;
 };
 
+/** Every key two accesses conflict on. */
+const conflictsOf = (a: Access, b: Access): readonly Key[] => [...new Set([
+    ...[...a.writes].filter(key => b.writes.has(key) || b.reads.has(key) || b.reduces.has(key)),
+    ...[...b.writes].filter(key => a.reads.has(key) || a.reduces.has(key)),
+])];
+
+/** A system's leaves in its tiers, with their units and accesses, and its graph with readers of folds after their contributors. */
+const orderedOf = (system: Definition) => {
+    const graph = graphOf(system);
+    const leaves = graph.units.flatMap((unit, index) => isLeaf(unit) && !isObserver(unit) ? [{ leaf: unit, unit: index }] : []);
+    const accesses = leaves.map(({ leaf }) => accessOf(leaf));
+    // Leaves that read a resource run after every leaf that reduces into it, so they read the finished fold.
+    const reductions = new Map<Key, number>();
+    accesses.forEach((access, contributor) => {
+        for (const key of access.reduces) {
+            reductions.set(key, (reductions.get(key) ?? 0) + 1);
+            accesses.forEach((other, reader) => {
+                if (reader !== contributor && other.reads.has(key)) graph.successors[end(leaves[contributor].unit)].add(start(leaves[reader].unit));
+            });
+        }
+    });
+    return { graph, leaves, accesses, reductions };
+};
+
+/**
+ * What put a leaf after another: a constraint of either, or of a composite holding it, naming the other or a composite
+ * holding it (`after`, `before`), its reading a fold the other contributes to (`reduction`), or being placed during a
+ * span (`during`). `conflicts` are the keys both access, one writing, which need the order.
+ */
+export type Placement = { readonly leaf: Leaf; readonly because: "after" | "before" | "during" | "reduction"; readonly conflicts: readonly Key[] };
+
+/**
+ * For each leaf in a system's tiers, the leaves it follows directly: those with an ordering path to it through no other
+ * leaf of its tiers.
+ */
+export const placementsOf = (system: Definition): ReadonlyMap<Leaf, readonly Placement[]> => {
+    const { graph, leaves, accesses } = orderedOf(system);
+    const reach = reachability(topologicalOrder(graph), graph.successors);
+    const ancestors = graph.units.map(() => [] as number[]);
+    graph.members.forEach((members, unit) => {
+        const visit = (member: number): void => {
+            ancestors[member].push(unit);
+            for (const inner of graph.members[member]) visit(inner);
+        };
+        for (const member of members) visit(member);
+    });
+    /** Whether `systems` names `unit` or a composite holding it. */
+    const names = (systems: readonly object[] | undefined, unit: number): boolean => {
+        const named = graph.resolve(systems);
+        return named.includes(unit) || ancestors[unit].some(holder => named.includes(holder));
+    };
+    const constrains = (unit: number, list: "after" | "before", other: number): boolean =>
+        [unit, ...ancestors[unit]].some(holder => holder !== 0 && names(graph.units[holder].declaration[list], other));
+    const placements = new Map<Leaf, readonly Placement[]>();
+    leaves.forEach(({ leaf, unit }, b) => {
+        const before = leaves.flatMap((other, a) => a !== b && reaches(reach, end(other.unit), start(unit)) ? [a] : []);
+        const direct = before.filter(a => !before.some(other => other !== a && reaches(reach, end(leaves[a].unit), start(leaves[other].unit))));
+        placements.set(leaf, direct.map(a => {
+            const other = leaves[a];
+            const because = constrains(unit, "after", other.unit) ? "after"
+                : constrains(other.unit, "before", unit) ? "before"
+                : [...accesses[a].reduces].some(key => accesses[b].reads.has(key)) ? "reduction" : "during";
+            return { leaf: other.leaf, because, conflicts: conflictsOf(accesses[a], accesses[b]) };
+        }));
+    });
+    return placements;
+};
+
 const schedules = new WeakMap<Definition, Schedule>();
 
 /** A system's schedule, created once per system. Throws on a cycle, or on two conflicting leaves with no ordering path between them. */
@@ -179,33 +260,125 @@ export const scheduleOf = (system: Definition): Schedule => {
  * or on inputs that don't merge.
  */
 const createSchedule = (system: Definition): Schedule => {
-    const graph = graphOf(system);
+    const { graph, leaves, accesses, reductions } = orderedOf(system);
     const observer = graph.units.filter(isObserver);
-    const leaves = graph.units.flatMap((unit, index) => isLeaf(unit) && !isObserver(unit) ? [{ leaf: unit, unit: index }] : []);
     checkInputs(leaves.map(({ leaf }) => leaf));
-    const accesses = leaves.map(({ leaf }) => accessOf(leaf));
-    // Leaves that read a resource run after every leaf that reduces into it, so they read the finished fold.
-    const reductions = new Map<Key, number>();
-    accesses.forEach((access, contributor) => {
-        for (const key of access.reduces) {
-            reductions.set(key, (reductions.get(key) ?? 0) + 1);
-            accesses.forEach((other, reader) => {
-                if (reader !== contributor && other.reads.has(key)) graph.successors[end(leaves[contributor].unit)].add(start(leaves[reader].unit));
-            });
-        }
-    });
     const order = topologicalOrder(graph);
     const reach = reachability(order, graph.successors);
     for (let a = 0; a < leaves.length; a++) {
         for (let b = a + 1; b < leaves.length; b++) {
             const key = conflictOf(accesses[a], accesses[b]);
             if (key !== undefined && !ordered(reach, leaves[a].unit, leaves[b].unit)) {
-                throw new Error(`Systems "${leaves[a].leaf.name}" and "${leaves[b].leaf.name}" both access "${labelOf(key)}" and one writes it; order them with before or after.`);
+                const whole = [leaves[a].leaf, leaves[b].leaf].filter(leaf => leaf.declaration.components?.whole === true)
+                    .map(leaf => ` "${leaf.name}" takes its row whole (components.whole), so it writes every member.`).join("");
+                throw new Error(`Systems "${leaves[a].leaf.name}" and "${leaves[b].leaf.name}" both access "${labelOf(key)}" and one writes it; order them with before or after.${whole}`);
             }
         }
     }
     const depth = depthsOf(graph, order);
-    const tiers: Leaf[][] = [];
-    for (const { leaf, unit } of leaves) (tiers[depth[start(unit)]] ??= []).push(leaf);
-    return { tiers: tiers.filter(tier => tier !== undefined), reductions, observer };
+    const byDepth: Leaf[][] = [];
+    for (const { leaf, unit } of leaves) (byDepth[depth[start(unit)]] ??= []).push(leaf);
+    const tiers = byDepth.filter(tier => tier !== undefined);
+    // A sync point comes between tiers, so a schedule of one tier has none.
+    if (tiers.length < 2) return { tiers, reductions, observer, syncs: tiers.map(() => null) };
+    const tierOf = new Map<Leaf, number>();
+    tiers.forEach((tier, t) => { for (const leaf of tier) tierOf.set(leaf, t); });
+    const edges: { readonly lo: number; readonly hi: number; readonly reason: SyncReason }[] = [];
+    leaves.forEach((from, a) => {
+        const changed = structuralOf(from.leaf);
+        if (changed === null) return;
+        leaves.forEach((to, b) => {
+            if (a === b || !reaches(reach, end(from.unit), start(to.unit))) return;
+            const keys = affected(changed, touchesOf(to.leaf));
+            if (keys !== null) edges.push({ lo: tierOf.get(from.leaf) ?? 0, hi: (tierOf.get(to.leaf) ?? 0) - 1, reason: { from: from.leaf, to: to.leaf, keys } });
+        });
+    });
+    return { tiers, reductions, observer, syncs: syncsOf(tiers.length, edges) };
+};
+
+/**
+ * Why a sync point follows a tier: a system in it or before it whose commands may change, structurally, what a system
+ * after the sync point that follows it reads, matches, looks up or indexes. `keys` are the components its commands name
+ * that the later one uses, none where it despawns, or where its commands or a cascade could change anything.
+ */
+export type SyncReason = { readonly from: Leaf; readonly to: Leaf; readonly keys: readonly Key[] };
+
+/** The components a leaf's commands may add or remove, by spawn, add or remove; `"any"` once it despawns or isn't followed. */
+const structuralOf = (leaf: Leaf): ReadonlySet<Key> | "any" | null => {
+    const { commands } = leaf;
+    if (commands === undefined) return null;
+    if (commands === null || commands.despawn === true) return "any";
+    const keys = new Set([...commands.spawn ?? [], ...commands.add ?? [], ...commands.remove ?? []].map(firstKeyOf));
+    // A reference written may despawn its holder, or remove itself, at the sync point.
+    for (const key of keys) if (declarationOf(key)?.reference !== undefined) return "any";
+    return keys.size === 0 ? null : keys;
+};
+
+/**
+ * The components a leaf's rows, lookups, indexes and order name, which commands could change its view of; `any` when
+ * one of them matches every entity, `cascaded` when it names a component a rule derives or `within` removes.
+ */
+const touchesOf = (leaf: Leaf): { readonly keys: ReadonlySet<Key>; readonly any: boolean; readonly cascaded: boolean } => {
+    const { components, lookup, up, order } = leaf.declaration;
+    const keys = new Set<Key>();
+    let any = false;
+    const add = (list: readonly Key[] | undefined): void => { for (const key of list ?? []) keys.add(firstKeyOf(key)); };
+    /** Names what a query requires; one requiring nothing matches every entity. */
+    const requires = (required: readonly (readonly Key[] | undefined)[], others: readonly (readonly Key[] | undefined)[]): void => {
+        if (required.every(list => list === undefined || list.length === 0)) any = true;
+        for (const list of [...required, ...others]) add(list);
+    };
+    const indexed = (index: unknown): void => {
+        const declaration = indexDefinitionOf(index)?.declaration;
+        if (declaration !== undefined) requires([declaration.key, declaration.components?.has], [declaration.components?.not]);
+    };
+    if (components !== undefined) {
+        requires([components.read, components.write, components.has, components.added, components.changed], [components.optional, components.not]);
+        add(Object.getOwnPropertySymbols(components.where ?? {}));
+    }
+    for (const name in lookup) {
+        const used = lookup[name];
+        if ("index" in used && used.index !== undefined) {
+            indexed(used.index);
+            add(used.read);
+        }
+        else if (!("index" in used)) requires([used.read, used.has], [used.optional, used.not, Array.isArray(used.changed) ? used.changed : undefined]);
+    }
+    if (order !== undefined) indexed(order);
+    if (up !== undefined) add([up.through, ...up.read ?? []]);
+    const cascaded = [...keys].some(key => { const declared = declarationOf(key); return declared?.derived === true || declared?.within !== undefined; });
+    return { keys, any, cascaded };
+};
+
+/** The keys through which `changed` may change what `touches` names; null where it can't. */
+const affected = (changed: ReadonlySet<Key> | "any", touches: ReturnType<typeof touchesOf>): readonly Key[] | null => {
+    if (touches.keys.size === 0 && !touches.any) return null;
+    if (changed === "any") return [];
+    if (touches.any || touches.cascaded) return [...changed];
+    const keys = [...changed].filter(key => touches.keys.has(key));
+    return keys.length === 0 ? null : keys;
+};
+
+/**
+ * The fewest sync points that put one between the tiers of each edge, after a tier from `lo` to `hi`: each placed as
+ * late as the first edge it must cover allows, so it covers every edge open then. An edge's reason goes to the first
+ * sync point within its tiers.
+ */
+const syncsOf = (count: number, edges: readonly { readonly lo: number; readonly hi: number; readonly reason: SyncReason }[]): readonly (readonly SyncReason[] | null)[] => {
+    const syncs: (SyncReason[] | null)[] = new Array<SyncReason[] | null>(count).fill(null);
+    let last = -1;
+    for (const { lo, hi } of [...edges].sort((a, b) => a.hi - b.hi)) {
+        if (last >= lo) continue;
+        last = hi;
+        syncs[hi] = [];
+    }
+    for (const { lo, hi, reason } of edges) {
+        for (let t = lo; t <= hi; t++) {
+            const reasons = syncs[t];
+            if (reasons === null) continue;
+            reasons.push(reason);
+            break;
+        }
+    }
+    return syncs;
 };

package/src/interface/resource/declarations.ts

@@ -0,0 +1,11 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import type { Declared } from '../component/declared.js';
+import { declaredOf } from '../registry/names.js';
+import type { Key } from './key.js';
+
+/** Every resource its modules registered so far, with its declaration. */
+export const declarations = (): ReadonlyMap<Key, Declared> => {
+    // Registration takes only keys declared in `Resources`, so each symbol registered as a resource is one of its keys.
+    const found = declaredOf("resource") as ReadonlyMap<Key, Declared>;
+    return found;
+};

package/src/interface/resource/index.ts

@@ -1,2 +1,4 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 export type { Key } from './key.js';
+export { declarations } from './declarations.js';
+export type { Declared } from '../component/declared.js';