@adobe/data-gpu 0.9.69

package/CLAUDE.md

@@ -0,0 +1,98 @@
+# CLAUDE.md — data-gpu
+
+## Hot-loop performance: direct typed-array column access in systems
+
+Per-frame systems (the physics solver, the renderers, anything in `update`/
+`physics`/`render`) run over every body/instance every frame. In those loops,
+**never use `column.get(i)` / `column.set(i, v)` for `Vec3`/`Quat`/struct
+columns** — `get` allocates a fresh array per call, so a few-hundred-element
+loop churns thousands of short-lived arrays/frame and the GC stalls show up as
+frame hitches.
+
+Instead:
+
+- **Read/write the backing memory directly.** Struct columns (`Vec3`, `Quat`,
+  any fixed-array/object schema) are flat `Float32Array` buffers. Hoist the
+  array once per archetype and index it: `Vec3` stride 3, `Quat` stride 4.
+
+  ```ts
+  const posArr = arch.columns.position.getTypedArray();   // not column.get(i)
+  for (let i = 0; i < arch.rowCount; i++) {
+      const o = i * 3;
+      state.pos[o] = posArr[o]; state.pos[o + 1] = posArr[o + 1]; state.pos[o + 2] = posArr[o + 2];
+  }
+  ```
+
+- **Systems may write component columns directly — no transaction.**
+  Transactions are for authored edits / undo / sync; a per-frame solver writing
+  its own derived state writes the typed array directly (zero transaction
+  overhead, and `column.set` does no change-notification anyway).
+
+- **Keep per-element math allocation-free.** Helpers called per row take an
+  out-array + offset and write into it (return scalars), rather than returning
+  a fresh `{...}` / `[...]`. See `ColliderShape.massProperties` (writes inverse
+  inertia into the solver array) and `composeTrs` in `pbr-render-plugin` (writes
+  a TRS matrix into a pooled arena). Reuse scratch buffers across frames; grow,
+  never reallocate per frame.
+
+Worked examples: the CPU solver gather/scatter (`cpu-xpbd-plugin.ts`) and the
+primitive instance packing (`pbr-render-plugin.ts`) — both are zero-allocation
+in steady state.
+
+(For the orthogonal "closure → class for V8 hidden classes" optimization on the
+`@adobe/data` buffer interfaces, see the `performance` skill.)
+
+## ECS traversal: select in the query, never iterate rows you'll skip
+
+When writing **any** system, before the loop ask: *which rows do I actually need
+this frame, and does the query already exclude the rest?* Iterating a wide set
+and `if`-skipping inside the loop is the recurring perf bug. The cost is
+invisible at tens of rows and dominant at thousands (see the worked numbers
+below), so make the query do the filtering. (`.claude/rules/archetypes.md` is
+the canonical rule; this is the data-gpu-specific checklist.)
+
+- **Push selection into `queryArchetypes(include, { exclude })`.** Require the
+  components you read; exclude the ones that disqualify a row. Don't query a
+  superset and filter. Distinguish by *archetype shape*, not by a per-row value
+  test, wherever you can: e.g. `StaticCollider` has no velocity columns, so the
+  dynamic gather/writeback simply never matches statics — no `if (isStatic)`.
+
+- **Process-once work → tag + exclude.** If a system does one-time setup per
+  entity (mirroring a body into an external engine, deriving `_worldBounds`,
+  uploading a buffer), add a private `_`-prefixed **`True` tag** when done and
+  `exclude` it from the query. Steady state then matches **zero archetypes** and
+  iterates nothing, instead of re-scanning every entity every frame to re-skip
+  it. Worked example: the Rapier/Jolt solver sync (`_rapierBody` / `_joltBody`).
+  Measured at 20k static + 64 dynamic: Jolt **0.53 → 0.07 ms/frame** (the scan
+  *was* the whole per-frame cost), Rapier **1.51 → 1.13**.
+
+- **Iterate tail→head when every visited row migrates out.** Adding/removing a
+  component (`db.store.update(id, { _tag: … })`, delete) migrates the row to
+  another archetype; doing it mid-iteration triggers a hole-fill (tail row moved
+  into the gap). Forward iteration pays that on every row and invalidates
+  indices ahead; `for (let r = rowCount - 1; r >= 0; r--)` removes only the tail,
+  so unvisited rows stay put. (See `world-bounds-plugin`, `transform-plugin`.)
+
+- **`getTypedArray()` for the hot path; `column.get()` for cold migrating loops.**
+  The every-frame path (e.g. solver writeback over all dynamics) reads/writes the
+  backing `Float32Array` directly — no allocation (see the hot-loop section
+  above). But a loop that **migrates rows as it goes** (the tag-on-completion
+  pattern) must NOT hold a hoisted `getTypedArray()` across the migration — the
+  buffer can move. Such loops run only over *new* rows (cold), so use
+  `column.get()` there: robust to the migration, and the small per-row
+  allocation is amortized to once-per-entity-lifetime.
+
+## Mirroring ECS state to an external engine (WASM physics, GPU, …)
+
+Each frame: (1) **sync** new entities into the engine — tag+exclude as above so
+this is O(new), not O(all); (2) step the engine; (3) **write back** only the
+subset that changed (e.g. dynamics — never statics) straight into the columns
+via `getTypedArray()`. Copy *into* the engine and *back* through typed-array
+indexing, not per-row object literals.
+
+Residual to watch: the **read-back from the engine** is bounded by the engine's
+JS binding. Some (e.g. `rapier3d-compat`) allocate a fresh `{x,y,z}` per getter
+call — a few allocations per moving body per frame. It scales with the *moving*
+count only; if that grows large, drop to the engine's raw/flat-buffer bindings
+to read straight into the typed arrays. Flagged at the call site in
+`rapier-solver-plugin.ts`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Adobe, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/core/core-plugin.d.ts

@@ -0,0 +1,44 @@
+import { FrameTime } from "./frame-time/frame-time.js";
+/**
+ * GPU runtime + frame scheduler — the shared base for both `graphics`
+ * (presentation) and `physics` (compute). Owns the WebGPU device, the
+ * per-frame command encoder, and the ordered frame phases. Contains nothing
+ * about canvases or render passes — those live in `graphics`.
+ *
+ * Phase order: input → preUpdate → update → postUpdate → physics → preRender
+ * → render → postRender. The command encoder is created at `preUpdate` and
+ * submitted at `postRender`; consumers record render passes (graphics) or
+ * compute passes (physics) into it during the phases between.
+ *
+ * Composes `FrameTime` over the scheduler so every downstream system has the
+ * `frameTime` resource — per-frame `dt` / `elapsed` — without re-deriving it.
+ */
+export declare const core: {
+    readonly components: {};
+    readonly resources: {
+        readonly frameTime: {
+            readonly default: FrameTime;
+            readonly transient: true;
+        };
+    } & {
+        readonly schedulerState: {
+            readonly default: import("@adobe/data/ecs").SchedulerState;
+        };
+    } & {
+        readonly device: {
+            readonly default: GPUDevice | null;
+            readonly transient: true;
+        };
+        readonly commandEncoder: {
+            readonly default: GPUCommandEncoder | null;
+            readonly transient: true;
+        };
+    };
+    readonly archetypes: {};
+    readonly transactions: {} & {};
+    readonly systems: import("@adobe/data/ecs").SystemDeclarations<"update" | "_frameTime" | "schedulerSystem" | "input" | "preUpdate" | "postUpdate" | "physics" | "preRender" | "render" | "postRender">;
+    readonly actions: {};
+    readonly services: {};
+    readonly computed: {};
+    readonly indexes: {};
+};

package/dist/core/core-plugin.js

@@ -0,0 +1,90 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database, scheduler } from "@adobe/data/ecs";
+import { FrameTime } from "./frame-time/frame-time.js";
+async function getWebGPUDevice() {
+    // Guard for headless hosts (Node) where `navigator` doesn't exist: the
+    // simulation runs without a GPU device; only rendering needs one.
+    if (typeof navigator === "undefined" || !navigator.gpu) {
+        return null;
+    }
+    const adapter = await navigator.gpu.requestAdapter();
+    if (!adapter) {
+        return null;
+    }
+    return adapter.requestDevice();
+}
+/**
+ * GPU runtime + frame scheduler — the shared base for both `graphics`
+ * (presentation) and `physics` (compute). Owns the WebGPU device, the
+ * per-frame command encoder, and the ordered frame phases. Contains nothing
+ * about canvases or render passes — those live in `graphics`.
+ *
+ * Phase order: input → preUpdate → update → postUpdate → physics → preRender
+ * → render → postRender. The command encoder is created at `preUpdate` and
+ * submitted at `postRender`; consumers record render passes (graphics) or
+ * compute passes (physics) into it during the phases between.
+ *
+ * Composes `FrameTime` over the scheduler so every downstream system has the
+ * `frameTime` resource — per-frame `dt` / `elapsed` — without re-deriving it.
+ */
+export const core = Database.Plugin.create({
+    extends: Database.Plugin.combine(scheduler, FrameTime.plugin),
+    resources: {
+        device: { default: null, transient: true },
+        commandEncoder: { default: null, transient: true },
+    },
+    systems: {
+        input: {
+            create: _db => () => { },
+        },
+        preUpdate: {
+            create: db => () => {
+                const { device } = db.store.resources;
+                if (device) {
+                    db.store.resources.commandEncoder = device.createCommandEncoder();
+                }
+            },
+            schedule: { after: ["input"] },
+        },
+        update: {
+            create: _db => () => { },
+            schedule: { after: ["preUpdate"] },
+        },
+        postUpdate: {
+            create: _db => () => { },
+            schedule: { after: ["update"] },
+        },
+        physics: {
+            create: _db => () => { },
+            schedule: { after: ["postUpdate"] },
+        },
+        preRender: {
+            create: _db => () => { },
+            schedule: { after: ["physics"] },
+        },
+        render: {
+            create: db => {
+                getWebGPUDevice().then(device => {
+                    db.store.resources.device = device;
+                });
+                return () => { };
+            },
+            schedule: { after: ["preRender"] },
+        },
+        // Submits the frame's command encoder. Graphics ends its render pass
+        // `before: ["postRender"]` (so the pass is closed first); physics
+        // finishes its compute passes during the `physics` phase — both record
+        // into this encoder beforehand.
+        postRender: {
+            create: db => () => {
+                const { commandEncoder, device } = db.store.resources;
+                if (commandEncoder && device) {
+                    device.queue.submit([commandEncoder.finish()]);
+                    db.store.resources.commandEncoder = null;
+                }
+            },
+            schedule: { after: ["render"] },
+        },
+    },
+});
+//# sourceMappingURL=core-plugin.js.map

package/dist/core/core-plugin.js.map

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

package/dist/core/frame-time/frame-time-plugin.d.ts

@@ -0,0 +1,25 @@
+import type { FrameTime } from "./frame-time.js";
+/**
+ * Publishes per-frame wall-clock timing as the `frameTime` resource. Declares
+ * its system but does not extend the scheduler — so pure-data consumers (and
+ * their tests) can pull in the `frameTime` resource without dragging in
+ * `requestAnimationFrame`. Composed with a scheduler (via `core`), the system
+ * runs in the first tier (no dependencies), so every later phase — update,
+ * physics, render — reads a `dt`/`elapsed` already advanced for this frame.
+ */
+export declare const plugin: {
+    readonly components: {};
+    readonly resources: {
+        readonly frameTime: {
+            readonly default: FrameTime;
+            readonly transient: true;
+        };
+    };
+    readonly archetypes: {};
+    readonly transactions: {};
+    readonly systems: import("@adobe/data/ecs").SystemDeclarations<"_frameTime">;
+    readonly actions: {};
+    readonly services: {};
+    readonly computed: {};
+    readonly indexes: {};
+};

package/dist/core/frame-time/frame-time-plugin.js

@@ -0,0 +1,41 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+/**
+ * Largest per-frame delta (seconds) the clock reports. A backgrounded tab or
+ * the very first frame would otherwise produce a multi-second `dt` that throws
+ * every time-stepped system off; clamping here means no consumer has to.
+ */
+const MAX_DELTA = 0.1;
+/**
+ * Publishes per-frame wall-clock timing as the `frameTime` resource. Declares
+ * its system but does not extend the scheduler — so pure-data consumers (and
+ * their tests) can pull in the `frameTime` resource without dragging in
+ * `requestAnimationFrame`. Composed with a scheduler (via `core`), the system
+ * runs in the first tier (no dependencies), so every later phase — update,
+ * physics, render — reads a `dt`/`elapsed` already advanced for this frame.
+ */
+export const plugin = Database.Plugin.create({
+    resources: {
+        frameTime: {
+            default: { now: 0, dt: 0, elapsed: 0 },
+            transient: true,
+        },
+    },
+    systems: {
+        _frameTime: {
+            create: db => {
+                let last = 0;
+                return () => {
+                    const now = performance.now();
+                    // first frame (last === 0) reports dt 0 — no work has elapsed yet
+                    const raw = last === 0 ? 0 : (now - last) / 1000;
+                    last = now;
+                    const dt = raw < MAX_DELTA ? raw : MAX_DELTA;
+                    const elapsed = db.store.resources.frameTime.elapsed + dt;
+                    db.store.resources.frameTime = { now, dt, elapsed };
+                };
+            },
+        },
+    },
+});
+//# sourceMappingURL=frame-time-plugin.js.map

package/dist/core/frame-time/frame-time-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-time-plugin.js","sourceRoot":"","sources":["../../../src/core/frame-time/frame-time-plugin.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAG3C;;;;GAIG;AACH,MAAM,SAAS,GAAG,GAAG,CAAC;AAEtB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC;IACzC,SAAS,EAAE;QACP,SAAS,EAAE;YACP,OAAO,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAmC;YACvE,SAAS,EAAE,IAAI;SAClB;KACJ;IACD,OAAO,EAAE;QACL,UAAU,EAAE;YACR,MAAM,EAAE,EAAE,CAAC,EAAE;gBACT,IAAI,IAAI,GAAG,CAAC,CAAC;gBACb,OAAO,GAAG,EAAE;oBACR,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;oBAC9B,kEAAkE;oBAClE,MAAM,GAAG,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;oBACjD,IAAI,GAAG,GAAG,CAAC;oBACX,MAAM,EAAE,GAAG,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;oBAC7C,MAAM,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,OAAO,GAAG,EAAE,CAAC;oBAC1D,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC;gBACxD,CAAC,CAAC;YACN,CAAC;SACJ;KACJ;CACJ,CAAC,CAAC"}

package/dist/core/frame-time/frame-time.d.ts

@@ -0,0 +1,18 @@
+export * as FrameTime from "./public.js";
+/**
+ * Wall-clock timing for the current frame, published once per frame by
+ * `FrameTime.plugin`. Any system that advances state over time reads this
+ * instead of calling `performance.now()` and tracking its own `lastTime`.
+ */
+export interface FrameTime {
+    /** `performance.now()` (ms) sampled at the start of this frame. */
+    readonly now: number;
+    /**
+     * Seconds since the previous frame, clamped to a sane maximum so a
+     * stalled tab or the first frame can't inject a huge time jump. A solver
+     * that needs a tighter stability bound clamps `dt` further at its own seam.
+     */
+    readonly dt: number;
+    /** Seconds since the plugin started — the running sum of clamped `dt`. */
+    readonly elapsed: number;
+}

package/dist/core/frame-time/frame-time.js

@@ -0,0 +1,3 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export * as FrameTime from "./public.js";
+//# sourceMappingURL=frame-time.js.map

package/dist/core/frame-time/frame-time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-time.js","sourceRoot":"","sources":["../../../src/core/frame-time/frame-time.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC"}

package/dist/core/frame-time/public.d.ts

@@ -0,0 +1 @@
+export { plugin } from "./frame-time-plugin.js";

package/dist/core/frame-time/public.js

@@ -0,0 +1,3 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export { plugin } from "./frame-time-plugin.js";
+//# sourceMappingURL=public.js.map

package/dist/core/frame-time/public.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.js","sourceRoot":"","sources":["../../../src/core/frame-time/public.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/graphics/animation/animation-data-plugin.d.ts

@@ -0,0 +1,216 @@
+import { Database, Entity } from "@adobe/data/ecs";
+import { AnimationTrack } from "../animation/animation-track/animation-track.js";
+declare const animationBase: {
+    readonly components: {
+        readonly animationClipTracks: {
+            readonly default: AnimationTrack[];
+        };
+        readonly animationClipDuration: {
+            readonly type: "number";
+            readonly precision: 2;
+            readonly default: number;
+        };
+        readonly animationClipRef: {
+            readonly type: "integer";
+            readonly minimum: -2147483648;
+            readonly maximum: 2147483647;
+            readonly default: number;
+        };
+        readonly animationTargets: {
+            readonly default: Entity[];
+        };
+        readonly animationTime: {
+            readonly type: "number";
+            readonly precision: 2;
+            readonly default: number;
+        };
+        readonly animationSpeed: {
+            readonly default: 1;
+            readonly type: "number";
+            readonly precision: 1;
+        };
+        readonly animationLoop: {
+            readonly type: "boolean";
+        };
+        readonly animationPlaying: {
+            readonly type: "boolean";
+        };
+        readonly animationObservable: {
+            readonly type: "boolean";
+            readonly const: true;
+            readonly default: true;
+        };
+    };
+    readonly resources: {};
+    readonly archetypes: {
+        readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
+        readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
+        readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
+    };
+    readonly transactions: {};
+    readonly systems: import("@adobe/data/ecs").SystemDeclarations<never>;
+    readonly actions: {};
+    readonly services: {};
+    readonly computed: {};
+    readonly indexes: {};
+};
+type AnimationStore = Database.Plugin.ToStore<typeof animationBase>;
+export declare const animationData: {
+    readonly components: {
+        readonly animationClipTracks: {
+            readonly default: AnimationTrack[];
+        };
+        readonly animationClipDuration: {
+            readonly type: "number";
+            readonly precision: 2;
+            readonly default: number;
+        };
+        readonly animationClipRef: {
+            readonly type: "integer";
+            readonly minimum: -2147483648;
+            readonly maximum: 2147483647;
+            readonly default: number;
+        };
+        readonly animationTargets: {
+            readonly default: Entity[];
+        };
+        readonly animationTime: {
+            readonly type: "number";
+            readonly precision: 2;
+            readonly default: number;
+        };
+        readonly animationSpeed: {
+            readonly default: 1;
+            readonly type: "number";
+            readonly precision: 1;
+        };
+        readonly animationLoop: {
+            readonly type: "boolean";
+        };
+        readonly animationPlaying: {
+            readonly type: "boolean";
+        };
+        readonly animationObservable: {
+            readonly type: "boolean";
+            readonly const: true;
+            readonly default: true;
+        };
+    } & {};
+    readonly resources: {};
+    readonly archetypes: {
+        readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
+        readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
+        readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
+    } & {};
+    readonly transactions: {} & {
+        readonly insertAnimationClip: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{} & {
+            readonly animationClipTracks: {
+                readonly default: AnimationTrack[];
+            };
+            readonly animationClipDuration: {
+                readonly type: "number";
+                readonly precision: 2;
+                readonly default: number;
+            };
+            readonly animationClipRef: {
+                readonly type: "integer";
+                readonly minimum: -2147483648;
+                readonly maximum: 2147483647;
+                readonly default: number;
+            };
+            readonly animationTargets: {
+                readonly default: Entity[];
+            };
+            readonly animationTime: {
+                readonly type: "number";
+                readonly precision: 2;
+                readonly default: number;
+            };
+            readonly animationSpeed: {
+                readonly default: 1;
+                readonly type: "number";
+                readonly precision: 1;
+            };
+            readonly animationLoop: {
+                readonly type: "boolean";
+            };
+            readonly animationPlaying: {
+                readonly type: "boolean";
+            };
+            readonly animationObservable: {
+                readonly type: "boolean";
+                readonly const: true;
+                readonly default: true;
+            };
+        }>, import("@adobe/data/schema").FromSchemas<{}>, {} & {
+            readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
+            readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
+            readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
+        }, {} & {}>, args: {
+            tracks: AnimationTrack[];
+            duration: number;
+        }) => number;
+        readonly insertAnimation: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{} & {
+            readonly animationClipTracks: {
+                readonly default: AnimationTrack[];
+            };
+            readonly animationClipDuration: {
+                readonly type: "number";
+                readonly precision: 2;
+                readonly default: number;
+            };
+            readonly animationClipRef: {
+                readonly type: "integer";
+                readonly minimum: -2147483648;
+                readonly maximum: 2147483647;
+                readonly default: number;
+            };
+            readonly animationTargets: {
+                readonly default: Entity[];
+            };
+            readonly animationTime: {
+                readonly type: "number";
+                readonly precision: 2;
+                readonly default: number;
+            };
+            readonly animationSpeed: {
+                readonly default: 1;
+                readonly type: "number";
+                readonly precision: 1;
+            };
+            readonly animationLoop: {
+                readonly type: "boolean";
+            };
+            readonly animationPlaying: {
+                readonly type: "boolean";
+            };
+            readonly animationObservable: {
+                readonly type: "boolean";
+                readonly const: true;
+                readonly default: true;
+            };
+        }>, import("@adobe/data/schema").FromSchemas<{}>, {} & {
+            readonly AnimationClip: readonly ["animationClipTracks", "animationClipDuration"];
+            readonly Animation: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying"];
+            readonly AnimationObservable: readonly ["animationClipRef", "animationTargets", "animationTime", "animationSpeed", "animationLoop", "animationPlaying", "animationObservable"];
+        }, {} & {}>, args: {
+            animationClipRef: number;
+            animationTargets: number[];
+            animationTime?: number;
+            animationSpeed?: number;
+            animationLoop?: boolean;
+            animationPlaying?: boolean;
+            observable?: boolean;
+        }) => number;
+        readonly advanceAnimations: (t: AnimationStore, args: {
+            dt: number;
+            observable: boolean;
+        }) => void;
+    };
+    readonly systems: import("@adobe/data/ecs").SystemDeclarations<never>;
+    readonly actions: {};
+    readonly services: {};
+    readonly computed: {};
+    readonly indexes: {} & {};
+};
+export {};