@adobe/data 0.9.80 → 0.9.82

package/dist/ecs/database/database-read.type-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/ecs/database/database-read.type-test.js

@@ -0,0 +1,220 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "./database.js";
+/**
+ * Compile-time tests for `Database.Read<DB>` and the `db.derive`
+ * callback surface. Type-only — nothing here executes. `@ts-expect-error`
+ * marks the accesses that MUST NOT compile (the footguns the read projection
+ * removes structurally).
+ */
+const plugin = Database.Plugin.create({
+    components: {
+        x: { type: "number" },
+        y: { type: "string" },
+    },
+    resources: {
+        frameRate: { type: "number", default: 30 },
+    },
+    archetypes: {
+        Foo: ["x"],
+    },
+    indexes: {
+        byX: { key: "x" },
+        byXUnique: { key: "x", unique: true },
+    },
+});
+const db = Database.create(plugin);
+// ============================================================================
+// derive — POSITIVE: the read surface a compute body is allowed to touch
+// ============================================================================
+function derivePositive() {
+    // value reads
+    const gotten = db.derive((d) => d.get(0, "x"));
+    const selected = db.derive((d) => d.select(["x"]));
+    // presence `select` — `exclude` is allowed (membership-based)
+    db.derive((d) => d.select(["x"], { exclude: ["y"] }));
+    // …but the value-dependent options are NOT on the derive surface: they can
+    // only be tracked coarsely, so a value-keyed / ordered reactive read must go
+    // through a declared index.
+    db.derive((d) => 
+    // @ts-expect-error `where` is not offered on a derive's select — use an index
+    d.select(["x"], { where: { x: 1 } }));
+    db.derive((d) => 
+    // @ts-expect-error `order` is not offered on a derive's select — use an index
+    d.select(["x"], { order: { x: true } }));
+    // whole-entity read
+    db.derive((d) => d.read(0));
+    // projection read: exactly the requested fields, optionality preserved,
+    // unrequested fields (incl. id) excluded
+    db.derive((d) => {
+        const p = d.read(0, ["x", "y"]);
+        if (p !== null) {
+            const _x = p.x;
+            const _y = p.y;
+            void _x;
+            void _y;
+            // @ts-expect-error `id` was not requested, so it is not on the projection
+            p.id;
+        }
+        return p;
+    });
+    // archetype read: narrowed to the archetype's own row (no extra fields)
+    db.derive((d) => {
+        const foo = d.read(0, db.archetypes.Foo);
+        if (foo !== null) {
+            const _x = foo.x;
+            // @ts-expect-error `y` is not part of the Foo archetype — narrowed read excludes it
+            foo.y;
+        }
+        return foo;
+    });
+    // resource reads
+    const frameRate = db.derive((d) => d.resources.frameRate);
+    // archetype identity — and the realistic composition select(archetype.components)
+    db.derive((d) => d.archetypes.Foo.components);
+    db.derive((d) => d.archetypes.Foo.id);
+    db.derive((d) => d.select(d.archetypes.Foo.components));
+    // index lookups
+    db.derive((d) => d.indexes.byX.find({ x: 1 }));
+    db.derive((d) => d.indexes.byX.findRange({ x: 1 }));
+    // a unique index also exposes `get`
+    const head = db.derive((d) => d.indexes.byXUnique.get({ x: 1 }));
+}
+function deriveInputsPositive() {
+    // inputs are injected as current values, strongly typed by unwrapping each Observe
+    const sum = db.derive({ n: numberInput, s: stringInput }, (d, inputs) => {
+        // the first arg is still the read projection
+        const r = d.resources.frameRate;
+        return `${inputs.s}:${inputs.n + r}`;
+    });
+    // a body that mixes an ECS read with an injected input value
+    const mixed = db.derive({ n: numberInput }, (d, inputs) => (d.get(0, "x") ?? 0) + inputs.n);
+}
+function deriveInputsNegative() {
+    db.derive({ n: numberInput }, (d, inputs) => {
+        void d;
+        // @ts-expect-error `n` unwraps to number, not string
+        const bad = inputs.n;
+        return bad;
+    });
+    db.derive({ n: numberInput }, (d, inputs) => {
+        void d;
+        // @ts-expect-error `m` is not an injected input
+        return inputs.m;
+    });
+    // @ts-expect-error an input value must be an Observe, not a bare value
+    db.derive({ n: 123 }, (d, inputs) => inputs.n);
+}
+// ============================================================================
+// derive — NEGATIVE: everything the read projection removes
+// ============================================================================
+function deriveNegative() {
+    db.derive((d) => {
+        // @ts-expect-error observers are not exposed — a derive subscribes to its own reads
+        return d.observe;
+    });
+    db.derive((d) => {
+        // @ts-expect-error transactions / writes are not exposed to a read-only derive
+        return d.transactions;
+    });
+    db.derive((d) => {
+        // @ts-expect-error queryArchetypes (raw column access) is not exposed
+        return d.queryArchetypes;
+    });
+    db.derive((d) => {
+        // @ts-expect-error locate (row access) is not exposed
+        return d.locate;
+    });
+    db.derive((d) => {
+        // @ts-expect-error per-archetype column access is not exposed
+        return d.archetypes.Foo.columns;
+    });
+    db.derive((d) => {
+        // @ts-expect-error per-archetype rowCount (table access) is not exposed
+        return d.archetypes.Foo.rowCount;
+    });
+    db.derive((d) => {
+        // @ts-expect-error per-archetype insert (write) is not exposed
+        return d.archetypes.Foo.insert;
+    });
+    db.derive((d) => {
+        // @ts-expect-error index observe is not exposed — a derive subscribes for you
+        return d.indexes.byX.observe;
+    });
+}
+function readProjectionPositive() {
+    const v = rd.get(0, "x");
+    const ids = rd.select(["x"]);
+    const excluded = rd.select(["x"], { exclude: ["y"] });
+    const fr = rd.resources.frameRate;
+    rd.archetypes.Foo.components.has("x");
+    const found = rd.indexes.byX.find({ x: 1 });
+    void v;
+    void ids;
+    void excluded;
+    void fr;
+    void found;
+}
+function readProjectionNegative() {
+    // @ts-expect-error observers omitted from the read projection
+    rd.observe;
+    // @ts-expect-error index observe omitted from the read projection
+    rd.indexes.byX.observe;
+    // @ts-expect-error table/column access omitted from the read projection
+    rd.archetypes.Foo.columns;
+    // @ts-expect-error transactions omitted from the read projection
+    rd.transactions;
+    // @ts-expect-error `where` (value-dependent) omitted from the read projection's select
+    rd.select(["x"], { where: { x: 1 } });
+    // @ts-expect-error `order` (value-dependent) omitted from the read projection's select
+    rd.select(["x"], { order: { x: true } });
+}
+// ============================================================================
+// Read distributes over an INTERSECTION (Option A). The structural definition
+// means `Database.Read<A & B>` merges both members' read surfaces, and because
+// `derive` passes `Database.Read<this>`, a derive on an intersection receiver
+// sees indexes + resources + archetypes from BOTH members — so a consumer of a
+// composed `A & B` database (e.g. an indexed core intersected with a
+// resource-computed layer) never needs to cast.
+// ============================================================================
+const pluginA = Database.Plugin.create({
+    components: { a: { type: "number" } },
+    resources: { ra: { type: "number", default: 0 } },
+    archetypes: { AOnly: ["a"] },
+    indexes: { byA: { key: "a" } },
+});
+const pluginB = Database.Plugin.create({
+    components: { b: { type: "string" } },
+    resources: { rb: { type: "string", default: "" } },
+    archetypes: { BOnly: ["b"] },
+    indexes: { byB: { key: "b" } },
+});
+const dbA = Database.create(pluginA);
+const dbB = Database.create(pluginB);
+function intersectionRead() {
+    // both members' resources
+    const _ra = rb2.resources.ra;
+    const _rb = rb2.resources.rb;
+    // both members' indexes (find-only)
+    const _fa = rb2.indexes.byA.find({ a: 1 });
+    const _fb = rb2.indexes.byB.find({ b: "x" });
+    // both members' archetype identities
+    rb2.archetypes.AOnly.components.has("a");
+    rb2.archetypes.BOnly.components.has("b");
+    void _ra;
+    void _rb;
+    void _fa;
+    void _fb;
+}
+function intersectionDerive() {
+    // `Database.Read<this>` on an intersection receiver → merged surface.
+    both.derive((d) => {
+        const _ra = d.resources.ra;
+        const _rb = d.resources.rb;
+        d.indexes.byA.find({ a: 1 });
+        d.indexes.byB.find({ b: "x" });
+        void _ra;
+        void _rb;
+        return 0;
+    });
+}
+//# sourceMappingURL=database-read.type-test.js.map

package/dist/ecs/database/database-read.type-test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-read.type-test.js","sourceRoot":"","sources":["../../../src/ecs/database/database-read.type-test.ts"],"names":[],"mappings":"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"}

package/dist/ecs/database/database.d.ts

@@ -138,6 +138,38 @@ export interface Database<C extends Components = {}, R extends ResourceComponent
         archetype(id: ArchetypeId): Observe<void>;
         select<Include extends StringKeyof<C>, T extends Include>(include: readonly Include[] | ReadonlySet<string>, options?: EntitySelectOptions<C, Pick<C & RequiredComponents, T>>): Observe<readonly Entity[]>;
     };
+    /**
+     * Reactive derivation. `compute` runs against a read-only projection of this
+     * database ({@link Database.Read} — value / index / resource reads only; no
+     * observers, writes, or table access). The derive records exactly the reads
+     * it performs and re-emits when any could have changed: the initial value on
+     * subscribe, then at most once per committed transaction (synchronously at
+     * the commit boundary), structurally deduplicated so an unchanged result
+     * never re-notifies.
+     *
+     * The callback receives `Database.Read<this>`, so an *intersection* database
+     * resolves to the merged read surface — consumers never need to cast.
+     */
+    derive<T>(compute: (db: Database.Read<this>) => T): Observe<T>;
+    /**
+     * `derive` with a fixed record of external `inputs` — arbitrary `Observe<T>`
+     * values that do NOT live in the ECS (e.g. observables exposed by services).
+     * Their CURRENT values are injected as the second callback argument, keyed the
+     * same as `inputs` and unwrapped (`Observe<U> → U`); the first argument stays
+     * the read projection, so a body can fold external values and ECS reads into
+     * one synchronous expression.
+     *
+     * The inputs are subscribed once, at the root (not read dynamically inside the
+     * body), so the set is fixed for the life of the derive. The derive recomputes
+     * when any input emits OR an ECS read it recorded could have changed; like
+     * {@link Observe.fromProperties}, the first value is withheld until every input
+     * has produced one. Anything dynamic — an input set that depends on data, or
+     * an input whose arguments come from an ECS read — composes with
+     * {@link Observe.withSwitch} / {@link Observe.fromKeys} around the derive.
+     */
+    derive<I extends Record<string, Observe<unknown>>, T>(inputs: I, compute: (db: Database.Read<this>, inputs: {
+        readonly [K in keyof I]: I[K] extends Observe<infer U> ? U : never;
+    }) => T): Observe<T>;
     /**
      * Wipes all entities and resets all resources to their plugin defaults,
      * preserving database identity (observers, transaction wrappers, sync
@@ -209,12 +241,47 @@ export declare namespace Database {
      * expansion that amplifies TS7056 serialization overflow in deep extends chains.
      */
     type FromPlugin<P extends Database.Plugin> = Database<FromSchemas<RemoveIndex<P['components']>>, FromSchemas<RemoveIndex<P['resources']>>, RemoveIndex<P['archetypes']>, ToTransactionFunctions<RemoveIndex<P['transactions']>>, StringKeyof<P['systems']>, ToActionFunctions<RemoveIndex<P['actions']>>, FromServiceFactories<RemoveIndex<P['services']>>, FromComputedFactories<RemoveIndex<P['computed']>>, RemoveIndex<P['indexes']>>;
+    /**
+     * The read-only projection of a Database that a `db.derive` callback
+     * receives. It exposes only the auto-trackable read surface —
+     *   - value reads: `get`, `read`, `select`
+     *   - resource reads: `resources`
+     *   - index lookups: `indexes.<name>.find` / `findRange` / `get`
+     *   - archetype identity: `archetypes.<name>.components` / `id`
+     * — and structurally OMITS everything a derived computation must not touch:
+     *   - `observe` (a derive subscribes to what it reads for you)
+     *   - transactions / actions / any write
+     *   - direct table access: `queryArchetypes`, `locate`, and per-archetype
+     *     `columns` / `rowCount` / `insert` / row reads
+     *   - `services` / `computed` / lifecycle (`extend`, `reset`, `toData`, …)
+     *
+     * Because the surface is narrowed structurally, misuse is a compile error
+     * rather than a value that must be guarded / thrown on at runtime.
+     */
+    type Read<DB extends Database<any, any, any, any, any, any, any, any, any>> = Pick<DB, "get" | "read" | "resources"> & {
+        select(include: readonly string[] | ReadonlySet<string>, options?: {
+            readonly exclude?: readonly string[];
+        }): readonly Entity[];
+        readonly indexes: {
+            readonly [K in keyof DB["indexes"]]: Omit<DB["indexes"][K], "observe">;
+        };
+        readonly archetypes: {
+            readonly [K in keyof DB["archetypes"]]: Pick<DB["archetypes"][K], "components" | "id">;
+        };
+    };
     const create: typeof createDatabase;
     const is: (value: unknown) => value is Database;
     const observeSelectDeep: <C extends Components, Include extends StringKeyof<C>>(db: Database<C, any, any, any, any, any, any, any>, include: readonly Include[] | ReadonlySet<Include | "id">, options?: EntitySelectOptions<C, Pick<C & RequiredComponents, Include>>) => Observe<readonly (RequiredComponents & { readonly [K in Include]: C[K]; })[]>;
     type Index<C extends Components = any> = StoreIndex<C, any, any, any>;
     namespace Index {
         type Handle<C extends Components, I extends StoreIndex<C, any, any, any>> = StoreIndex.Handle<C, I>;
+        /**
+         * The index handle as exposed to a `db.derive` callback: the
+         * synchronous lookups (`find` / `findRange` / `get`) only. `observe` is
+         * removed — a derive subscribes to the reads it performs automatically, so
+         * calling `observe` from inside one is a category error.
+         */
+        type ReadHandle<C extends Components, I extends StoreIndex<C, any, any, any>> = Omit<Handle<C, I>, "observe">;
     }
     namespace Archetype {
         /**

package/dist/ecs/database/database.js.map

@@ -1 +1 @@
-{"version":3,"file":"database.js","sourceRoot":"","sources":["../../../src/ecs/database/database.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAkBvD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EAAE,iBAAiB,IAAI,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAc1F,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAsMtD,MAAM,KAAW,QAAQ,CAyGxB;AAzGD,WAAiB,QAAQ;IAmBV,eAAM,GAAG,cAAc,CAAC;IAExB,WAAE,GAAG,CAAC,KAAc,EAAqB,EAAE;QACtD,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,cAAc,IAAI,KAAK,IAAI,SAAS,IAAI,KAAK,IAAI,OAAO,IAAI,KAAK,IAAI,SAAS,IAAI,KAAK,IAAI,QAAQ,IAAI,KAAK,IAAI,QAAQ,IAAI,KAAK,CAAC;IAC1L,CAAC,CAAA;IAEY,0BAAiB,GAAG,kBAAkB,CAAC;IAyDpD,IAAiB,MAAM,CAqBtB;IArBD,WAAiB,MAAM;QACR,aAAM,GAAG,YAAY,CAAC;QACtB,cAAO,GAAG,cAAc,CAAC;IAmBxC,CAAC,EArBgB,MAAM,GAAN,eAAM,KAAN,eAAM,QAqBtB;AAEH,CAAC,EAzGgB,QAAQ,KAAR,QAAQ,QAyGxB"}
+{"version":3,"file":"database.js","sourceRoot":"","sources":["../../../src/ecs/database/database.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAkBvD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,EAAE,iBAAiB,IAAI,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAc1F,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AA0OtD,MAAM,KAAW,QAAQ,CAkKxB;AAlKD,WAAiB,QAAQ;IAoEV,eAAM,GAAG,cAAc,CAAC;IAExB,WAAE,GAAG,CAAC,KAAc,EAAqB,EAAE;QACtD,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,cAAc,IAAI,KAAK,IAAI,SAAS,IAAI,KAAK,IAAI,OAAO,IAAI,KAAK,IAAI,SAAS,IAAI,KAAK,IAAI,QAAQ,IAAI,KAAK,IAAI,QAAQ,IAAI,KAAK,CAAC;IAC1L,CAAC,CAAA;IAEY,0BAAiB,GAAG,kBAAkB,CAAC;IAiEpD,IAAiB,MAAM,CAqBtB;IArBD,WAAiB,MAAM;QACR,aAAM,GAAG,YAAY,CAAC;QACtB,cAAO,GAAG,cAAc,CAAC;IAmBxC,CAAC,EArBgB,MAAM,GAAN,eAAM,KAAN,eAAM,QAqBtB;AAEH,CAAC,EAlKgB,QAAQ,KAAR,QAAQ,QAkKxB"}

package/dist/ecs/database/observe-derive.d.ts

@@ -0,0 +1,14 @@
+import { Observe } from "../../observe/index.js";
+import { ReadonlyStore } from "../store/index.js";
+import { TransactionResult } from "./transactional-store/transactional-store.js";
+/**
+ * Builds `db.derive`. A single read-recording wrapper is constructed
+ * once and shared across every derive on this database: because a `compute`
+ * body is synchronous and performs no writes or nested derives, no two runs can
+ * overlap, so the wrapper's "currently-recording" target is reset per run and
+ * safely reused.
+ */
+export declare const createDerive: <C extends object>(store: ReadonlyStore<C, any, any, any>, observeTransactions: Observe<TransactionResult<C>>) => {
+    <T>(compute: (db: any) => T): Observe<T>;
+    <I extends Record<string, Observe<unknown>>, T>(inputs: I, compute: (db: any, inputs: { readonly [K in keyof I]: I[K] extends Observe<infer U> ? U : never; }) => T): Observe<T>;
+};

package/dist/ecs/database/observe-derive.js

@@ -0,0 +1,257 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Observe } from "../../observe/index.js";
+import { equals } from "../../equals.js";
+const emptyDeps = () => ({
+    entityWhole: new Set(),
+    entityComponents: new Map(),
+    columns: new Set(),
+    setReads: [],
+});
+const watchComponent = (deps, entity, component) => {
+    let set = deps.entityComponents.get(entity);
+    if (set === undefined) {
+        deps.entityComponents.set(entity, (set = new Set()));
+    }
+    set.add(component);
+};
+const affected = (deps, result) => {
+    const { changedEntities, changedComponents, changedArchetypes } = result;
+    const { entityWhole, entityComponents, columns, setReads } = deps;
+    // Entity deps: iterate the (usually small) *changed* set and probe the
+    // watched sets — O(|changedEntities|), not O(|watched|). A commit touches a
+    // handful of entities regardless of how many a derive reads.
+    if (entityWhole.size > 0 || entityComponents.size > 0) {
+        for (const [entity, values] of changedEntities) {
+            if (entityWhole.has(entity)) {
+                return true;
+            }
+            const watched = entityComponents.get(entity);
+            if (watched === undefined) {
+                continue;
+            }
+            if (values === null) {
+                // entity deleted — any scoped read of it is now stale
+                return true;
+            }
+            for (const component of Object.keys(values)) {
+                if (watched.has(component)) {
+                    return true;
+                }
+            }
+        }
+    }
+    // Resource column deps.
+    if (columns.size > 0 && !changedComponents.isDisjointFrom(columns)) {
+        return true;
+    }
+    // Set-valued reads: cheap gate, then recompute-and-compare this one read.
+    for (const dep of setReads) {
+        if (dep.kind === "index") {
+            if (changedComponents.isDisjointFrom(dep.readColumns)) {
+                continue;
+            }
+        }
+        else if (changedArchetypes.size === 0) {
+            continue;
+        }
+        if (!equals(dep.last, dep.recompute())) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Builds `db.derive`. A single read-recording wrapper is constructed
+ * once and shared across every derive on this database: because a `compute`
+ * body is synchronous and performs no writes or nested derives, no two runs can
+ * overlap, so the wrapper's "currently-recording" target is reset per run and
+ * safely reused.
+ */
+export const createDerive = (store, observeTransactions) => {
+    // The active recording target, non-null only for the duration of one
+    // synchronous `compute` run.
+    let recording = null;
+    // `resources` and `indexes` are built lazily and cached: the store's
+    // resource and index maps are populated during database construction, which
+    // finishes AFTER this factory is created, but before any derive can run.
+    let resourcesRecorder = null;
+    const buildResources = () => {
+        const out = {};
+        for (const name of Object.keys(store.resources)) {
+            Object.defineProperty(out, name, {
+                enumerable: true,
+                get() {
+                    if (recording) {
+                        recording.columns.add(name);
+                    }
+                    return store.resources[name];
+                },
+            });
+        }
+        return out;
+    };
+    let indexesRecorder = null;
+    const buildIndexes = () => {
+        const out = {};
+        const storeIndexes = (store.indexes ?? {});
+        for (const name of Object.keys(storeIndexes)) {
+            const handle = storeIndexes[name];
+            const readColumns = new Set(handle.readColumns ?? []);
+            // Record a per-bucket dependency: the exact result this lookup
+            // returned, plus a thunk to recompute it. `affected` gates on the
+            // read columns then recompute-compares, so an unrelated bucket's
+            // change recomputes this (cheap Map-get + slice) to an identical
+            // sequence and is suppressed — the derive body never re-runs.
+            const recordLookup = (result, recompute) => {
+                if (recording) {
+                    recording.setReads.push({ kind: "index", readColumns, recompute, last: result });
+                }
+            };
+            const readHandle = {
+                find: (arg) => {
+                    const result = handle.find(arg);
+                    recordLookup(result, () => handle.find(arg));
+                    return result;
+                },
+                findRange: (arg) => {
+                    const result = handle.findRange(arg);
+                    recordLookup(result, () => handle.findRange(arg));
+                    return result;
+                },
+            };
+            if (typeof handle.get === "function") {
+                readHandle.get = (arg) => {
+                    const result = handle.get(arg);
+                    recordLookup(result, () => handle.get(arg));
+                    return result;
+                };
+            }
+            out[name] = readHandle;
+        }
+        return out;
+    };
+    // The read-recording projection handed to `compute`. Delegates every read to
+    // the real store and records the dependency it implies. Typed loosely here;
+    // the precise `Database.Read<…>` surface is enforced at the public
+    // `db.derive` boundary.
+    const recorder = {
+        get: (entity, component) => {
+            if (recording) {
+                watchComponent(recording, entity, component);
+            }
+            return store.get(entity, component);
+        },
+        read: (entity, archetypeOrComponents) => {
+            if (recording) {
+                if (archetypeOrComponents === undefined) {
+                    recording.entityWhole.add(entity);
+                }
+                else if (Array.isArray(archetypeOrComponents)) {
+                    for (const component of archetypeOrComponents) {
+                        watchComponent(recording, entity, component);
+                    }
+                }
+                else {
+                    for (const component of archetypeOrComponents.components) {
+                        watchComponent(recording, entity, component);
+                    }
+                }
+            }
+            return store.read(entity, archetypeOrComponents);
+        },
+        // Presence select only — `include` + `exclude`, no `where` / `order`
+        // (value-dependent options are omitted from the derive surface; use a
+        // declared index for value-keyed or ordered reactive reads). Recorded as
+        // a set-valued read gated on `changedArchetypes`: the result is
+        // membership-shaped, so a pure value write can never move it, and an
+        // unrelated migration recompute-compares to the same sequence.
+        select: (include, options) => {
+            const exclude = options?.exclude;
+            const args = [include, exclude === undefined ? undefined : { exclude }];
+            const run = () => store.select(...args);
+            const result = run();
+            if (recording) {
+                recording.setReads.push({ kind: "select", recompute: run, last: result });
+            }
+            return result;
+        },
+        get resources() {
+            return (resourcesRecorder ??= buildResources());
+        },
+        get indexes() {
+            return (indexesRecorder ??= buildIndexes());
+        },
+        // Archetype identity (components / id) is static, so reading it records
+        // no dependency; delegate to the real archetypes.
+        archetypes: store.archetypes,
+    };
+    // Implementation signature — hidden; callers only ever see the two typed
+    // overloads above. `inputs` is `any` here solely because an overloaded impl
+    // signature must remain callable for the typed overload (whose `inputs` param
+    // is checked contravariantly); the public surface stays fully typed.
+    function derive(arg1, arg2) {
+        const inputObservables = typeof arg1 === "function" ? undefined : arg1;
+        const compute = typeof arg1 === "function" ? arg1 : arg2;
+        if (compute === undefined) {
+            throw new Error("db.derive requires a compute function");
+        }
+        return (notify) => {
+            let last;
+            let hasLast = false;
+            let deps = emptyDeps();
+            // Latest injected input snapshot; `ready` gates the ECS commit path
+            // until the inputs exist (no inputs → ready immediately).
+            let latestInputs;
+            let ready = inputObservables === undefined;
+            const run = () => {
+                recording = emptyDeps();
+                try {
+                    return compute(recorder, latestInputs);
+                }
+                finally {
+                    deps = recording;
+                    recording = null;
+                }
+            };
+            const emit = (value) => {
+                if (!hasLast || !equals(last, value)) {
+                    last = value;
+                    hasLast = true;
+                    notify(value);
+                }
+            };
+            // ECS commit gate — recompute when a recorded read could have changed.
+            // `observeTransactions` fires once per committed transaction, so a
+            // recompute happens at most once per commit, synchronously at the
+            // commit boundary (the same cadence as `observe.entity` / the raw
+            // component observers a hand-written computed would use). Guarded by
+            // `ready` so it never runs before the first dep set is recorded.
+            const unobserveTransactions = observeTransactions((result) => {
+                if (ready && affected(deps, result)) {
+                    emit(run());
+                }
+            });
+            if (inputObservables === undefined) {
+                emit(run());
+                return () => {
+                    unobserveTransactions();
+                };
+            }
+            // Inputs are subscribed once here at the root — never read inside the
+            // recording run — so the set is fixed for the derive's lifetime. Each
+            // emission refreshes the injected snapshot and recomputes; the first
+            // (all inputs present) is also the derive's first value.
+            const unobserveInputs = Observe.fromProperties(inputObservables)((values) => {
+                latestInputs = values;
+                ready = true;
+                emit(run());
+            });
+            return () => {
+                unobserveInputs();
+                unobserveTransactions();
+            };
+        };
+    }
+    return derive;
+};
+//# sourceMappingURL=observe-derive.js.map

package/dist/ecs/database/observe-derive.js.map

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

package/dist/ecs/database/observe-derive.test.d.ts

@@ -0,0 +1 @@
+export {};