@adobe/ecs 0.0.0-stage → 0.2.0

package/dist/implementation/world/prepared-spawn.js

@@ -0,0 +1,119 @@
+import { addCommand, pushCommand, pushComponent } from './buffer.js';
+import { commandsTarget } from './commands.js';
+import { listIndexOf, listShapeOf, positionalOf } from './lists.js';
+const isTargeted = (commands) => commandsTarget in commands;
+/** The values object a site would have built, for calls the site can't take positionally. */
+const valuesOf = (keys, values) => {
+    const object = {};
+    keys.forEach((key, k) => { object[key] = values[k]; });
+    return object;
+};
+const createPlans = () => ({ byIndex: [], byShape: [] });
+/**
+ * A site's plan for a world and list: a kept one, else one `make` makes for its shape and the site's keys, kept from
+ * then on. `make` is one function per kind of site, so finding a plan allocates nothing.
+ */
+const planFor = (plans, state, list, site, make) => {
+    const index = listIndexOf(list);
+    const indexed = index >= 0 ? plans.byIndex[index] : undefined;
+    // Kept small, so it inlines into the systems spawning and adding: the rest is outlined.
+    return indexed !== undefined && indexed.state === state ? indexed : planned(plans, state, list, site, make, index);
+};
+/** A site's plan other than one kept by archetype index for this world. */
+const planned = (plans, state, list, site, make, index) => {
+    const shape = listShapeOf(state, list);
+    let plan = plans.byShape[shape.index];
+    if (plan === undefined || plan.shape !== shape) {
+        plan = make(state, shape, site);
+        plans.byShape[shape.index] = plan;
+    }
+    // A list made at runtime has an index once resolved.
+    const kept = index >= 0 ? index : listIndexOf(list);
+    if (kept >= 0)
+        plans.byIndex[kept] = plan;
+    return plan;
+};
+const spawnPlanOf = (state, shape, site) => ({ state, shape, spawn: positionalOf(state, shape, site) });
+/**
+ * The compiler's hook for a main-thread spawn site with literal keys: the call becomes a per-site function taking the
+ * values in key order, so no value object is built and nothing is read by key. `keys` is called on first use, after
+ * the module's key constants are initialized. Commands it didn't make go through `commands.spawn` as written.
+ */
+export const prepareSpawn = (keys) => {
+    let resolved = null;
+    /** A key named twice means the later value wins, as in the object literal: such sites use `commands.spawn`. */
+    let distinct = false;
+    const plans = createPlans();
+    return {
+        begin: (commands, components) => {
+            if (resolved === null) {
+                resolved = keys();
+                distinct = new Set(resolved).size === resolved.length;
+            }
+            if (!distinct || !isTargeted(commands))
+                return null;
+            return planFor(plans, commands[commandsTarget].state, components, resolved, spawnPlanOf).spawn;
+        },
+        // Commands this world didn't make, or keys named twice, which only an untyped values object can carry.
+        fallback: (commands, components, values) => Reflect.apply(commands.spawn(components), undefined, [valuesOf(resolved ?? keys(), values)]),
+    };
+};
+const addPlanOf = (state, shape, site) => {
+    const named = shape.keys.flatMap((key, k) => site.includes(key) ? [] : [k]);
+    const at = site.map(key => typeof key === "symbol" ? shape.keys.indexOf(key) : -1);
+    return {
+        state,
+        shape,
+        ids: at.map(k => k < 0 ? -1 : shape.ids[k]),
+        given: at.map(k => k < 0 ? undefined : shape.starts[k]),
+        missing: named.map(k => shape.ids[k]),
+        starts: named.map(k => shape.starts[k]),
+    };
+};
+/**
+ * The compiler's hook for a main-thread add site with literal keys: the call becomes a per-site function taking the
+ * entity and values in key order, so no value object is built and nothing is read by key. Ids are resolved once per
+ * world and list, so a key that isn't a component commands may add throws before anything is appended, as
+ * `commands.add` does. Commands it didn't make go through `commands.add` as written.
+ */
+export const prepareAdd = (keys) => {
+    let resolved = null;
+    let distinct = false;
+    const plans = createPlans();
+    let plan = null;
+    let buffer = null;
+    return {
+        begin: (commands, entity, components) => {
+            if (resolved === null) {
+                resolved = keys();
+                distinct = new Set(resolved).size === resolved.length;
+            }
+            if (!distinct || !isTargeted(commands))
+                return false;
+            const { state, target } = commands[commandsTarget];
+            plan = planFor(plans, state, components, resolved, addPlanOf);
+            // Shared values are checked before anything is queued, which `commands.add` does.
+            if (plan.shape.shared.length > 0)
+                return false;
+            buffer = target.buffer;
+            pushCommand(buffer, addCommand, entity);
+            buffer.shapes[buffer.count - 1] = plan.shape.index;
+            return true;
+        },
+        value: (k, value) => {
+            const id = plan === null ? -1 : plan.ids[k];
+            if (buffer === null || plan === null || id < 0)
+                return;
+            pushComponent(buffer, id, value === undefined ? plan.given[k] : value);
+        },
+        end: () => {
+            if (buffer === null || plan === null)
+                return;
+            const { missing, starts } = plan;
+            for (let k = 0; k < missing.length; k++)
+                pushComponent(buffer, missing[k], starts[k]);
+        },
+        fallback: (commands, entity, components, values) => Reflect.apply(commands.add, commands, [entity, components, valuesOf(resolved ?? keys(), values)]),
+    };
+};
+//# sourceMappingURL=prepared-spawn.js.map

package/dist/implementation/world/prepared-spawn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepared-spawn.js","sourceRoot":"","sources":["../../../src/implementation/world/prepared-spawn.ts"],"names":[],"mappings":"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"}

package/dist/implementation/world/program.d.ts

@@ -0,0 +1,11 @@
+import type { Finalizer } from '../../interface/finalizer/created.js';
+import type { Rule } from '../../interface/rule/created.js';
+import type { Key } from './state.js';
+/**
+ * The components a world must have met before the item can match anything there: all of them, or for a changes
+ * finalizer any one it watches. Empty when it can match from the start.
+ */
+export declare const triggersOf: (item: Rule | Finalizer) => {
+    readonly keys: readonly Key[];
+    readonly any: boolean;
+};

package/dist/implementation/world/program.js

@@ -0,0 +1,12 @@
+/**
+ * The components a world must have met before the item can match anything there: all of them, or for a changes
+ * finalizer any one it watches. Empty when it can match from the start.
+ */
+export const triggersOf = (item) => {
+    if (item.kind === "rule")
+        return { keys: item.declaration.components.has ?? [], any: false };
+    if (item.kind === "finalizer")
+        return { keys: [...item.declaration.components.read ?? [], ...item.declaration.components.has ?? []], any: false };
+    return { keys: item.declaration.watch ?? [], any: true };
+};
+//# sourceMappingURL=program.js.map

package/dist/implementation/world/program.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"program.js","sourceRoot":"","sources":["../../../src/implementation/world/program.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,IAAsB,EAA4D,EAAE;IAC3G,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM;QAAE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,IAAI,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC;IAC7F,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW;QAAE,OAAO,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,IAAI,EAAE,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC;IAClJ,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,KAAK,IAAI,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC;AAC7D,CAAC,CAAC"}

package/dist/implementation/world/protocol.d.ts

@@ -0,0 +1,192 @@
+import type { Schema } from '../../interface/schema/schema.js';
+import type { Endpoint } from './port.js';
+import type { WasmScalar } from './wasm.js';
+import type { IndexReaderSetup } from './index-readers.js';
+/** Where a kernel column comes from in any archetype it matches. */
+export type Source = {
+    readonly kind: "entity";
+} | {
+    readonly kind: "field" | "changed" | "chunks" | "blocks" | "present";
+    readonly id: number;
+    readonly leaf: number;
+};
+/** Component ids of one lookup, and for a lookup by entity with `changed`, those it watches. */
+export type LookupSetup = {
+    readonly read: readonly number[];
+    readonly has: readonly number[];
+    readonly optional: readonly number[];
+    readonly not: readonly number[];
+    readonly changed: readonly number[] | null;
+};
+export type KernelSetup = {
+    readonly index: number;
+    readonly url: string;
+    readonly sources: readonly Source[];
+    readonly booleans: readonly boolean[];
+    readonly strides: readonly number[];
+    readonly offsets: readonly number[];
+    /** Tick columns nothing observes: they point at a dummy element. */
+    readonly muted: readonly boolean[];
+    readonly lookups: readonly LookupSetup[];
+    /** By lookup through an index: its lookup, how its JS reader reads it, and how many components it watches. */
+    readonly indexes: readonly {
+        readonly lookup: number;
+        readonly reader: IndexReaderSetup;
+        readonly watched: number;
+    }[];
+    /** Component ids, used as `keys` so command values name components by id. */
+    readonly keys: readonly number[];
+    /** By key index, each component's label, which a failing write of an optional component names. */
+    readonly labels: readonly string[];
+    /** Optional components' ids: an archetype without one gives its columns empty. */
+    readonly optional: readonly number[];
+    /** By key index: what each component stored in linear memory starts at, for a spawn leaving it out; null for the rest, whose start the world resolves. */
+    readonly starts: readonly unknown[];
+    /** The component ids of each list the kernel spawns, in the order its spawner takes values. */
+    readonly spawns: readonly (readonly number[])[];
+    readonly added: readonly number[];
+    readonly changed: readonly number[];
+    /** For a kernel reading `up`: each parent column's boolean flag, stride and offset, the same in every archetype. */
+    readonly up: {
+        readonly booleans: readonly boolean[];
+        readonly strides: readonly number[];
+        readonly offsets: readonly number[];
+    };
+    /** Whether the kernel reduces: its fast tasks then carry their partials' address and stride after the scalars. */
+    readonly reduces: boolean;
+    /** The compiled WASM version, which workers instantiate against the shared memory and prefer. */
+    readonly wasm: {
+        readonly module: WebAssembly.Module;
+        readonly scalars: readonly WasmScalar[];
+        readonly imports: readonly string[];
+    } | null;
+};
+/**
+ * Messages are handled in order, so new components' schemas always arrive before the tasks that use them. Where
+ * archetypes and the entity table are in the memory, workers read from the layout directory, whose header is at byte
+ * `header` (`layout-directory.ts`).
+ */
+export type ToWorker = 
+/** From a lent worker's owner, first: the port every later message arrives on and every reply goes to. */
+{
+    readonly kind: "port";
+    readonly port: Endpoint;
+}
+/** The memory, its layout directory's header, and the byte offset of this worker's control words, its command ring's among them. */
+ | {
+    readonly kind: "memory";
+    readonly memory: WebAssembly.Memory;
+    readonly header: number;
+    readonly control: number;
+}
+/** Wait on this worker's task ring in shared memory until asked to leave. Offsets are bytes into the memory. */
+ | {
+    readonly kind: "window";
+    readonly control: number;
+    readonly statuses: number;
+    readonly payloads: number;
+    readonly claims: number;
+    readonly worker: number;
+    readonly epoch: number;
+}
+/** New components' schemas; none for a value that isn't data. */
+ | {
+    readonly kind: "layout";
+    readonly schemas: readonly (readonly [number, Schema | undefined])[];
+} | {
+    readonly kind: "kernels";
+    readonly task: number;
+    readonly kernels: readonly KernelSetup[];
+}
+/** For tests of what a world holds: how many kernels this worker keeps. */
+ | {
+    readonly kind: "tables";
+    readonly task: number;
+} | {
+    readonly kind: "run";
+    readonly task: number;
+    readonly kernel: number;
+    readonly archetype: number;
+    readonly start: number;
+    readonly end: number;
+    readonly tick: number;
+    /** Rows pass only if a filtered tick is newer than this; `-1` passes every row. */
+    readonly lastRun: number;
+    readonly resources: readonly unknown[];
+    readonly args: unknown;
+    /** The byte address of this chunk's reduction partials, or -1 for a kernel without reductions. */
+    readonly partials: number;
+    /** A WASM kernel's lookup parameters, and its lookups through indexes', which JS kernels' readers read too. */
+    readonly lookups: readonly number[];
+    readonly indexes: readonly number[];
+    /** The archetype's values of the shared components the kernel reads, which each call takes. */
+    readonly shared: readonly unknown[];
+};
+export type WorkerError = {
+    readonly name: string;
+    readonly message: string;
+    readonly stack?: string;
+};
+/**
+ * A task's completion: its segment of the worker's command ring, as start and end bytes past the ring's base, and what
+ * it wrote past the ring's size, or null (`command-ring.ts`). A failed task's segment holds what it issued before failing,
+ * which applies, as the main thread's would.
+ */
+export type FromWorker = {
+    readonly kind: "done";
+    readonly task: number;
+    readonly start: number;
+    readonly end: number;
+    readonly spill: Uint8Array | null;
+} | {
+    readonly kind: "failed";
+    readonly task: number;
+    readonly start: number;
+    readonly end: number;
+    readonly spill: Uint8Array | null;
+    readonly error: WorkerError;
+} | {
+    readonly kind: "tables";
+    readonly task: number;
+    readonly kernels: number;
+};
+/**
+ * Tasks a worker's ring holds, and f64 words per task: twelve fields, then scalars. The fields are kernel, archetype,
+ * start, end, tick, lastRun, the window epoch, the scalar count, then the split's claims: the line of its first range
+ * word (-1 for none), the grain, this worker's participant index and the participant count. Without claims the task
+ * runs `start` to `end`; with them it runs the `grain`-row pieces it claims (`claims.ts`).
+ */
+export declare const ringSize = 64;
+/** A ring task's kernel that runs nothing: a round trip to the worker and back, as the `wake` benchmark measures. */
+export declare const idleKernel = -1;
+export declare const taskWords = 32;
+export declare const taskFields = 12;
+export declare const maximumScalars: number;
+/**
+ * Int32 words per 128-byte cache line, the largest in use (Apple silicon). Words that different threads write each get
+ * a line of their own, so a store by one doesn't invalidate the line another is polling.
+ */
+export declare const lineWords = 32;
+/** Splits in flight with claims the pool holds room for: one range word per worker each, each on its own line. */
+export declare const splitCount = 256;
+/**
+ * Control words per worker: tasks posted, tasks done, the window epoch, and a signal bumped on every post or close,
+ * which the worker waits on, so a wake-up between its check and its wait isn't lost. Closing a window bumps the
+ * epoch; a worker leaves its window when the epoch moves on, and runs only tasks posted in its own window's epoch,
+ * so a task posted after a close waits until the worker has handled the messages sent before it.
+ */
+export declare const posted = 0;
+export declare const done = 1;
+export declare const epoch = 2;
+export declare const signal = 3;
+/**
+ * The worker's command ring: its base and capacity in bytes, which the world sets at sync points; its write cursor past
+ * the base, which the worker stores at each task's end and the world resets at sync points; and the bytes its tasks
+ * needed since, spills included, which the next sync point grows the ring to. The base reads as unsigned.
+ */
+export declare const ringBase = 4;
+export declare const ringCapacity = 5;
+export declare const ringCursor = 6;
+export declare const ringNeeded = 7;
+/** Each worker's control words take a whole line. */
+export declare const controlWords = 32;

package/dist/implementation/world/protocol.js

@@ -0,0 +1,41 @@
+/**
+ * Tasks a worker's ring holds, and f64 words per task: twelve fields, then scalars. The fields are kernel, archetype,
+ * start, end, tick, lastRun, the window epoch, the scalar count, then the split's claims: the line of its first range
+ * word (-1 for none), the grain, this worker's participant index and the participant count. Without claims the task
+ * runs `start` to `end`; with them it runs the `grain`-row pieces it claims (`claims.ts`).
+ */
+export const ringSize = 64;
+/** A ring task's kernel that runs nothing: a round trip to the worker and back, as the `wake` benchmark measures. */
+export const idleKernel = -1;
+export const taskWords = 32;
+export const taskFields = 12;
+export const maximumScalars = taskWords - taskFields;
+/**
+ * Int32 words per 128-byte cache line, the largest in use (Apple silicon). Words that different threads write each get
+ * a line of their own, so a store by one doesn't invalidate the line another is polling.
+ */
+export const lineWords = 32;
+/** Splits in flight with claims the pool holds room for: one range word per worker each, each on its own line. */
+export const splitCount = 256;
+/**
+ * Control words per worker: tasks posted, tasks done, the window epoch, and a signal bumped on every post or close,
+ * which the worker waits on, so a wake-up between its check and its wait isn't lost. Closing a window bumps the
+ * epoch; a worker leaves its window when the epoch moves on, and runs only tasks posted in its own window's epoch,
+ * so a task posted after a close waits until the worker has handled the messages sent before it.
+ */
+export const posted = 0;
+export const done = 1;
+export const epoch = 2;
+export const signal = 3;
+/**
+ * The worker's command ring: its base and capacity in bytes, which the world sets at sync points; its write cursor past
+ * the base, which the worker stores at each task's end and the world resets at sync points; and the bytes its tasks
+ * needed since, spills included, which the next sync point grows the ring to. The base reads as unsigned.
+ */
+export const ringBase = 4;
+export const ringCapacity = 5;
+export const ringCursor = 6;
+export const ringNeeded = 7;
+/** Each worker's control words take a whole line. */
+export const controlWords = lineWords;
+//# sourceMappingURL=protocol.js.map

package/dist/implementation/world/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../../src/implementation/world/protocol.ts"],"names":[],"mappings":"AA8FA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,EAAE,CAAC;AAC3B,qHAAqH;AACrH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,CAAC;AAC7B,MAAM,CAAC,MAAM,SAAS,GAAG,EAAE,CAAC;AAC5B,MAAM,CAAC,MAAM,UAAU,GAAG,EAAE,CAAC;AAC7B,MAAM,CAAC,MAAM,cAAc,GAAG,SAAS,GAAG,UAAU,CAAC;AACrD;;;GAGG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,EAAE,CAAC;AAC5B,kHAAkH;AAClH,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,CAAC;AAC9B;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,CAAC;AACxB,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,CAAC;AACtB,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC;AACvB,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,CAAC;AACxB;;;;GAIG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAC;AAC1B,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC;AAC9B,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC;AAC5B,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC;AAC5B,qDAAqD;AACrD,MAAM,CAAC,MAAM,YAAY,GAAG,SAAS,CAAC"}

package/dist/implementation/world/publish.d.ts

@@ -0,0 +1,9 @@
+import type { Pool } from './pool.js';
+import type { State } from './state.js';
+/**
+ * Returns a function that brings workers up to date with the shared memory's layout: it flushes the layout directory,
+ * where workers find archetypes and the entity table, and posts only new components' schemas. Called after every
+ * sync point and wherever registration changes layouts, so workers see them before the next run's tasks; allocates
+ * nothing when nothing is new.
+ */
+export declare const createPublisher: (state: State, pool: Pool) => (() => void);

package/dist/implementation/world/publish.js

@@ -0,0 +1,28 @@
+import { schemaOf } from '../../interface/registry/index.js';
+import { flushBetween } from './layout-directory.js';
+/**
+ * Returns a function that brings workers up to date with the shared memory's layout: it flushes the layout directory,
+ * where workers find archetypes and the entity table, and posts only new components' schemas. Called after every
+ * sync point and wherever registration changes layouts, so workers see them before the next run's tasks; allocates
+ * nothing when nothing is new.
+ */
+export const createPublisher = (state, pool) => {
+    let schemasSent = 0;
+    return () => {
+        flushBetween(state.directory, state.bumped, state.archetypes, state.entities, state.resourceEntity, state.counted);
+        if (schemasSent === state.keys.length)
+            return;
+        // Workers never touch resources, so their schemas, defaults included, stay on the world's thread.
+        // A value that isn't data has no schema; workers store it as an object they never touch.
+        const schemas = [];
+        for (let id = schemasSent; id < state.keys.length; id++) {
+            if (!state.resources.has(id))
+                schemas.push([id, schemaOf(state.keys[id])]);
+        }
+        if (schemas.length > 0)
+            pool.broadcast({ kind: "layout", schemas });
+        // Only once sent, so a failed broadcast is retried after the next sync point.
+        schemasSent = state.keys.length;
+    };
+};
+//# sourceMappingURL=publish.js.map

package/dist/implementation/world/publish.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.js","sourceRoot":"","sources":["../../../src/implementation/world/publish.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAIrD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAY,EAAE,IAAU,EAAgB,EAAE;IACtE,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,OAAO,GAAG,EAAE;QACR,YAAY,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;QACnH,IAAI,WAAW,KAAK,KAAK,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO;QAC9C,kGAAkG;QAClG,yFAAyF;QACzF,MAAM,OAAO,GAA8C,EAAE,CAAC;QAC9D,KAAK,IAAI,EAAE,GAAG,WAAW,EAAE,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;YACtD,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC;gBAAE,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/E,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;YAAE,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;QACpE,8EAA8E;QAC9E,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;IACpC,CAAC,CAAC;AACN,CAAC,CAAC"}

package/dist/implementation/world/ranges.d.ts

@@ -0,0 +1,21 @@
+/**
+ * One `added` or `changed` filter: per-row ticks, the newest tick of each chunk of rows, and the newest tick of each
+ * block of rows within a chunk.
+ */
+export type Filter = {
+    readonly ticks: Float64Array;
+    readonly chunks: Float64Array;
+    readonly blocks: Float64Array;
+};
+/**
+ * Calls `each` with every row below `count` whose tick in `ticks` is newer than `since`, skipping chunks, then blocks,
+ * whose ticks aren't.
+ */
+export declare const forEachNewerRow: (ticks: Float64Array, chunks: Float64Array, blocks: Float64Array, count: number, since: number, each: (row: number) => void) => void;
+/**
+ * Calls `call` for each maximal range of rows in `start` to `end` that passes the change filters: any tick newer
+ * than `lastRun`. Chunks, then blocks, with no newer tick are skipped without reading their rows, so finding the rows
+ * costs a check per chunk, one per block of a chunk that changed, and one per row of a block that changed. With no
+ * filters, or `lastRun` below 0, every row passes.
+ */
+export declare const forEachPassingRange: (filters: readonly Filter[], lastRun: number, start: number, end: number, call: (start: number, end: number) => void) => void;

package/dist/implementation/world/ranges.js

@@ -0,0 +1,130 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { blockShift, chunkShift } from './kernel.js';
+/** Whether any filter's chunk tick of `chunk` is newer than `lastRun`. */
+const chunkNewer = (filters, chunk, lastRun) => {
+    for (let i = 0; i < filters.length; i++)
+        if (filters[i].chunks[chunk] > lastRun)
+            return true;
+    return false;
+};
+const blockNewer = (filters, block, lastRun) => {
+    for (let i = 0; i < filters.length; i++)
+        if (filters[i].blocks[block] > lastRun)
+            return true;
+    return false;
+};
+const rowNewer = (filters, row, lastRun) => {
+    for (let i = 0; i < filters.length; i++)
+        if (filters[i].ticks[row] > lastRun)
+            return true;
+    return false;
+};
+/**
+ * Calls `each` with every row below `count` whose tick in `ticks` is newer than `since`, skipping chunks, then blocks,
+ * whose ticks aren't.
+ */
+export const forEachNewerRow = (ticks, chunks, blocks, count, since, each) => {
+    for (let chunk = 0, last = (count - 1) >> chunkShift; chunk <= last; chunk++) {
+        if (!(chunks[chunk] > since))
+            continue;
+        for (let block = chunk << (chunkShift - blockShift), end = Math.min((chunk + 1) << (chunkShift - blockShift), ((count - 1) >> blockShift) + 1); block < end; block++) {
+            if (!(blocks[block] > since))
+                continue;
+            for (let row = block << blockShift, rowEnd = Math.min(count, (block + 1) << blockShift); row < rowEnd; row++)
+                if (ticks[row] > since)
+                    each(row);
+        }
+    }
+};
+/** `forEachPassingRange` for one filter, whose loops each read one array. */
+const forEachPassingRangeOf = (filter, lastRun, start, end, call) => {
+    const { ticks, chunks, blocks } = filter;
+    const lastChunk = (end - 1) >> chunkShift;
+    let row = start;
+    while (row < end) {
+        let chunk = row >> chunkShift;
+        if (!(chunks[chunk] > lastRun)) {
+            do
+                chunk++;
+            while (chunk <= lastChunk && !(chunks[chunk] > lastRun));
+            if (chunk > lastChunk)
+                return;
+            row = chunk << chunkShift;
+        }
+        const chunkEnd = Math.min(end, (chunk + 1) << chunkShift);
+        const lastBlock = (chunkEnd - 1) >> blockShift;
+        let block = row >> blockShift;
+        if (!(blocks[block] > lastRun)) {
+            do
+                block++;
+            while (block <= lastBlock && !(blocks[block] > lastRun));
+            if (block > lastBlock) {
+                row = chunkEnd;
+                continue;
+            }
+            row = block << blockShift;
+        }
+        const blockEnd = Math.min(chunkEnd, (block + 1) << blockShift);
+        while (row < blockEnd && !(ticks[row] > lastRun))
+            row++;
+        if (row === blockEnd)
+            continue;
+        // A passing range runs on by row ticks alone, past blocks and chunks, until a row doesn't pass.
+        const first = row;
+        do
+            row++;
+        while (row < end && ticks[row] > lastRun);
+        call(first, row);
+    }
+};
+/**
+ * Calls `call` for each maximal range of rows in `start` to `end` that passes the change filters: any tick newer
+ * than `lastRun`. Chunks, then blocks, with no newer tick are skipped without reading their rows, so finding the rows
+ * costs a check per chunk, one per block of a chunk that changed, and one per row of a block that changed. With no
+ * filters, or `lastRun` below 0, every row passes.
+ */
+export const forEachPassingRange = (filters, lastRun, start, end, call) => {
+    if (lastRun < 0 || filters.length === 0)
+        return call(start, end);
+    if (start >= end)
+        return;
+    if (filters.length === 1)
+        return forEachPassingRangeOf(filters[0], lastRun, start, end, call);
+    const lastChunk = (end - 1) >> chunkShift;
+    let row = start;
+    while (row < end) {
+        let chunk = row >> chunkShift;
+        if (!chunkNewer(filters, chunk, lastRun)) {
+            do
+                chunk++;
+            while (chunk <= lastChunk && !chunkNewer(filters, chunk, lastRun));
+            if (chunk > lastChunk)
+                return;
+            row = chunk << chunkShift;
+        }
+        const chunkEnd = Math.min(end, (chunk + 1) << chunkShift);
+        const lastBlock = (chunkEnd - 1) >> blockShift;
+        let block = row >> blockShift;
+        if (!blockNewer(filters, block, lastRun)) {
+            do
+                block++;
+            while (block <= lastBlock && !blockNewer(filters, block, lastRun));
+            if (block > lastBlock) {
+                row = chunkEnd;
+                continue;
+            }
+            row = block << blockShift;
+        }
+        const blockEnd = Math.min(chunkEnd, (block + 1) << blockShift);
+        while (row < blockEnd && !rowNewer(filters, row, lastRun))
+            row++;
+        if (row === blockEnd)
+            continue;
+        const first = row;
+        do
+            row++;
+        while (row < end && rowNewer(filters, row, lastRun));
+        call(first, row);
+    }
+};
+//# sourceMappingURL=ranges.js.map

package/dist/implementation/world/ranges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ranges.js","sourceRoot":"","sources":["../../../src/implementation/world/ranges.ts"],"names":[],"mappings":"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"}

package/dist/implementation/world/reclaim.d.ts

@@ -0,0 +1,27 @@
+import type { Layout } from '../../interface/registry/layout.js';
+import { type Archetype } from './archetype.js';
+import type { State } from './state.js';
+/**
+ * Sync points an archetype stays empty before it's reclaimed, so one emptied and filled again soon, as a cell is while
+ * entities cross it, isn't reclaimed and reused over and over: a reclaim and reuse costs a sync point about 1.7 µs
+ * (perf.md), and each walker leaves at most this many empty behind it. A tail ends before the second sync point after
+ * the one it reads, so none reads a reclaimed archetype's rows.
+ */
+export declare const emptyFor = 8;
+/** Archetypes whose rows left in the sync point just applied that are now empty, with shared values, as candidates. */
+export declare const noteEmptied: (state: State) => void;
+/**
+ * At the end of a sync point: reclaims the candidates that stayed empty long enough, keeps those that may be later,
+ * drops those filled again, then drops the values interned since the last sync point that nothing came to hold.
+ */
+export declare const reclaimEmptied: (state: State) => void;
+/**
+ * Notes an edge `holder[key]` cached between archetypes `from` and `to`, so it's cleared, set to `cleared`, once either
+ * is reclaimed. Only edges with an end of shared values are kept, so worlds without them keep none.
+ */
+export declare const noteEdge: (holder: object, key: PropertyKey, cleared: unknown, from: Archetype, to: Archetype) => void;
+/**
+ * A reclaimed archetype of `components` reused for the shared values `held` holds, their layouts and texts by
+ * component id; null where its component set's pool is empty.
+ */
+export declare const reuseArchetype: (state: State, key: string, components: readonly number[], held: readonly (number | undefined)[], layouts: readonly (Layout | undefined)[], texts: readonly (string | undefined)[]) => Archetype | null;