@vizij/runtime-react 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,33 +1,364 @@
 // src/VizijRuntimeProvider.tsx
-import {
-  useCallback,
-  useContext,
-  useEffect,
-  useMemo,
-  useRef,
-  useState
-} from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   VizijContext,
   createVizijStore,
   loadGLTFWithBundle,
   loadGLTFFromBlobWithBundle
 } from "@vizij/render";
-import {
-  OrchestratorProvider,
-  OrchestratorContext,
-  useOrchestrator,
-  useOrchFrame
-} from "@vizij/orchestrator-react";
 import { compileIrGraph } from "@vizij/node-graph-authoring";
 import { valueAsNumber as valueAsNumber2 } from "@vizij/value-json";
 import { getLookup } from "@vizij/utils";
+import { loadAnimationModule } from "@vizij/animation-module";
+
+// src/engine/aroraEngine.ts
+import {
+  init,
+  startRuntime
+} from "@vizij/runtime";
+
+// src/engine/graphSpecDiff.ts
+function asRecords(value) {
+  return Array.isArray(value) ? value : [];
+}
+function nodeId(node) {
+  return typeof node.id === "string" ? node.id : void 0;
+}
+function endpointId(endpoint) {
+  const id = endpoint?.node_id;
+  return typeof id === "string" ? id : void 0;
+}
+function endpointInput(endpoint) {
+  const input = endpoint?.input;
+  return typeof input === "string" ? input : void 0;
+}
+function stable(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortKeys(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+function edgeKey(edge) {
+  return stable([
+    endpointId(edge.from),
+    edge.from?.output ?? "out",
+    endpointId(edge.to),
+    endpointInput(edge.to),
+    edge.selector ?? null
+  ]);
+}
+function graphSpecDiff(prev, next) {
+  const prevNodes = /* @__PURE__ */ new Map();
+  for (const node of asRecords(prev.nodes)) {
+    const id = nodeId(node);
+    if (id) prevNodes.set(id, node);
+  }
+  const nextNodes = /* @__PURE__ */ new Map();
+  for (const node of asRecords(next.nodes)) {
+    const id = nodeId(node);
+    if (id) nextNodes.set(id, node);
+  }
+  const prevEdges = asRecords(prev.edges);
+  const nextEdges = asRecords(next.edges);
+  const remove_nodes = [...prevNodes.keys()].filter((id) => !nextNodes.has(id));
+  const upsertIds = /* @__PURE__ */ new Set();
+  for (const [id, node] of nextNodes) {
+    const before = prevNodes.get(id);
+    if (!before || stable(before) !== stable(node)) upsertIds.add(id);
+  }
+  const prevEdgeKeys = new Set(prevEdges.map(edgeKey));
+  const nextEdgeKeys = new Set(nextEdges.map(edgeKey));
+  const removedEdges = prevEdges.filter((e) => !nextEdgeKeys.has(edgeKey(e)));
+  const changedEdges = [
+    ...nextEdges.filter((e) => !prevEdgeKeys.has(edgeKey(e))),
+    ...removedEdges
+  ];
+  for (const edge of changedEdges) {
+    for (const id of [endpointId(edge.from), endpointId(edge.to)]) {
+      if (id && nextNodes.has(id)) upsertIds.add(id);
+    }
+  }
+  const incidentToUpsert = (edge) => {
+    const from = endpointId(edge.from);
+    const to = endpointId(edge.to);
+    return from !== void 0 && upsertIds.has(from) || to !== void 0 && upsertIds.has(to);
+  };
+  const upsert_nodes = [...upsertIds].map((id) => nextNodes.get(id));
+  const upsert_edges = nextEdges.filter(incidentToUpsert);
+  const removeNodeSet = new Set(remove_nodes);
+  const remove_edges = removedEdges.flatMap((edge) => {
+    const to = endpointId(edge.to);
+    const input = endpointInput(edge.to);
+    if (!to || !input || removeNodeSet.has(to) || upsertIds.has(to)) return [];
+    return [{ node_id: to, input }];
+  });
+  if (upsert_nodes.length === 0 && remove_nodes.length === 0 && upsert_edges.length === 0 && remove_edges.length === 0) {
+    return null;
+  }
+  return { upsert_nodes, remove_nodes, upsert_edges, remove_edges };
+}
+
+// src/engine/aroraEngine.ts
+var BUILT_IN_PREFIX = "arora/";
+function isBuiltInPath(path) {
+  return path.startsWith(BUILT_IN_PREFIX);
+}
+var RUN_PERIOD_MS = 1e3 / 60;
+var initPromise = null;
+function ensureWasmInit(input) {
+  if (!initPromise) {
+    initPromise = init(input);
+  }
+  return initPromise;
+}
+var DeviceSlot = class {
+  constructor() {
+    this.handle = null;
+    /** Module loading a boot must wait out before it reads `modules`. */
+    this.modulesLoading = null;
+    /**
+     * When set, a booted device is handed to its own loop (`device.run`) at
+     * this period. `null`: the host drives `step()` itself.
+     */
+    this.runPeriodMs = null;
+    /**
+     * Serializes device operations. Every `recompose` chains behind the
+     * previous op so two never run concurrently — a bundle whose import fans
+     * out into several graph registrations recomposes in a burst. Failures are
+     * swallowed on the chain so one failed op doesn't wedge later ones; each
+     * caller still sees its own rejection through the promise `enqueue`
+     * returns.
+     */
+    this.opChain = Promise.resolve();
+  }
+  get current() {
+    return this.handle;
+  }
+  /**
+   * The modules every subsequent device boot loads. The live device (if any)
+   * is not touched: a later `recompose` that sees the list changed rebuilds.
+   */
+  setModules(modules) {
+    this.modules = modules && modules.length > 0 ? modules : void 0;
+  }
+  /**
+   * Announce module loading in flight: boots wait for `loading` to settle
+   * before reading the module list, so a device never boots without modules
+   * that were already on their way. Pass a promise that cannot reject (the
+   * owner handles its own failures) — boots resume either way.
+   */
+  waitForModules(loading) {
+    this.modulesLoading = loading;
+  }
+  /**
+   * Hand the live device to its own loop, if there is one and `runPeriodMs`
+   * says so — for a host whose drive mode turns self-paced after boot.
+   */
+  startRun() {
+    if (this.handle) {
+      this.maybeRun(this.handle.device);
+    }
+  }
+  maybeRun(device) {
+    if (this.runPeriodMs === null || device.running) {
+      return;
+    }
+    device.run(this.runPeriodMs).catch((error) => {
+      this.onRunEnded?.(error);
+    });
+  }
+  enqueue(op) {
+    const run = this.opChain.then(op, op);
+    this.opChain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  async boot(spec) {
+    await ensureWasmInit();
+    if (this.modulesLoading) {
+      await this.modulesLoading;
+    }
+    const device = await startRuntime(spec, void 0, this.modules);
+    this.handle = { device, spec, modules: this.modules };
+    this.onDeviceStarted?.(this.handle);
+    this.maybeRun(device);
+    return this.handle;
+  }
+  /**
+   * Rebuild the device because its module set changed since boot — the one
+   * change a live device cannot take. Carries the store across (snapshot
+   * minus built-in keys) and replays module setup via `onDeviceStarted`. The
+   * old device's wrapper is freed; if it was self-paced its loop keeps
+   * ticking unreachable — which is why boots wait for announced modules
+   * instead of leaning on this path.
+   */
+  async rebuild(old, spec) {
+    const carried = {};
+    for (const [path, value] of Object.entries(old.device.snapshot())) {
+      if (!isBuiltInPath(path)) {
+        carried[path] = value;
+      }
+    }
+    const device = await startRuntime(spec, void 0, this.modules);
+    if (Object.keys(carried).length > 0) {
+      device.writeValues(carried);
+    }
+    this.handle = { device, spec, modules: this.modules };
+    old.device.dispose();
+    this.onDeviceStarted?.(this.handle);
+    this.maybeRun(device);
+    return this.handle;
+  }
+  /**
+   * Make the device run `spec`: boot it if none is live, otherwise swap the
+   * graph in place (the store is the same store, so nothing is carried).
+   * No-op if the spec is identical by reference. Serialized behind any
+   * in-flight op (see `opChain`).
+   */
+  recompose(spec) {
+    return this.enqueue(async () => {
+      const old = this.handle;
+      if (!old) {
+        return this.boot(spec);
+      }
+      if (old.modules !== this.modules) {
+        return this.rebuild(old, spec);
+      }
+      if (old.spec === spec) {
+        return old;
+      }
+      const edits = graphSpecDiff(old.spec, spec);
+      if (edits) {
+        try {
+          await old.device.applyGraphEdits(edits);
+        } catch (err) {
+          console.warn(
+            "[vizij-runtime] applyGraphEdits failed; reloading the whole graph",
+            err
+          );
+          await old.device.loadGraph(spec);
+        }
+      }
+      old.spec = spec;
+      return old;
+    });
+  }
+};
+
+// src/utils/composeGraph.ts
+function asArray(value) {
+  return Array.isArray(value) ? value.filter((n) => n && typeof n === "object") : [];
+}
+function prefixId(sourceId, id) {
+  return typeof id === "string" && id ? `${sourceId}::${id}` : id;
+}
+function prefixEndpoint(sourceId, endpoint) {
+  if (!endpoint || typeof endpoint !== "object") {
+    return endpoint;
+  }
+  const record = endpoint;
+  if (typeof record.node_id !== "string") {
+    return endpoint;
+  }
+  return { ...record, node_id: prefixId(sourceId, record.node_id) };
+}
+function outputPathsOf(spec) {
+  const paths = [];
+  for (const node of asArray(spec.nodes)) {
+    if (String(node.type ?? "").toLowerCase() !== "output") {
+      continue;
+    }
+    const path = node.params?.path;
+    if (typeof path === "string" && path.trim()) {
+      paths.push(path.trim());
+    }
+  }
+  return paths;
+}
+function composeGraphSpecs(sources) {
+  const nodes = [];
+  const edges = [];
+  const outputOwners = /* @__PURE__ */ new Map();
+  for (const { sourceId, spec } of sources) {
+    for (const path of outputPathsOf(spec)) {
+      const owner = outputOwners.get(path);
+      if (owner && owner !== sourceId) {
+        console.warn(
+          `[vizij-runtime] output path "${path}" is written by both "${owner}" and "${sourceId}"; last writer wins ("${sourceId}"). There is no combiner node for additive merges yet.`
+        );
+      }
+      outputOwners.set(path, sourceId);
+    }
+    for (const node of asArray(spec.nodes)) {
+      nodes.push({ ...node, id: prefixId(sourceId, node.id) });
+    }
+    for (const edge of asArray(spec.edges)) {
+      edges.push({
+        ...edge,
+        from: prefixEndpoint(sourceId, edge.from),
+        to: prefixEndpoint(sourceId, edge.to)
+      });
+    }
+  }
+  return { nodes, edges };
+}
 
 // src/context.ts
 import { createContext } from "react";
 var VizijRuntimeContext = createContext(null);
 
+// src/memoryInvestigation.ts
+function getGlobalMemoryInvestigation() {
+  return globalThis;
+}
+function updateRuntimeMap(updater) {
+  const globalObj = getGlobalMemoryInvestigation();
+  if (!globalObj.__VIZIJ_MEMORY_INVESTIGATION__?.enabled) {
+    return;
+  }
+  if (!globalObj.__vizijMemoryDebugState) {
+    globalObj.__vizijMemoryDebugState = {};
+  }
+  if (!globalObj.__vizijMemoryDebugState.runtimes) {
+    globalObj.__vizijMemoryDebugState.runtimes = {};
+  }
+  updater(globalObj.__vizijMemoryDebugState.runtimes);
+}
+function setRuntimeDebugState(runtimeId, state) {
+  updateRuntimeMap((runtimeMap) => {
+    runtimeMap[runtimeId] = state;
+  });
+}
+function clearRuntimeDebugState(runtimeId) {
+  updateRuntimeMap((runtimeMap) => {
+    delete runtimeMap[runtimeId];
+  });
+}
+
 // src/updatePolicy.ts
+var blobIdentityMap = /* @__PURE__ */ new WeakMap();
+var nextBlobIdentity = 0;
+function getBlobIdentity(blob) {
+  if (!blob) {
+    return "missing";
+  }
+  let identity = blobIdentityMap.get(blob);
+  if (identity === void 0) {
+    identity = nextBlobIdentity++;
+    blobIdentityMap.set(blob, identity);
+  }
+  return `${identity}:${blob.size}:${blob.type}`;
+}
 function applyRuntimeGraphBundle(base, bundle) {
   const next = {
     ...base
@@ -43,18 +374,10 @@ function applyRuntimeGraphBundle(base, bundle) {
     "programs"
   );
   if (hasRigOverride) {
-    if (bundle.rig) {
-      next.rig = bundle.rig;
-    } else {
-      delete next.rig;
-    }
+    next.rig = bundle.rig;
   }
   if (hasPoseOverride) {
-    if (bundle.pose) {
-      next.pose = bundle.pose;
-    } else {
-      delete next.pose;
-    }
+    next.pose = bundle.pose;
   }
   if (hasAnimationsOverride) {
     next.animations = Array.isArray(bundle.animations) ? bundle.animations : void 0;
@@ -76,10 +399,18 @@ function normalizeSpecPayload(value) {
 }
 function glbSignature(glb) {
   if (glb.kind === "url") {
-    return `url:${glb.src}`;
+    const importOptions = normalizeSpecPayload({
+      aggressiveImport: glb.aggressiveImport ?? false,
+      rootBounds: glb.rootBounds ?? null
+    });
+    return `url:${glb.src}:${importOptions}`;
   }
   if (glb.kind === "blob") {
-    return `blob:${glb.blob?.size ?? 0}`;
+    const importOptions = normalizeSpecPayload({
+      aggressiveImport: glb.aggressiveImport ?? false,
+      rootBounds: glb.rootBounds ?? null
+    });
+    return `blob:${getBlobIdentity(glb.blob)}:${importOptions}`;
   }
   return `world:${normalizeSpecPayload(glb.world)}`;
 }
@@ -573,65 +904,20 @@ function resolvePoseControlInputPath({
 }
 
 // src/utils/clipPlayback.ts
-var EPSILON = 1e-6;
 function toFiniteNumber(value, fallback) {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : fallback;
 }
-function normaliseInterpolation(interpolation) {
-  const mode = typeof interpolation === "string" ? interpolation.trim().toLowerCase() : "linear";
-  if (mode === "step") {
-    return "step";
-  }
-  if (mode === "cubic" || mode === "cubicspline") {
-    return "cubic";
-  }
-  return "linear";
-}
-function asNumericKeyframe(keyframe) {
-  if (!keyframe || typeof keyframe !== "object") {
-    return null;
-  }
-  const time = Number(keyframe.time);
-  const value = Number(keyframe.value);
-  if (!Number.isFinite(time) || !Number.isFinite(value)) {
-    return null;
-  }
-  const inTangentRaw = keyframe.inTangent;
-  const outTangentRaw = keyframe.outTangent;
-  const inTangent = inTangentRaw == null || Number.isFinite(Number(inTangentRaw)) ? inTangentRaw : void 0;
-  const outTangent = outTangentRaw == null || Number.isFinite(Number(outTangentRaw)) ? outTangentRaw : void 0;
-  return {
-    time,
-    value,
-    inTangent,
-    outTangent
-  };
-}
-function getNumericKeyframes(track) {
+function lastKeyframeTime(track) {
   const keyframes = Array.isArray(track.keyframes) ? track.keyframes : [];
-  const numeric = keyframes.map((keyframe) => asNumericKeyframe(keyframe)).filter((keyframe) => Boolean(keyframe));
-  if (numeric.length <= 1) {
-    return numeric;
-  }
-  return [...numeric].sort((a, b) => a.time - b.time);
-}
-function resolveTangent(value, fallback) {
-  const parsed = Number(value);
-  if (Number.isFinite(parsed)) {
-    return parsed;
-  }
-  return fallback;
-}
-function sampleHermite(startValue, endValue, outTangent, inTangent, factor, duration) {
-  const t = factor;
-  const t2 = t * t;
-  const t3 = t2 * t;
-  const h00 = 2 * t3 - 3 * t2 + 1;
-  const h10 = t3 - 2 * t2 + t;
-  const h01 = -2 * t3 + 3 * t2;
-  const h11 = t3 - t2;
-  return h00 * startValue + h10 * outTangent * duration + h01 * endValue + h11 * inTangent * duration;
+  let maxTime = 0;
+  keyframes.forEach((keyframe) => {
+    const time = Number(keyframe?.time);
+    if (Number.isFinite(time) && time > maxTime) {
+      maxTime = time;
+    }
+  });
+  return maxTime;
 }
 function resolveClipDurationSeconds(clip, fallbackDurationSeconds = 0) {
   const fallback = Math.max(0, toFiniteNumber(fallbackDurationSeconds, 0));
@@ -645,109 +931,13 @@ function resolveClipDurationSeconds(clip, fallbackDurationSeconds = 0) {
   const tracks = Array.isArray(clip.tracks) ? clip.tracks : [];
   let maxTime = 0;
   tracks.forEach((track) => {
-    const keyframes = getNumericKeyframes(track);
-    const last = keyframes[keyframes.length - 1];
-    if (last && last.time > maxTime) {
-      maxTime = last.time;
+    const time = lastKeyframeTime(track);
+    if (time > maxTime) {
+      maxTime = time;
     }
   });
   return maxTime > 0 ? maxTime : fallback;
 }
-function clampAnimationTime(time, duration) {
-  if (!Number.isFinite(duration) || duration <= 0) {
-    return 0;
-  }
-  if (!Number.isFinite(time)) {
-    return 0;
-  }
-  if (time <= 0) {
-    return 0;
-  }
-  if (time >= duration) {
-    return duration;
-  }
-  return time;
-}
-function advanceClipTime(state, dt) {
-  const duration = Math.max(0, toFiniteNumber(state.duration, 0));
-  const speed = Number.isFinite(state.speed) && state.speed > 0 ? state.speed : 1;
-  const currentTime = clampAnimationTime(state.time, duration);
-  const delta = Number.isFinite(dt) && dt > 0 ? Math.max(0, dt) * speed : 0;
-  if (!state.playing || delta <= 0) {
-    return { time: currentTime, completed: false };
-  }
-  if (duration <= 0) {
-    return { time: 0, completed: true };
-  }
-  const nextTime = currentTime + delta;
-  if (state.loop) {
-    if (nextTime < duration) {
-      return { time: nextTime, completed: false };
-    }
-    const wrapped = (nextTime % duration + duration) % duration;
-    return { time: wrapped, completed: false };
-  }
-  if (nextTime >= duration - EPSILON) {
-    return { time: duration, completed: true };
-  }
-  return { time: nextTime, completed: false };
-}
-function sampleTrackAtTime(track, timeSeconds) {
-  const keyframes = getNumericKeyframes(track);
-  if (keyframes.length === 0) {
-    return 0;
-  }
-  if (keyframes.length === 1) {
-    return keyframes[0].value;
-  }
-  const mode = normaliseInterpolation(track.interpolation);
-  const time = Number.isFinite(timeSeconds) ? timeSeconds : 0;
-  const first = keyframes[0];
-  if (time <= first.time + EPSILON) {
-    return first.value;
-  }
-  const last = keyframes[keyframes.length - 1];
-  if (time >= last.time - EPSILON) {
-    return last.value;
-  }
-  for (let i = 0; i < keyframes.length - 1; i += 1) {
-    const current = keyframes[i];
-    const next = keyframes[i + 1];
-    const start = current.time;
-    const end = next.time;
-    const duration = end - start;
-    if (duration <= EPSILON) {
-      if (time <= end + EPSILON) {
-        return next.value;
-      }
-      continue;
-    }
-    if (Math.abs(time - end) <= EPSILON) {
-      return next.value;
-    }
-    if (time < end) {
-      const factor = (time - start) / duration;
-      if (mode === "step") {
-        return current.value;
-      }
-      if (mode === "cubic") {
-        const slope = (next.value - current.value) / duration;
-        const outTangent = resolveTangent(current.outTangent, slope);
-        const inTangent = resolveTangent(next.inTangent, slope);
-        return sampleHermite(
-          current.value,
-          next.value,
-          outTangent,
-          inTangent,
-          factor,
-          duration
-        );
-      }
-      return current.value + (next.value - current.value) * factor;
-    }
-  }
-  return last.value;
-}
 
 // src/utils/animationBridge.ts
 function resolveAnimationBridgeOutputPaths(channel, faceId, rigInputMap) {
@@ -818,56 +1008,10 @@ function collectAnimationClipOutputPaths(clip, faceId, rigInputMap) {
     (left, right) => left.localeCompare(right)
   );
 }
-function sampleAnimationClipOutputValues(clip, timeSeconds, weight = 1, faceId, rigInputMap) {
-  const appliedWeight = Number.isFinite(weight) && weight >= 0 ? Number(weight) : 1;
-  const outputValues = /* @__PURE__ */ new Map();
-  const tracks = Array.isArray(clip.tracks) ? clip.tracks : [];
-  tracks.forEach((track) => {
-    const channel = typeof track.channel === "string" ? track.channel.trim() : "";
-    if (!channel) {
-      return;
-    }
-    const sampledValue = sampleTrackAtTime(
-      track,
-      timeSeconds
-    );
-    const weightedValue = sampledValue * appliedWeight;
-    resolveAnimationBridgeOutputPaths(channel, faceId, rigInputMap).forEach(
-      (path) => {
-        outputValues.set(path, (outputValues.get(path) ?? 0) + weightedValue);
-      }
-    );
-  });
-  return outputValues;
-}
-function diffAnimationAggregateValues(previousAggregate, nextAggregate, epsilon = 1e-6) {
-  const operations = [];
-  const changedPaths = /* @__PURE__ */ new Set();
-  previousAggregate.forEach((previousValue, path) => {
-    const nextValue = nextAggregate.get(path);
-    if (nextValue === void 0 || Math.abs(nextValue - previousValue) > epsilon) {
-      changedPaths.add(path);
-    }
-  });
-  nextAggregate.forEach((nextValue, path) => {
-    const previousValue = previousAggregate.get(path);
-    if (previousValue === void 0 || Math.abs(nextValue - previousValue) > epsilon) {
-      changedPaths.add(path);
-    }
-  });
-  changedPaths.forEach((path) => {
-    const nextValue = nextAggregate.get(path);
-    if (nextValue === void 0) {
-      operations.push({ kind: "clear", path });
-      return;
-    }
-    operations.push({ kind: "set", path, value: nextValue });
-  });
-  return operations;
-}
 
 // src/utils/valueConversion.ts
 import {
+  fromAroraValueJSON,
   isNormalizedValue,
   valueAsBool,
   valueAsColorRgba,
@@ -920,27 +1064,28 @@ function valueJSONToRaw(value) {
   if (Array.isArray(value)) {
     return value.map((entry) => valueJSONToRaw(entry));
   }
-  if (typeof value === "object" && !("type" in value)) {
-    const entries = Object.entries(value).map(([key, entry]) => [
-      key,
-      valueJSONToRaw(entry)
-    ]);
-    return Object.fromEntries(entries);
-  }
-  if (!isNormalizedValue(value)) {
+  const normalized = isNormalizedValue(value) ? value : fromAroraValueJSON(value);
+  if (normalized === void 0) {
+    if (typeof value === "object" && !("type" in value)) {
+      const entries = Object.entries(value).map(([key, entry]) => [
+        key,
+        valueJSONToRaw(entry)
+      ]);
+      return Object.fromEntries(entries);
+    }
     return void 0;
   }
-  switch (value.type) {
+  switch (normalized.type) {
     case "float": {
-      const num = valueAsNumber(value);
+      const num = valueAsNumber(normalized);
       return typeof num === "number" ? num : void 0;
     }
     case "bool": {
-      const boolVal = valueAsBool(value);
+      const boolVal = valueAsBool(normalized);
       return typeof boolVal === "boolean" ? boolVal : void 0;
     }
     case "text": {
-      const text = valueAsText(value);
+      const text = valueAsText(normalized);
       return typeof text === "string" ? text : void 0;
     }
     case "vec2":
@@ -948,11 +1093,11 @@ function valueJSONToRaw(value) {
     case "vec4":
     case "quat":
     case "vector": {
-      const vec = valueAsVector(value);
+      const vec = valueAsVector(normalized);
       return vec ? numericArrayToRaw(vec) : void 0;
     }
     case "colorrgba": {
-      const color = valueAsColorRgba(value);
+      const color = valueAsColorRgba(normalized);
       if (!color) {
         return void 0;
       }
@@ -960,7 +1105,7 @@ function valueJSONToRaw(value) {
       return { r, g, b, a };
     }
     case "transform": {
-      const transform = valueAsTransform(value);
+      const transform = valueAsTransform(normalized);
       if (!transform) {
         return void 0;
       }
@@ -970,15 +1115,20 @@ function valueJSONToRaw(value) {
         scale: numericArrayToRaw(transform.scale)
       };
     }
+    case "array":
+    case "list":
+    case "tuple":
+      return (normalized.data ?? []).map(
+        (entry) => valueJSONToRaw(entry)
+      );
     case "record": {
-      const entries = Object.entries(value.data ?? {}).map(([key, entry]) => [
-        key,
-        valueJSONToRaw(entry)
-      ]);
+      const entries = Object.entries(normalized.data ?? {}).map(
+        ([key, entry]) => [key, valueJSONToRaw(entry)]
+      );
       return Object.fromEntries(entries);
     }
     case "enum": {
-      const [tag, inner] = value.data;
+      const [tag, inner] = normalized.data;
       return {
         tag,
         value: valueJSONToRaw(inner)
@@ -989,17 +1139,608 @@ function valueJSONToRaw(value) {
   }
 }
 
+// src/engine/animationModule.ts
+var ANIMATION_MODULE_FN = {
+  loadAnimation: "76697a69-6a00-0000-0f00-000000000001",
+  createPlayer: "76697a69-6a00-0000-0f00-000000000002",
+  addInstance: "76697a69-6a00-0000-0f00-000000000003",
+  step: "76697a69-6a00-0000-0f00-000000000004",
+  play: "76697a69-6a00-0000-0f00-000000000005",
+  pause: "76697a69-6a00-0000-0f00-000000000006",
+  stop: "76697a69-6a00-0000-0f00-000000000007",
+  seek: "76697a69-6a00-0000-0f00-000000000008",
+  setSpeed: "76697a69-6a00-0000-0f00-000000000009",
+  setLoop: "76697a69-6a00-0000-0f00-00000000000a",
+  setWeight: "76697a69-6a00-0000-0f00-00000000000b",
+  removeInstance: "76697a69-6a00-0000-0f00-00000000000c",
+  playerStates: "76697a69-6a00-0000-0f00-00000000000d"
+};
+var ANIMATION_MODULE_PARAM = {
+  clip: "76697a69-6a00-0000-0f01-000000000001",
+  playerName: "76697a69-6a00-0000-0f02-000000000001",
+  player: "76697a69-6a00-0000-0f03-000000000001",
+  anim: "76697a69-6a00-0000-0f03-000000000002",
+  dtNs: "76697a69-6a00-0000-0f04-000000000001",
+  playPlayer: "76697a69-6a00-0000-0f05-000000000001",
+  pausePlayer: "76697a69-6a00-0000-0f06-000000000001",
+  stopPlayer: "76697a69-6a00-0000-0f07-000000000001",
+  seekPlayer: "76697a69-6a00-0000-0f08-000000000001",
+  seekTimeNs: "76697a69-6a00-0000-0f08-000000000002",
+  speedPlayer: "76697a69-6a00-0000-0f09-000000000001",
+  speedValue: "76697a69-6a00-0000-0f09-000000000002",
+  loopPlayer: "76697a69-6a00-0000-0f0a-000000000001",
+  loopMode: "76697a69-6a00-0000-0f0a-000000000002",
+  weightPlayer: "76697a69-6a00-0000-0f0b-000000000001",
+  weightInstance: "76697a69-6a00-0000-0f0b-000000000002",
+  weightValue: "76697a69-6a00-0000-0f0b-000000000003",
+  removePlayer: "76697a69-6a00-0000-0f0c-000000000001",
+  removeInstance: "76697a69-6a00-0000-0f0c-000000000002"
+};
+var ANIMATION_MODULE_TYPE = {
+  clip: "76697a69-6a00-0000-0000-000000000100",
+  track: "76697a69-6a00-0000-0000-000000000101",
+  keypoint: "76697a69-6a00-0000-0000-000000000102",
+  transitionHandle: "76697a69-6a00-0000-0000-000000000103",
+  trackOutput: "76697a69-6a00-0000-0000-000000000110",
+  playerState: "76697a69-6a00-0000-0000-000000000111"
+};
+var ANIMATION_MODULE_FIELD = {
+  clipName: "76697a69-6a00-0000-0100-000000000001",
+  clipDuration: "76697a69-6a00-0000-0100-000000000002",
+  clipTracks: "76697a69-6a00-0000-0100-000000000003",
+  trackId: "76697a69-6a00-0000-0101-000000000001",
+  trackName: "76697a69-6a00-0000-0101-000000000002",
+  trackAnimatable: "76697a69-6a00-0000-0101-000000000003",
+  trackPoints: "76697a69-6a00-0000-0101-000000000004",
+  keypointId: "76697a69-6a00-0000-0102-000000000001",
+  keypointStamp: "76697a69-6a00-0000-0102-000000000002",
+  keypointValue: "76697a69-6a00-0000-0102-000000000003",
+  keypointTransitionsIn: "76697a69-6a00-0000-0102-000000000004",
+  keypointTransitionsOut: "76697a69-6a00-0000-0102-000000000005",
+  handleX: "76697a69-6a00-0000-0103-000000000001",
+  handleY: "76697a69-6a00-0000-0103-000000000002",
+  outputTrackId: "76697a69-6a00-0000-0110-000000000001",
+  outputDefaultKey: "76697a69-6a00-0000-0110-000000000002",
+  outputValue: "76697a69-6a00-0000-0110-000000000003",
+  statePlayer: "76697a69-6a00-0000-0111-000000000001",
+  stateState: "76697a69-6a00-0000-0111-000000000002",
+  stateTimeNs: "76697a69-6a00-0000-0111-000000000003",
+  stateDurationNs: "76697a69-6a00-0000-0111-000000000004",
+  stateSpeed: "76697a69-6a00-0000-0111-000000000005"
+};
+var field = (id, value) => ({
+  id,
+  value
+});
+function storedClipToModuleValue(clip, resolveKeys) {
+  const name = typeof clip.name === "string" && clip.name.trim().length > 0 ? clip.name.trim() : typeof clip.id === "string" ? clip.id : "";
+  const durationMs = Number(clip.duration);
+  const duration = Number.isFinite(durationMs) && durationMs > 0 ? Math.round(durationMs) : 1;
+  const tracks = (Array.isArray(clip.tracks) ? clip.tracks : []).map((rawTrack, index) => {
+    if (!rawTrack || typeof rawTrack !== "object") {
+      return null;
+    }
+    const animatableId = typeof rawTrack.animatableId === "string" ? rawTrack.animatableId.trim() : "";
+    if (!animatableId) {
+      return null;
+    }
+    const trackId = typeof rawTrack.id === "string" && rawTrack.id.trim().length > 0 ? rawTrack.id.trim() : `track-${index}`;
+    const trackName = typeof rawTrack.name === "string" && rawTrack.name.trim().length > 0 ? rawTrack.name.trim() : trackId;
+    const points = (Array.isArray(rawTrack.points) ? rawTrack.points : []).map((rawPoint, pointIndex) => {
+      if (!rawPoint || typeof rawPoint !== "object") {
+        return null;
+      }
+      const stamp = Number(rawPoint.stamp);
+      const value = Number(rawPoint.value);
+      if (!Number.isFinite(stamp) || !Number.isFinite(value)) {
+        return null;
+      }
+      const pointId = typeof rawPoint.id === "string" && rawPoint.id.trim().length > 0 ? rawPoint.id.trim() : `${trackId}:point-${pointIndex}`;
+      const handles = (handle) => ({
+        structs: {
+          id: ANIMATION_MODULE_TYPE.transitionHandle,
+          elements: handle ? [
+            {
+              fields: [
+                field(ANIMATION_MODULE_FIELD.handleX, {
+                  f32: handle.x
+                }),
+                field(ANIMATION_MODULE_FIELD.handleY, {
+                  f32: handle.y
+                })
+              ]
+            }
+          ] : []
+        }
+      });
+      return {
+        fields: [
+          field(ANIMATION_MODULE_FIELD.keypointId, { str: pointId }),
+          field(ANIMATION_MODULE_FIELD.keypointStamp, {
+            f32: Math.max(0, Math.min(1, stamp))
+          }),
+          field(ANIMATION_MODULE_FIELD.keypointValue, { f32: value }),
+          field(
+            ANIMATION_MODULE_FIELD.keypointTransitionsIn,
+            handles(rawPoint.transitions?.in)
+          ),
+          field(
+            ANIMATION_MODULE_FIELD.keypointTransitionsOut,
+            handles(rawPoint.transitions?.out)
+          )
+        ]
+      };
+    }).filter(Boolean);
+    if (points.length === 0) {
+      return null;
+    }
+    const targets = resolveKeys?.(animatableId) ?? [animatableId];
+    return targets.map((target, targetIndex) => ({
+      fields: [
+        field(ANIMATION_MODULE_FIELD.trackId, {
+          str: targetIndex === 0 ? trackId : `${trackId}~${targetIndex}`
+        }),
+        field(ANIMATION_MODULE_FIELD.trackName, { str: trackName }),
+        field(ANIMATION_MODULE_FIELD.trackAnimatable, { str: target }),
+        field(ANIMATION_MODULE_FIELD.trackPoints, {
+          structs: {
+            id: ANIMATION_MODULE_TYPE.keypoint,
+            elements: points
+          }
+        })
+      ]
+    }));
+  }).filter(Boolean).flat();
+  return {
+    struct: {
+      id: ANIMATION_MODULE_TYPE.clip,
+      fields: [
+        field(ANIMATION_MODULE_FIELD.clipName, { str: name }),
+        field(ANIMATION_MODULE_FIELD.clipDuration, { u32: duration }),
+        field(ANIMATION_MODULE_FIELD.clipTracks, {
+          structs: {
+            id: ANIMATION_MODULE_TYPE.track,
+            elements: tracks
+          }
+        })
+      ]
+    }
+  };
+}
+function loadAnimationCall(clipValue) {
+  return {
+    id: ANIMATION_MODULE_FN.loadAnimation,
+    args: [field(ANIMATION_MODULE_PARAM.clip, clipValue)]
+  };
+}
+function createPlayerCall(name) {
+  return {
+    id: ANIMATION_MODULE_FN.createPlayer,
+    args: [field(ANIMATION_MODULE_PARAM.playerName, { str: name })]
+  };
+}
+function addInstanceCall(player, anim) {
+  return {
+    id: ANIMATION_MODULE_FN.addInstance,
+    args: [
+      field(ANIMATION_MODULE_PARAM.player, { u32: player }),
+      field(ANIMATION_MODULE_PARAM.anim, { u32: anim })
+    ]
+  };
+}
+function playCall(player) {
+  return {
+    id: ANIMATION_MODULE_FN.play,
+    args: [field(ANIMATION_MODULE_PARAM.playPlayer, { u32: player })]
+  };
+}
+function pauseCall(player) {
+  return {
+    id: ANIMATION_MODULE_FN.pause,
+    args: [field(ANIMATION_MODULE_PARAM.pausePlayer, { u32: player })]
+  };
+}
+function stopCall(player) {
+  return {
+    id: ANIMATION_MODULE_FN.stop,
+    args: [field(ANIMATION_MODULE_PARAM.stopPlayer, { u32: player })]
+  };
+}
+function seekCall(player, timeNs) {
+  return {
+    id: ANIMATION_MODULE_FN.seek,
+    args: [
+      field(ANIMATION_MODULE_PARAM.seekPlayer, { u32: player }),
+      field(ANIMATION_MODULE_PARAM.seekTimeNs, {
+        u64: Math.max(0, Math.round(timeNs))
+      })
+    ]
+  };
+}
+function setSpeedCall(player, speed) {
+  return {
+    id: ANIMATION_MODULE_FN.setSpeed,
+    args: [
+      field(ANIMATION_MODULE_PARAM.speedPlayer, { u32: player }),
+      field(ANIMATION_MODULE_PARAM.speedValue, { f32: speed })
+    ]
+  };
+}
+function setLoopCall(player, mode) {
+  return {
+    id: ANIMATION_MODULE_FN.setLoop,
+    args: [
+      field(ANIMATION_MODULE_PARAM.loopPlayer, { u32: player }),
+      field(ANIMATION_MODULE_PARAM.loopMode, { str: mode })
+    ]
+  };
+}
+function setWeightCall(player, instance, weight) {
+  return {
+    id: ANIMATION_MODULE_FN.setWeight,
+    args: [
+      field(ANIMATION_MODULE_PARAM.weightPlayer, { u32: player }),
+      field(ANIMATION_MODULE_PARAM.weightInstance, { u32: instance }),
+      field(ANIMATION_MODULE_PARAM.weightValue, { f32: weight })
+    ]
+  };
+}
+function callResultU32(result) {
+  const ret = result.ret;
+  if (ret && typeof ret === "object" && "u32" in ret) {
+    const value = Number(ret.u32);
+    return Number.isFinite(value) ? value : null;
+  }
+  return null;
+}
+var ANIMATION_PLAYERS_PATH = "vizij/animations/players";
+var ANIMATIONS_SOURCE_ID = "animations";
+function animationsGraphSource() {
+  return {
+    sourceId: ANIMATIONS_SOURCE_ID,
+    spec: {
+      nodes: [
+        { id: "dt", type: "input", params: { path: "arora/dt" } },
+        {
+          id: "step",
+          type: "externalfunction",
+          params: {
+            function: ANIMATION_MODULE_FN.step,
+            param_ids: [ANIMATION_MODULE_PARAM.dtNs]
+          }
+        },
+        {
+          id: "apply",
+          type: "output",
+          params: {
+            key_field: ANIMATION_MODULE_FIELD.outputDefaultKey,
+            value_field: ANIMATION_MODULE_FIELD.outputValue
+          }
+        },
+        {
+          id: "states",
+          type: "externalfunction",
+          params: { function: ANIMATION_MODULE_FN.playerStates, param_ids: [] }
+        },
+        {
+          id: "states-out",
+          type: "output",
+          params: { path: ANIMATION_PLAYERS_PATH }
+        }
+      ],
+      edges: [
+        { from: { node_id: "dt" }, to: { node_id: "step", input: "args_0" } },
+        { from: { node_id: "step" }, to: { node_id: "apply", input: "in" } },
+        {
+          from: { node_id: "states" },
+          to: { node_id: "states-out", input: "in" }
+        }
+      ]
+    }
+  };
+}
+function fieldNumber(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  for (const key of ["u64", "u32", "f32", "f64"]) {
+    if (key in value) {
+      const parsed = Number(value[key]);
+      return Number.isFinite(parsed) ? parsed : null;
+    }
+  }
+  return null;
+}
+function decodePlayerStates(raw) {
+  if (!raw || typeof raw !== "object" || !("structs" in raw)) {
+    return [];
+  }
+  const structs = raw.structs;
+  const elements = Array.isArray(structs?.elements) ? structs.elements : [];
+  const states = [];
+  for (const element of elements) {
+    const fields = element?.fields;
+    if (!Array.isArray(fields)) {
+      continue;
+    }
+    const byId = /* @__PURE__ */ new Map();
+    for (const entry of fields) {
+      const id = entry?.id;
+      const value = entry?.value;
+      if (typeof id === "string" && value && typeof value === "object") {
+        byId.set(id, value);
+      }
+    }
+    const player = fieldNumber(byId.get(ANIMATION_MODULE_FIELD.statePlayer));
+    if (player === null) {
+      continue;
+    }
+    const stateValue = byId.get(ANIMATION_MODULE_FIELD.stateState);
+    states.push({
+      player,
+      state: stateValue && "str" in stateValue ? String(stateValue.str) : "",
+      time: (fieldNumber(byId.get(ANIMATION_MODULE_FIELD.stateTimeNs)) ?? 0) / 1e9,
+      duration: (fieldNumber(byId.get(ANIMATION_MODULE_FIELD.stateDurationNs)) ?? 0) / 1e9,
+      speed: fieldNumber(byId.get(ANIMATION_MODULE_FIELD.stateSpeed)) ?? 1
+    });
+  }
+  return states;
+}
+
+// src/engine/animationModuleHost.ts
+var AnimationModuleHost = class {
+  constructor(getDevice, resolveKeys = (key) => [key]) {
+    this.getDevice = getDevice;
+    this.resolveKeys = resolveKeys;
+    this.clips = /* @__PURE__ */ new Map();
+  }
+  /** Whether any clip is currently marked playing (drives source lifecycle). */
+  hasPlaying() {
+    for (const entry of this.clips.values()) {
+      if (entry.playing) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /** Whether a clip id is known to the host. */
+  has(clipId) {
+    return this.clips.has(clipId);
+  }
+  /** The clip's module `PlayerId` on the live device (feedback correlation). */
+  playerIdOf(clipId) {
+    return this.clips.get(clipId)?.playerId ?? null;
+  }
+  /** The clip's transport state as last commanded. */
+  transportOf(clipId) {
+    const entry = this.clips.get(clipId);
+    if (!entry) {
+      return null;
+    }
+    return {
+      playing: entry.playing,
+      speed: entry.speed,
+      loop: entry.loop,
+      weight: entry.weight
+    };
+  }
+  /**
+   * Declare the clips the bundle carries, as data. Keeps playing/transport
+   * state for clips that survive; clips no longer present are dropped. Does
+   * not touch the device — loading is lazy (on first play), so muted/unused
+   * clips never enter the module, and conversion happens at load with the
+   * key resolver's state at that moment.
+   */
+  setClips(clips) {
+    const nextIds = new Set(clips.map((clip) => clip.id));
+    for (const id of Array.from(this.clips.keys())) {
+      if (!nextIds.has(id)) {
+        this.clips.delete(id);
+      }
+    }
+    for (const clip of clips) {
+      const existing = this.clips.get(clip.id);
+      if (existing) {
+        existing.stored = clip.stored;
+        existing.animId = null;
+        existing.playerId = null;
+        existing.instId = null;
+      } else {
+        this.clips.set(clip.id, {
+          stored: clip.stored,
+          playing: false,
+          speed: 1,
+          loop: "loop",
+          weight: 1,
+          animId: null,
+          playerId: null,
+          instId: null
+        });
+      }
+    }
+  }
+  /**
+   * Mark a clip playing, ensure it is loaded into the live device with a
+   * player + instance, and issue `play` (a resume after `pause` needs it; on
+   * a fresh player it is a no-op). Idempotent. Resolves once the calls have
+   * dispatched (or immediately when there is no live device yet — the
+   * provider registers the source, which boots the device and replays via
+   * `replayInto`).
+   */
+  async play(clipId) {
+    const entry = this.clips.get(clipId);
+    if (!entry) {
+      return;
+    }
+    entry.playing = true;
+    const device = this.getDevice();
+    if (!device) {
+      return;
+    }
+    await this.ensureLoaded(device, entry);
+    if (entry.playerId !== null) {
+      await device.call(playCall(entry.playerId));
+    }
+  }
+  /** Hold the clip's playhead (`pause` on its player). */
+  pause(clipId) {
+    const entry = this.clips.get(clipId);
+    if (!entry) {
+      return;
+    }
+    entry.playing = false;
+    this.dispatch(
+      (device) => entry.playerId !== null ? device.call(pauseCall(entry.playerId)) : null
+    );
+  }
+  /**
+   * Stop a clip: not playing, playhead reset to the window start (`stop` on
+   * its player — the next tick emits the clip's t=0 pose). The clip stays
+   * loaded for a cheap replay.
+   */
+  stop(clipId) {
+    const entry = this.clips.get(clipId);
+    if (!entry) {
+      return;
+    }
+    entry.playing = false;
+    this.dispatch(
+      (device) => entry.playerId !== null ? device.call(stopCall(entry.playerId)) : null
+    );
+  }
+  /** Move the clip's playhead to `seconds`. */
+  seek(clipId, seconds) {
+    const entry = this.clips.get(clipId);
+    if (!entry) {
+      return;
+    }
+    this.dispatch(
+      (device) => entry.playerId !== null ? device.call(seekCall(entry.playerId, seconds * 1e9)) : null
+    );
+  }
+  /** Set the clip's playback speed multiplier. */
+  setSpeed(clipId, speed) {
+    const entry = this.clips.get(clipId);
+    if (!entry) {
+      return;
+    }
+    entry.speed = speed;
+    this.dispatch(
+      (device) => entry.playerId !== null ? device.call(setSpeedCall(entry.playerId, speed)) : null
+    );
+  }
+  /** Set how the clip's player time maps into clip time. */
+  setLoop(clipId, mode) {
+    const entry = this.clips.get(clipId);
+    if (!entry) {
+      return;
+    }
+    entry.loop = mode;
+    this.dispatch(
+      (device) => entry.playerId !== null ? device.call(setLoopCall(entry.playerId, mode)) : null
+    );
+  }
+  /** Set the clip instance's blend weight. */
+  setWeight(clipId, weight) {
+    const entry = this.clips.get(clipId);
+    if (!entry) {
+      return;
+    }
+    entry.weight = weight;
+    this.dispatch(
+      (device) => entry.playerId !== null && entry.instId !== null ? device.call(setWeightCall(entry.playerId, entry.instId, weight)) : null
+    );
+  }
+  /**
+   * Re-issue setup and transport for every playing clip against a freshly
+   * started device (module guest state did not survive the rebuild). Voids
+   * stale ids first. Called from `DeviceSlot.onDeviceStarted`.
+   */
+  replayInto(device) {
+    for (const entry of this.clips.values()) {
+      entry.animId = null;
+      entry.playerId = null;
+      entry.instId = null;
+      if (entry.playing) {
+        void this.ensureLoaded(device, entry);
+      }
+    }
+  }
+  /** Fire-and-forget a transport call against the live device, if any. */
+  dispatch(issue) {
+    const device = this.getDevice();
+    if (!device) {
+      return;
+    }
+    void issue(device)?.catch(() => {
+    });
+  }
+  async ensureLoaded(device, entry) {
+    if (entry.instId !== null) {
+      return;
+    }
+    if (entry.animId === null) {
+      const anim = await device.call(
+        loadAnimationCall(
+          storedClipToModuleValue(entry.stored, this.resolveKeys)
+        )
+      );
+      entry.animId = callResultU32(anim);
+    }
+    if (entry.playerId === null) {
+      const player = await device.call(createPlayerCall(""));
+      entry.playerId = callResultU32(player);
+    }
+    if (entry.instId === null && entry.animId !== null && entry.playerId !== null) {
+      const inst = await device.call(
+        addInstanceCall(entry.playerId, entry.animId)
+      );
+      entry.instId = callResultU32(inst);
+    }
+    const followups = [];
+    if (entry.playerId !== null) {
+      if (entry.speed !== 1) {
+        followups.push(setSpeedCall(entry.playerId, entry.speed));
+      }
+      if (entry.loop !== "loop") {
+        followups.push(setLoopCall(entry.playerId, entry.loop));
+      }
+      if (entry.instId !== null && entry.weight !== 1) {
+        followups.push(
+          setWeightCall(entry.playerId, entry.instId, entry.weight)
+        );
+      }
+    }
+    for (const call of followups) {
+      await device.call(call);
+    }
+  }
+};
+
 // src/VizijRuntimeProvider.tsx
 import { jsx } from "react/jsx-runtime";
 var ACTIVE_GRACE_MS = 250;
 var VISIBLE_IDLE_FPS = 30;
 var HIDDEN_IDLE_FPS = 1;
+var IMPLICIT_PAUSE_GAP_S = 5;
+var inferImplicitPause = (dt) => {
+  if (dt <= IMPLICIT_PAUSE_GAP_S) {
+    return dt;
+  }
+  console.warn(
+    `[vizij-runtime] step loop woke after a ${dt.toFixed(
+      1
+    )}s wall-clock gap; treating it as a suspension (dt = 0)`
+  );
+  return 0;
+};
 var DEFAULT_MERGE = {
   outputs: "add",
   intermediate: "add"
 };
 var DEFAULT_DURATION = 0.35;
 var POSE_CONTROL_BRIDGE_EPSILON = 1e-6;
+var runtimeDebugInstanceSequence = 0;
 var DEV_MODE = (() => {
   const nodeEnv = globalThis.process?.env?.NODE_ENV;
   return typeof nodeEnv === "string" && nodeEnv === "development";
@@ -1490,12 +2231,15 @@ function pickExtractedAnimations(asset) {
   }
   return animations;
 }
-function mergeAnimationLists(explicit, fromBundle) {
-  if (!explicit?.length && fromBundle.length === 0) {
+function mergeAnimationLists(explicit, hasExplicitOverride, fromBundle) {
+  if (!hasExplicitOverride) {
+    return fromBundle.length > 0 ? fromBundle : void 0;
+  }
+  if (!Array.isArray(explicit)) {
     return void 0;
   }
-  if (!explicit?.length) {
-    return fromBundle.length > 0 ? fromBundle : void 0;
+  if (explicit.length === 0) {
+    return [];
   }
   if (fromBundle.length === 0) {
     return explicit;
@@ -1546,13 +2290,68 @@ function convertBundlePrograms(entries) {
     };
   }).filter(Boolean);
 }
-function mergeProgramLists(explicit, fromBundle) {
-  if (!explicit?.length && fromBundle.length === 0) {
+function resolveConstraintDefault(path, namespace, inputConstraints) {
+  const trimmed = path.trim();
+  if (!trimmed) {
     return void 0;
   }
-  if (!explicit?.length) {
+  const stripped = stripRigFacePrefix(trimmed);
+  const relativePath = stripped ? `/${stripped}` : "";
+  const candidates = [
+    namespaceTypedPath(trimmed, namespace),
+    trimmed,
+    stripped ? namespaceTypedPath(stripped, namespace) : void 0,
+    stripped || void 0,
+    relativePath || void 0
+  ];
+  for (const candidate of candidates) {
+    if (!candidate) {
+      continue;
+    }
+    const defaultValue = inputConstraints[candidate]?.defaultValue;
+    if (Number.isFinite(defaultValue)) {
+      return Number(defaultValue);
+    }
+  }
+  return void 0;
+}
+function deriveProgramInputSeedValues(args) {
+  const graphSpec = resolveGraphSpec(
+    args.program.graph,
+    `${args.program.id ?? "program"} graph (seed defaults)`
+  );
+  if (!graphSpec) {
+    return [];
+  }
+  return collectInputPaths(graphSpec).map((path) => path.trim()).filter((path) => path.length > 0).flatMap((path) => {
+    const namespacedPath = namespaceTypedPath(path, args.namespace);
+    if (args.stagedInputs.has(namespacedPath)) {
+      return [];
+    }
+    if (args.getPathSnapshot(namespacedPath) !== void 0) {
+      return [];
+    }
+    const defaultValue = resolveConstraintDefault(
+      path,
+      args.namespace,
+      args.inputConstraints
+    );
+    if (!Number.isFinite(defaultValue)) {
+      return [];
+    }
+    return [{ path, value: { float: Number(defaultValue) } }];
+  });
+}
+function mergeProgramLists(explicit, hasExplicitOverride, fromBundle) {
+  if (!hasExplicitOverride) {
     return fromBundle.length > 0 ? fromBundle : void 0;
   }
+  if (!Array.isArray(explicit)) {
+    return void 0;
+  }
+  if (explicit.length === 0) {
+    return [];
+  }
   if (fromBundle.length === 0) {
     return explicit;
   }
@@ -1571,10 +2370,23 @@ function mergeProgramLists(explicit, fromBundle) {
 }
 function mergeAssetBundle(base, extracted, extractedAnimations) {
   const resolvedBundle = base.bundle ?? extracted ?? null;
+  const hasBaseRigOverride = Object.prototype.hasOwnProperty.call(base, "rig");
+  const hasBasePoseOverride = Object.prototype.hasOwnProperty.call(
+    base,
+    "pose"
+  );
+  const hasBaseAnimationsOverride = Object.prototype.hasOwnProperty.call(
+    base,
+    "animations"
+  );
+  const hasBaseProgramsOverride = Object.prototype.hasOwnProperty.call(
+    base,
+    "programs"
+  );
   const rigFromBundle = convertBundleGraph(
     pickBundleGraph(resolvedBundle, ["rig"])
   );
-  const resolvedRig = base.rig ?? rigFromBundle ?? void 0;
+  const resolvedRig = hasBaseRigOverride ? base.rig : base.rig ?? rigFromBundle ?? void 0;
   const basePose = base.pose;
   const hasBasePoseGraphOverride = Boolean(
     basePose && Object.prototype.hasOwnProperty.call(basePose, "graph")
@@ -1583,13 +2395,15 @@ function mergeAssetBundle(base, extracted, extractedAnimations) {
     basePose && Object.prototype.hasOwnProperty.call(basePose, "config")
   );
   const poseStageFilter = basePose?.stageNeutralFilter;
-  const poseGraphFromBundle = hasBasePoseGraphOverride ? null : convertBundleGraph(
+  const poseGraphFromBundle = hasBasePoseOverride && !basePose ? null : hasBasePoseGraphOverride ? null : convertBundleGraph(
     pickBundleGraph(resolvedBundle, ["pose-driver", "pose"])
   );
   const resolvedPoseGraph = hasBasePoseGraphOverride ? basePose?.graph : basePose?.graph ?? poseGraphFromBundle ?? void 0;
   const resolvedPoseConfig = hasBasePoseConfigOverride ? basePose?.config : basePose?.config ?? resolvedBundle?.poses?.config ?? void 0;
   let resolvedPose = basePose;
-  if (basePose) {
+  if (hasBasePoseOverride && !basePose) {
+    resolvedPose = void 0;
+  } else if (basePose) {
     const nextPose = { ...basePose };
     let changed = false;
     if (resolvedPoseGraph && basePose.graph !== resolvedPoseGraph) {
@@ -1617,17 +2431,20 @@ function mergeAssetBundle(base, extracted, extractedAnimations) {
   );
   let resolvedAnimations = mergeAnimationLists(
     base.animations,
+    hasBaseAnimationsOverride,
     animationsFromBundle
   );
   const animationsFromAsset = extractedAnimations && extractedAnimations.length > 0 ? extractedAnimations : [];
   if (animationsFromAsset.length > 0) {
     resolvedAnimations = mergeAnimationLists(
       resolvedAnimations,
+      true,
       animationsFromAsset
     );
   }
   const programsFromBundle = mergeProgramLists(
     base.programs,
+    hasBaseProgramsOverride,
     convertBundlePrograms(resolvedBundle?.graphs)
   );
   const merged = {
@@ -1741,28 +2558,18 @@ function VizijRuntimeProvider({
   faceId: faceIdProp,
   updateTier = "auto",
   autoCreate = true,
-  createOptions,
   autostart = false,
-  driveOrchestrator = true,
+  driveRuntime = true,
   mergeStrategy,
   onRegisterControllers,
   onStatusChange,
-  transformOutputWrite,
-  orchestratorScope = "auto"
+  transformOutputWrite
 }) {
   const storeRef = useRef(null);
   if (!storeRef.current) {
     storeRef.current = createVizijStore();
   }
-  const parentOrchestrator = useContext(OrchestratorContext);
-  const hasParentOrchestrator = Boolean(parentOrchestrator);
-  const shouldProvideOrchestrator = orchestratorScope === "isolated" || !hasParentOrchestrator && orchestratorScope !== "shared";
-  if (orchestratorScope === "shared" && !hasParentOrchestrator) {
-    console.warn(
-      '[vizij-runtime] orchestratorScope="shared" requires an OrchestratorProvider higher in the tree; falling back to an isolated provider.'
-    );
-  }
-  const runtimeTree = /* @__PURE__ */ jsx(VizijContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ jsx(
+  return /* @__PURE__ */ jsx(VizijContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ jsx(
     VizijRuntimeProviderInner,
     {
       assetBundle,
@@ -1771,8 +2578,7 @@ function VizijRuntimeProvider({
       updateTier,
       autoCreate,
       autostart,
-      driveOrchestrator,
-      createOptions,
+      driveRuntime,
       mergeStrategy,
       onRegisterControllers,
       onStatusChange,
@@ -1781,18 +2587,6 @@ function VizijRuntimeProvider({
       children
     }
   ) });
-  if (!shouldProvideOrchestrator) {
-    return runtimeTree;
-  }
-  return /* @__PURE__ */ jsx(
-    OrchestratorProvider,
-    {
-      autoCreate,
-      createOptions,
-      autostart: false,
-      children: runtimeTree
-    }
-  );
 }
 function VizijRuntimeProviderInner({
   assetBundle: initialAssetBundle,
@@ -1807,8 +2601,7 @@ function VizijRuntimeProviderInner({
   children,
   autoCreate,
   autostart,
-  createOptions,
-  driveOrchestrator
+  driveRuntime
 }) {
   const [assetBundleOverride, setAssetBundleOverride] = useState(null);
   const [graphUpdateToken, setGraphUpdateToken] = useState(0);
@@ -1870,23 +2663,17 @@ function VizijRuntimeProviderInner({
       setGraphUpdateToken((prev) => prev + 1);
     }
   }, [effectiveAssetBundle]);
-  const {
-    ready,
-    createOrchestrator,
-    registerGraph,
-    registerMergedGraph,
-    registerAnimation,
-    removeGraph,
-    removeAnimation,
-    removeInput,
-    listControllers,
-    setInput: orchestratorSetInput,
-    getPathSnapshot,
-    step: stepRuntime
-  } = useOrchestrator();
-  const frame = useOrchFrame();
+  const deviceSlotRef = useRef(null);
+  if (!deviceSlotRef.current) {
+    deviceSlotRef.current = new DeviceSlot();
+  }
+  const deviceSlot = deviceSlotRef.current;
+  const [ready, setReady] = useState(false);
+  const graphSourcesRef = useRef([]);
   const namespace = namespaceProp ?? assetBundle.namespace ?? "default";
   const faceId = faceIdProp ?? assetBundle.faceId ?? assetBundle.pose?.config?.faceId ?? assetBundle.pose?.config?.faceId ?? void 0;
+  const faceIdRef = useRef(faceId);
+  faceIdRef.current = faceId;
   const [status, setStatus] = useState({
     loading: true,
     ready: false,
@@ -1899,12 +2686,15 @@ function VizijRuntimeProviderInner({
     stepHz: void 0,
     controllers: { graphs: [], anims: [] }
   });
+  const runtimeDebugInstanceIdRef = useRef(
+    `vizij-runtime:${runtimeDebugInstanceSequence++}`
+  );
   const errorsRef = useRef([]);
   const outputPathsRef = useRef(/* @__PURE__ */ new Set());
   const baseOutputPathsRef = useRef(/* @__PURE__ */ new Set());
   const namespacedOutputPathsRef = useRef(/* @__PURE__ */ new Set());
   const namespaceRef = useRef(namespace);
-  const driveOrchestratorRef = useRef(driveOrchestrator);
+  const driveRuntimeRef = useRef(driveRuntime);
   const rigInputMapRef = useRef({});
   const rigPoseControlInputIdsRef = useRef(/* @__PURE__ */ new Set());
   const registeredGraphsRef = useRef([]);
@@ -1946,16 +2736,17 @@ function VizijRuntimeProviderInner({
   const [inputConstraints, setInputConstraints] = useState({});
   const inputConstraintsRef = useRef({});
   const avgStepDtRef = useRef(null);
+  const inputDriverIdsRef = useRef(/* @__PURE__ */ new Set());
   const animationTweensRef = useRef(/* @__PURE__ */ new Map());
   const clipPlaybackRef = useRef(/* @__PURE__ */ new Map());
   const programPlaybackRef = useRef(
     /* @__PURE__ */ new Map()
   );
   const programControllerIdsRef = useRef(/* @__PURE__ */ new Map());
-  const clipOutputValuesRef = useRef(
-    /* @__PURE__ */ new Map()
-  );
-  const clipAggregateValuesRef = useRef(/* @__PURE__ */ new Map());
+  const animationModuleRef = useRef(null);
+  const animationHostRef = useRef(null);
+  const animationsSourceRegisteredRef = useRef(false);
+  const animationGapWarnedRef = useRef(/* @__PURE__ */ new Set());
   const animationSystemActiveRef = useRef(true);
   const stagedInputsRef = useRef(/* @__PURE__ */ new Map());
   const autostartRef = useRef(autostart);
@@ -1971,6 +2762,58 @@ function VizijRuntimeProviderInner({
       runtimeMountedRef.current = false;
     };
   }, []);
+  const publishRuntimeDebugState = useCallback(() => {
+    const storeState = store.getState();
+    setRuntimeDebugState(runtimeDebugInstanceIdRef.current, {
+      namespace,
+      faceId: faceId ?? null,
+      rootId: status.rootId,
+      ready: status.ready,
+      loading: status.loading,
+      autostart,
+      driveRuntime,
+      loopMode,
+      outputCount: status.outputPaths.length,
+      graphControllerCount: status.controllers.graphs.length,
+      animationControllerCount: status.controllers.anims.length,
+      registeredGraphCount: registeredGraphsRef.current.length,
+      registeredAnimationCount: registeredAnimationsRef.current.length,
+      programControllerCount: programControllerIdsRef.current.size,
+      animationTweenCount: animationTweensRef.current.size,
+      clipPlaybackCount: clipPlaybackRef.current.size,
+      programPlaybackCount: programPlaybackRef.current.size,
+      stagedInputCount: stagedInputsRef.current.size,
+      activeDriverCount: inputDriverIdsRef.current.size,
+      worldEntryCount: Object.keys(storeState.world ?? {}).length,
+      animatableCount: Object.keys(storeState.animatables ?? {}).length,
+      valuesSize: storeState.values instanceof Map ? storeState.values.size : null,
+      stepHz: status.stepHz ?? null
+    });
+  }, [
+    autostart,
+    driveRuntime,
+    faceId,
+    loopMode,
+    namespace,
+    status.controllers.anims.length,
+    status.controllers.graphs.length,
+    status.loading,
+    status.outputPaths.length,
+    status.ready,
+    status.rootId,
+    status.stepHz,
+    store
+  ]);
+  useEffect(() => {
+    publishRuntimeDebugState();
+    const unsubscribe = store.subscribe(() => {
+      publishRuntimeDebugState();
+    });
+    return () => {
+      unsubscribe();
+      clearRuntimeDebugState(runtimeDebugInstanceIdRef.current);
+    };
+  }, [publishRuntimeDebugState, store]);
   useEffect(() => {
     const rigAsset = assetBundle.rig;
     if (!rigAsset) {
@@ -2066,59 +2909,289 @@ function VizijRuntimeProviderInner({
         });
         return;
       }
-      markActivity();
-      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
-      if (isRuntimeDebugEnabled() && (namespacedPath.includes("animation/authoring.timeline.main") || namespacedPath.endsWith("/blink"))) {
-        console.log("[vizij-runtime] stage input", {
-          path,
-          namespacedPath,
-          value
-        });
+      markActivity();
+      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
+      if (isRuntimeDebugEnabled() && (namespacedPath.includes("animation/authoring.timeline.main") || namespacedPath.endsWith("/blink"))) {
+        console.log("[vizij-runtime] stage input", {
+          path,
+          namespacedPath,
+          value
+        });
+      }
+      stagedInputsRef.current.set(namespacedPath, { value, shape });
+    },
+    [
+      assetBundle.pose?.config?.faceId,
+      faceId,
+      markActivity,
+      poseWeightFallbackMap,
+      useLegacyPoseWeightFallback
+    ]
+  );
+  const reportStatus = useCallback(
+    (updater) => {
+      setStatus((prev) => {
+        const next = updater(prev);
+        onStatusChange?.(next);
+        return next;
+      });
+    },
+    [onStatusChange]
+  );
+  const pushError = useCallback(
+    (error) => {
+      errorsRef.current = [...errorsRef.current, error];
+      reportStatus((prev) => ({
+        ...prev,
+        error,
+        errors: errorsRef.current
+      }));
+      console.warn("[vizij-runtime]", error.message, error.cause);
+    },
+    [reportStatus]
+  );
+  const resetErrors = useCallback(() => {
+    errorsRef.current = [];
+    reportStatus((prev) => ({
+      ...prev,
+      error: null,
+      errors: []
+    }));
+  }, [reportStatus]);
+  useEffect(() => {
+    autostartRef.current = autostart;
+    updateLoopMode();
+  }, [autostart, updateLoopMode]);
+  const pendingWritesRef = useRef(/* @__PURE__ */ new Map());
+  const getDevice = useCallback(
+    () => deviceSlot.current?.device ?? null,
+    [deviceSlot]
+  );
+  const ensureAnimationHost = useCallback(() => {
+    if (!animationModuleRef.current) {
+      return null;
+    }
+    if (!animationHostRef.current) {
+      animationHostRef.current = new AnimationModuleHost(
+        getDevice,
+        (key) => resolveAnimationBridgeOutputPaths(
+          key,
+          faceIdRef.current ?? void 0,
+          rigInputMapRef.current
+        )
+      );
+    }
+    return animationHostRef.current;
+  }, [getDevice]);
+  const applyEngineChangesRef = useRef(() => {
+  });
+  const recomposeDevice = useCallback(() => {
+    const spec = composeGraphSpecs(graphSourcesRef.current);
+    deviceSlot.recompose(spec).then((handle) => {
+      if (pendingWritesRef.current.size > 0) {
+        handle.device.writeValues(
+          Object.fromEntries(pendingWritesRef.current)
+        );
+        pendingWritesRef.current.clear();
+      }
+    }).catch((err) => {
+      pushError({
+        message: "Failed to (re)compose the arora device",
+        cause: err,
+        phase: "engine",
+        timestamp: performance.now()
+      });
+    });
+  }, [deviceSlot, pushError]);
+  const initEngine = useCallback(async () => {
+    await ensureWasmInit();
+    setReady(true);
+  }, []);
+  const hasBundleAnimations = (assetBundle.animations?.length ?? 0) > 0;
+  useEffect(() => {
+    if (!hasBundleAnimations || animationModuleRef.current) {
+      return;
+    }
+    let cancelled = false;
+    const loading = loadAnimationModule().then((module) => {
+      if (cancelled) {
+        return;
+      }
+      animationModuleRef.current = module;
+      deviceSlot.setModules([module]);
+      deviceSlot.onDeviceStarted = (handle) => {
+        animationHostRef.current?.replayInto(handle.device);
+      };
+      ensureAnimationHost();
+    }).catch((err) => {
+      pushError({
+        message: "Failed to load the animation module",
+        cause: err,
+        phase: "engine",
+        timestamp: performance.now()
+      });
+    });
+    deviceSlot.waitForModules(loading);
+    return () => {
+      cancelled = true;
+    };
+  }, [deviceSlot, ensureAnimationHost, hasBundleAnimations, pushError]);
+  const removeGraph = useCallback(
+    (id) => {
+      graphSourcesRef.current = graphSourcesRef.current.filter(
+        (s) => s.sourceId !== id && !s.sourceId.startsWith(`${id}#`)
+      );
+      recomposeDevice();
+    },
+    [recomposeDevice]
+  );
+  const registerGraph = useCallback(
+    (cfg) => {
+      const id = cfg.id ?? `graph-${graphSourcesRef.current.length}`;
+      graphSourcesRef.current = [
+        ...graphSourcesRef.current.filter((s) => s.sourceId !== id),
+        { sourceId: id, spec: cfg.spec ?? {} }
+      ];
+      recomposeDevice();
+      return id;
+    },
+    [recomposeDevice]
+  );
+  const registerMergedGraph = useCallback(
+    (cfg) => {
+      const id = cfg.id ?? `merged-${graphSourcesRef.current.length}`;
+      const members = cfg.graphs.map((graph, index) => ({
+        sourceId: `${id}#${graph.id ?? index}`,
+        spec: graph.spec ?? {}
+      }));
+      graphSourcesRef.current = [
+        ...graphSourcesRef.current.filter(
+          (s) => s.sourceId !== id && !s.sourceId.startsWith(`${id}#`)
+        ),
+        ...members
+      ];
+      recomposeDevice();
+      return id;
+    },
+    [recomposeDevice]
+  );
+  const registerAnimation = useCallback(
+    (cfg) => cfg.id ?? `animation-${registeredAnimationsRef.current.length}`,
+    []
+  );
+  const removeAnimation = useCallback((_id) => {
+  }, []);
+  const setAnimationsSourceRegistered = useCallback(
+    (registered) => {
+      if (registered === animationsSourceRegisteredRef.current) {
+        return;
+      }
+      animationsSourceRegisteredRef.current = registered;
+      if (registered) {
+        graphSourcesRef.current = [
+          ...graphSourcesRef.current.filter(
+            (s) => s.sourceId !== animationsGraphSource().sourceId
+          ),
+          animationsGraphSource()
+        ];
+      } else {
+        graphSourcesRef.current = graphSourcesRef.current.filter(
+          (s) => s.sourceId !== animationsGraphSource().sourceId
+        );
+      }
+      recomposeDevice();
+    },
+    [recomposeDevice]
+  );
+  const listControllers = useCallback(
+    () => ({
+      graphs: [...registeredGraphsRef.current],
+      anims: [...registeredAnimationsRef.current]
+    }),
+    []
+  );
+  const deviceSetInput = useCallback(
+    (path, value, _shape) => {
+      const handle = deviceSlot.current;
+      if (handle) {
+        handle.device.setValue(path, value);
+      } else {
+        pendingWritesRef.current.set(path, value);
       }
-      stagedInputsRef.current.set(namespacedPath, { value, shape });
     },
-    [
-      assetBundle.pose?.config?.faceId,
-      faceId,
-      markActivity,
-      poseWeightFallbackMap,
-      useLegacyPoseWeightFallback
-    ]
+    [deviceSlot]
   );
-  const reportStatus = useCallback(
-    (updater) => {
-      setStatus((prev) => {
-        const next = updater(prev);
-        onStatusChange?.(next);
-        return next;
+  const getPathSnapshot = useCallback(
+    (path) => {
+      const handle = deviceSlot.current;
+      if (!handle) {
+        return pendingWritesRef.current.get(path);
+      }
+      return handle.device.readValues([path])[path] ?? void 0;
+    },
+    [deviceSlot]
+  );
+  const getStoreSnapshot = useCallback(() => {
+    const handle = deviceSlot.current;
+    if (!handle) {
+      return void 0;
+    }
+    return handle.device.snapshot();
+  }, [deviceSlot]);
+  const stepListenersRef = useRef(/* @__PURE__ */ new Set());
+  const subscribeToStep = useCallback((listener) => {
+    const listeners = stepListenersRef.current;
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }, []);
+  const stepRuntime = useCallback(
+    (dt) => {
+      const handle = deviceSlot.current;
+      if (!handle) {
+        return;
+      }
+      if (!handle.device.running) {
+        handle.device.step(dt * 1e3);
+      }
+      const changes = handle.device.drainChanges();
+      applyEngineChangesRef.current(changes);
+      if (storeChangeListenersRef.current.size > 0) {
+        const paths = Object.keys(changes);
+        if (paths.length > 0) {
+          storeChangeListenersRef.current.forEach((listener) => {
+            try {
+              listener(changes);
+            } catch (err) {
+              console.error("[vizij-runtime] store-change listener error", err);
+            }
+          });
+        }
+      }
+      stepListenersRef.current.forEach((listener) => {
+        try {
+          listener();
+        } catch (err) {
+          console.error("[vizij-runtime] step listener error", err);
+        }
       });
     },
-    [onStatusChange]
+    [deviceSlot]
   );
-  const pushError = useCallback(
-    (error) => {
-      errorsRef.current = [...errorsRef.current, error];
-      reportStatus((prev) => ({
-        ...prev,
-        error,
-        errors: errorsRef.current
-      }));
-      console.warn("[vizij-runtime]", error.message, error.cause);
+  const storeChangeListenersRef = useRef(
+    /* @__PURE__ */ new Set()
+  );
+  const subscribeToStoreChanges = useCallback(
+    (listener) => {
+      const listeners = storeChangeListenersRef.current;
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
     },
-    [reportStatus]
+    []
   );
-  const resetErrors = useCallback(() => {
-    errorsRef.current = [];
-    reportStatus((prev) => ({
-      ...prev,
-      error: null,
-      errors: []
-    }));
-  }, [reportStatus]);
-  useEffect(() => {
-    autostartRef.current = autostart;
-    updateLoopMode();
-  }, [autostart, updateLoopMode]);
   const clearControllers = useCallback(() => {
     const existing = listControllers();
     existing.graphs.forEach((id) => {
@@ -2153,8 +3226,6 @@ function VizijRuntimeProviderInner({
     baseOutputPathsRef.current = /* @__PURE__ */ new Set();
     namespacedOutputPathsRef.current = /* @__PURE__ */ new Set();
     rigPoseControlInputIdsRef.current = /* @__PURE__ */ new Set();
-    clipOutputValuesRef.current.clear();
-    clipAggregateValuesRef.current.clear();
   }, [listControllers, removeAnimation, removeGraph, pushError]);
   useEffect(() => {
     namespaceRef.current = namespace;
@@ -2165,8 +3236,24 @@ function VizijRuntimeProviderInner({
     }));
   }, [namespace, faceId, reportStatus]);
   useEffect(() => {
-    driveOrchestratorRef.current = driveOrchestrator;
-  }, [driveOrchestrator]);
+    driveRuntimeRef.current = driveRuntime;
+  }, [driveRuntime]);
+  useEffect(() => {
+    deviceSlot.onRunEnded = (error) => {
+      pushError({
+        message: "The device's run loop ended: stepping failed",
+        cause: error,
+        phase: "engine",
+        timestamp: performance.now()
+      });
+    };
+    if (driveRuntime) {
+      deviceSlot.runPeriodMs = RUN_PERIOD_MS;
+      deviceSlot.startRun();
+    } else {
+      deviceSlot.runPeriodMs = null;
+    }
+  }, [deviceSlot, driveRuntime, pushError]);
   const glbAsset = effectiveAssetBundle.glb;
   const baseBundle = effectiveAssetBundle.bundle ?? null;
   useEffect(() => {
@@ -2279,16 +3366,16 @@ function VizijRuntimeProviderInner({
   ]);
   useEffect(() => {
     if (!ready && autoCreate) {
-      createOrchestrator(createOptions).catch((err) => {
+      initEngine().catch((err) => {
         pushError({
-          message: "Failed to create orchestrator runtime",
+          message: "Failed to initialize the engine",
           cause: err,
-          phase: "orchestrator",
+          phase: "engine",
           timestamp: performance.now()
         });
       });
     }
-  }, [ready, autoCreate, createOptions, createOrchestrator, pushError]);
+  }, [ready, autoCreate, initEngine, pushError]);
   const registerControllers = useCallback(async () => {
     clearControllers();
     if (isRuntimeDebugEnabled()) {
@@ -2451,19 +3538,13 @@ function VizijRuntimeProviderInner({
       console.log("[vizij-runtime] registered graph ids", graphIds);
     }
     const animationIds = [];
+    const hostClips = [];
     for (const anim of assetBundle.animations ?? []) {
       try {
-        const controllerId = namespaceControllerId(anim.id, namespace, "animation") ?? anim.id;
-        const animationPayload = anim.setup?.animation ?? toStoredAnimationClip(anim.id, anim.clip);
-        const config = {
-          id: controllerId,
-          setup: {
-            ...anim.setup ?? {},
-            animation: animationPayload
-          }
-        };
-        const id = registerAnimation(config);
-        animationIds.push(id);
+        const stored = anim.setup?.animation ?? toStoredAnimationClip(anim.id, anim.clip);
+        hostClips.push({ id: anim.id, stored });
+        registerAnimation({ id: anim.id });
+        animationIds.push(anim.id);
       } catch (err) {
         if (isRuntimeDebugEnabled()) {
           console.warn("[vizij-runtime] failed animation registration", {
@@ -2479,6 +3560,7 @@ function VizijRuntimeProviderInner({
         });
       }
     }
+    ensureAnimationHost()?.setClips(hostClips);
     registeredAnimationsRef.current = animationIds;
     if (assetBundle.initialInputs) {
       Object.entries(assetBundle.initialInputs).forEach(([path, value]) => {
@@ -2512,6 +3594,7 @@ function VizijRuntimeProviderInner({
   }, [
     assetBundle,
     clearControllers,
+    ensureAnimationHost,
     listControllers,
     mergeStrategy,
     namespace,
@@ -2543,75 +3626,77 @@ function VizijRuntimeProviderInner({
     });
   }, [ready, status.loading, graphUpdateToken, registerControllers, pushError]);
   useEffect(() => {
-    if (!frame) {
-      return;
-    }
-    const writes = frame.merged_writes ?? [];
-    if (!writes.length) {
-      return;
-    }
-    const setWorldValues = store.getState().setValues;
-    const namespaceValue = status.namespace;
-    const currentValues = store.getState().values;
-    const rigInputPathMap = rigInputMapRef.current;
-    const rigPoseControlInputIds = rigPoseControlInputIdsRef.current;
-    const batched = [];
-    const namespacedOutputs = namespacedOutputPathsRef.current;
-    const baseOutputs = baseOutputPathsRef.current;
-    writes.forEach((write) => {
-      const path = normalisePath(write.path);
-      const basePath = stripNamespace(path, namespaceValue);
-      const isTrackedOutput = namespacedOutputs.has(path) || baseOutputs.has(basePath);
-      if (!isTrackedOutput) {
-        return;
-      }
-      const raw = valueJSONToRaw(write.value);
-      if (raw === void 0) {
+    applyEngineChangesRef.current = (changes) => {
+      const entries = Object.entries(changes);
+      if (!entries.length) {
         return;
       }
-      const poseControlMatch = /^rig\/[^/]+\/pose\/control\/(.+)$/.exec(
-        basePath
-      );
-      if (poseControlMatch && typeof raw === "number" && Number.isFinite(raw)) {
-        const inputId = (poseControlMatch[1] ?? "").trim();
-        const hasNativePoseControlInput = inputId.length > 0 && rigPoseControlInputIds.has(inputId);
-        const mappedInputPath = inputId.length === 0 ? void 0 : resolvePoseControlInputPath({
-          inputId,
-          basePath,
-          rigInputPathMap,
-          hasNativePoseControlInput
-        });
-        if (mappedInputPath) {
-          const bridgeKey = `${namespaceValue}:${mappedInputPath}`;
-          const previousValue = poseControlBridgeValuesRef.current.get(bridgeKey);
-          if (previousValue === void 0 || Math.abs(previousValue - raw) > POSE_CONTROL_BRIDGE_EPSILON) {
-            poseControlBridgeValuesRef.current.set(bridgeKey, raw);
-            setInput(mappedInputPath, { float: raw });
+      const setWorldValues = store.getState().setValues;
+      const namespaceValue = status.namespace;
+      const currentValues = store.getState().values;
+      const rigInputPathMap = rigInputMapRef.current;
+      const rigPoseControlInputIds = rigPoseControlInputIdsRef.current;
+      const batched = [];
+      const namespacedOutputs = namespacedOutputPathsRef.current;
+      const baseOutputs = baseOutputPathsRef.current;
+      entries.forEach(([changedPath, changedValue]) => {
+        if (changedValue === null || isBuiltInPath(changedPath)) {
+          return;
+        }
+        const path = normalisePath(changedPath);
+        const basePath = stripNamespace(path, namespaceValue);
+        const isTrackedOutput = namespacedOutputs.has(path) || baseOutputs.has(basePath);
+        if (!isTrackedOutput) {
+          return;
+        }
+        const raw = valueJSONToRaw(changedValue);
+        if (raw === void 0) {
+          return;
+        }
+        const poseControlMatch = /^rig\/[^/]+\/pose\/control\/(.+)$/.exec(
+          basePath
+        );
+        if (poseControlMatch && typeof raw === "number" && Number.isFinite(raw)) {
+          const inputId = (poseControlMatch[1] ?? "").trim();
+          const hasNativePoseControlInput = inputId.length > 0 && rigPoseControlInputIds.has(inputId);
+          const mappedInputPath = inputId.length === 0 ? void 0 : resolvePoseControlInputPath({
+            inputId,
+            basePath,
+            rigInputPathMap,
+            hasNativePoseControlInput
+          });
+          if (mappedInputPath) {
+            const bridgeKey = `${namespaceValue}:${mappedInputPath}`;
+            const previousValue = poseControlBridgeValuesRef.current.get(bridgeKey);
+            if (previousValue === void 0 || Math.abs(previousValue - raw) > POSE_CONTROL_BRIDGE_EPSILON) {
+              poseControlBridgeValuesRef.current.set(bridgeKey, raw);
+              setInput(mappedInputPath, { float: raw });
+            }
           }
         }
+        const targetPath = baseOutputs.has(basePath) ? basePath : path;
+        const currentValue = currentValues.get(
+          getLookup(namespaceValue, targetPath)
+        );
+        const nextWrite = transformOutputWrite ? transformOutputWrite({
+          id: targetPath,
+          namespace: namespaceValue,
+          value: raw,
+          currentValue
+        }) : {
+          id: targetPath,
+          namespace: namespaceValue,
+          value: raw
+        };
+        if (nextWrite) {
+          batched.push(nextWrite);
+        }
+      });
+      if (batched.length > 0) {
+        setWorldValues(batched);
       }
-      const targetPath = baseOutputs.has(basePath) ? basePath : path;
-      const currentValue = currentValues.get(
-        getLookup(namespaceValue, targetPath)
-      );
-      const nextWrite = transformOutputWrite ? transformOutputWrite({
-        id: targetPath,
-        namespace: namespaceValue,
-        value: raw,
-        currentValue
-      }) : {
-        id: targetPath,
-        namespace: namespaceValue,
-        value: raw
-      };
-      if (nextWrite) {
-        batched.push(nextWrite);
-      }
-    });
-    if (batched.length > 0) {
-      setWorldValues(batched);
-    }
-  }, [frame, status.namespace, store, transformOutputWrite]);
+    };
+  }, [status.namespace, store, transformOutputWrite]);
   const stagePoseNeutral = useCallback(
     (force = false) => {
       const neutral = assetBundle.pose?.config?.neutralInputs ?? {};
@@ -2700,180 +3785,34 @@ function VizijRuntimeProviderInner({
     state.completion = completion;
     return completion;
   }, []);
-  const setAnimationInput = useCallback(
-    (path, value, options) => {
-      setInput(path, { float: value });
-      if (!options?.immediate) {
-        return;
-      }
-      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
-      const staged = stagedInputsRef.current.get(namespacedPath);
-      if (staged) {
-        orchestratorSetInput(namespacedPath, staged.value, staged.shape);
-        stagedInputsRef.current.delete(namespacedPath);
-        return;
-      }
-      orchestratorSetInput(namespacedPath, { float: value });
-    },
-    [orchestratorSetInput, setInput]
-  );
-  const clearAnimationInput = useCallback(
-    (path) => {
-      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
-      stagedInputsRef.current.delete(namespacedPath);
-      removeInput(namespacedPath);
-    },
-    [removeInput]
-  );
-  const buildClipOutputValues = useCallback(
-    (clip, state) => sampleAnimationClipOutputValues(
-      clip.clip,
-      state.time,
-      state.weight,
-      faceId ?? void 0,
-      rigInputMapRef.current
-    ),
-    [faceId]
-  );
-  const computeClipAggregateValues = useCallback(() => {
-    const aggregate = /* @__PURE__ */ new Map();
-    clipOutputValuesRef.current.forEach((outputValues) => {
-      outputValues.forEach((value, path) => {
-        aggregate.set(path, (aggregate.get(path) ?? 0) + value);
-      });
-    });
-    return aggregate;
-  }, []);
-  const stageClipAggregateValues = useCallback(
-    (nextAggregate, options) => {
-      diffAnimationAggregateValues(
-        clipAggregateValuesRef.current,
-        nextAggregate,
-        POSE_CONTROL_BRIDGE_EPSILON
-      ).forEach((operation) => {
-        if (operation.kind === "clear") {
-          clearAnimationInput(operation.path);
-          return;
-        }
-        setAnimationInput(operation.path, operation.value, options);
-      });
-      clipAggregateValuesRef.current = nextAggregate;
-    },
-    [clearAnimationInput, setAnimationInput]
-  );
-  const syncClipOutputs = useCallback(
-    (options) => {
-      stageClipAggregateValues(computeClipAggregateValues(), options);
-    },
-    [computeClipAggregateValues, stageClipAggregateValues]
-  );
-  const writeClipOutputs = useCallback(
-    (clip, state, options) => {
-      if (!animationSystemActiveRef.current) {
-        return;
-      }
-      clipOutputValuesRef.current.set(
-        clip.id,
-        buildClipOutputValues(clip, state)
-      );
-      syncClipOutputs(options);
-    },
-    [buildClipOutputValues, syncClipOutputs]
-  );
-  const clearClipOutputs = useCallback(
-    (clipId, options) => {
-      if (!clipOutputValuesRef.current.has(clipId)) {
-        return;
+  const ensureClipState = useCallback(
+    (id) => {
+      const clip = resolveClipById(id);
+      if (!clip) {
+        return null;
       }
-      clipOutputValuesRef.current.delete(clipId);
-      syncClipOutputs(options);
-    },
-    [syncClipOutputs]
-  );
-  const createClipPlaybackState = useCallback(
-    (clip) => {
       const duration = resolveClipDurationSeconds(
         clip.clip
       );
-      return {
-        id: clip.id,
-        time: 0,
+      const existing = clipPlaybackRef.current.get(id);
+      if (existing) {
+        existing.duration = duration;
+        return { clip, state: existing };
+      }
+      const state = {
+        id,
         duration,
         speed: 1,
-        weight: Number.isFinite(clip.weight) ? Number(clip.weight) : 1,
-        loop: false,
+        weight: 1,
+        loop: true,
         playing: false,
         resolve: null,
         completion: null
       };
+      clipPlaybackRef.current.set(id, state);
+      return { clip, state };
     },
-    []
-  );
-  const ensureClipPlaybackState = useCallback(
-    (id) => {
-      const clip = resolveClipById(id);
-      if (!clip) {
-        return null;
-      }
-      const existing = clipPlaybackRef.current.get(id);
-      if (existing) {
-        existing.duration = resolveClipDurationSeconds(
-          clip.clip,
-          existing.duration
-        );
-        existing.time = clampAnimationTime(existing.time, existing.duration);
-        return { clip, state: existing };
-      }
-      const next = createClipPlaybackState(clip);
-      clipPlaybackRef.current.set(id, next);
-      return { clip, state: next };
-    },
-    [createClipPlaybackState, resolveClipById]
-  );
-  const advanceClipPlayback = useCallback(
-    (dt) => {
-      if (clipPlaybackRef.current.size === 0) {
-        return;
-      }
-      const toDelete = [];
-      clipPlaybackRef.current.forEach((state, key) => {
-        const clip = resolveClipById(state.id);
-        if (!clip) {
-          toDelete.push(key);
-          resolveClipPromise(state);
-          return;
-        }
-        state.duration = resolveClipDurationSeconds(
-          clip.clip,
-          state.duration
-        );
-        const { time, completed } = advanceClipTime(
-          {
-            time: state.time,
-            duration: state.duration,
-            speed: state.speed,
-            loop: state.loop,
-            playing: state.playing
-          },
-          dt
-        );
-        state.time = clampAnimationTime(time, state.duration);
-        if (state.playing || completed) {
-          writeClipOutputs(clip, state);
-        }
-        if (completed) {
-          toDelete.push(key);
-          resolveClipPromise(state);
-        }
-      });
-      toDelete.forEach((key) => {
-        clipPlaybackRef.current.delete(key);
-        if (animationSystemActiveRef.current) {
-          clearClipOutputs(key);
-        }
-      });
-    },
-    [clearClipOutputs, resolveClipById, resolveClipPromise, writeClipOutputs]
+    [resolveClipById]
   );
   const animateValue = useCallback(
     (path, target, options) => {
@@ -2947,42 +3886,111 @@ function VizijRuntimeProviderInner({
       useLegacyPoseWeightFallback
     ]
   );
+  const warnAnimationGap = useCallback((key, message) => {
+    if (animationGapWarnedRef.current.has(key)) {
+      return;
+    }
+    animationGapWarnedRef.current.add(key);
+    console.warn(`[vizij-runtime] ${message}`);
+  }, []);
+  const syncAnimationsSource = useCallback(() => {
+    const host = animationHostRef.current;
+    setAnimationsSourceRegistered(host ? host.hasPlaying() : false);
+    updateLoopMode();
+  }, [setAnimationsSourceRegistered, updateLoopMode]);
+  const readPlayerStates = useCallback(() => {
+    const device = deviceSlot.current?.device;
+    if (!device) {
+      return [];
+    }
+    const raw = device.readValues([ANIMATION_PLAYERS_PATH])[ANIMATION_PLAYERS_PATH];
+    return decodePlayerStates(raw);
+  }, [deviceSlot]);
+  const settleFinishedClips = useCallback(() => {
+    let pending = false;
+    clipPlaybackRef.current.forEach((state) => {
+      if (state.completion && !state.loop) {
+        pending = true;
+      }
+    });
+    const host = animationHostRef.current;
+    if (!pending || !host) {
+      return;
+    }
+    const states = readPlayerStates();
+    if (states.length === 0) {
+      return;
+    }
+    clipPlaybackRef.current.forEach((state, id) => {
+      if (!state.completion || state.loop) {
+        return;
+      }
+      const playerId = host.playerIdOf(id);
+      if (playerId === null) {
+        return;
+      }
+      const feedback = states.find((entry) => entry.player === playerId);
+      if (!feedback) {
+        return;
+      }
+      const duration = feedback.duration > 0 ? feedback.duration : state.duration;
+      const atEnd = duration > 0 && feedback.time >= duration - 1e-3;
+      if (feedback.state === "stopped" || atEnd) {
+        state.playing = false;
+        resolveClipPromise(state);
+        host.pause(id);
+        syncAnimationsSource();
+      }
+    });
+  }, [readPlayerStates, resolveClipPromise, syncAnimationsSource]);
   const playAnimation = useCallback(
     (id, options) => {
-      const ensured = ensureClipPlaybackState(id);
+      const ensured = ensureClipState(id);
       if (!ensured) {
         return Promise.reject(
           new Error(`Animation ${id} is not part of the current asset bundle.`)
         );
       }
-      const { clip, state } = ensured;
-      const shouldReset = options?.reset === true;
-      if (shouldReset) {
-        resolveClipPromise(state);
-        state.time = 0;
-      }
-      const speed = options?.speed ?? state.speed ?? 1;
-      const weight = options?.weight ?? state.weight ?? clip.weight ?? 1;
-      state.speed = Number.isFinite(speed) && speed > 0 ? speed : 1;
-      state.weight = Number.isFinite(weight) ? Number(weight) : 1;
-      state.duration = resolveClipDurationSeconds(
-        clip.clip,
-        state.duration
-      );
-      state.time = clampAnimationTime(state.time, state.duration);
+      const { state } = ensured;
+      const host = ensureAnimationHost();
+      state.speed = options?.speed ?? state.speed;
+      state.weight = options?.weight ?? state.weight;
       state.playing = true;
       const completion = ensureClipPromise(state);
       clipPlaybackRef.current.set(id, state);
-      writeClipOutputs(clip, state);
+      if (host) {
+        if (options?.reset === true) {
+          host.seek(id, 0);
+        }
+        host.setSpeed(id, state.speed);
+        host.setWeight(id, state.weight);
+        host.setLoop(id, state.loop ? "loop" : "once");
+        void host.play(id).catch((err) => {
+          pushError({
+            message: `Failed to start animation ${id} on the device`,
+            cause: err,
+            phase: "animation",
+            timestamp: performance.now()
+          });
+        });
+      } else {
+        warnAnimationGap(
+          "module-not-ready",
+          "playAnimation called before the animation module finished loading; playback starts once it is ready."
+        );
+      }
+      syncAnimationsSource();
       markActivity();
       return completion;
     },
     [
-      ensureClipPlaybackState,
+      ensureAnimationHost,
       ensureClipPromise,
+      ensureClipState,
       markActivity,
-      resolveClipPromise,
-      writeClipOutputs
+      pushError,
+      syncAnimationsSource,
+      warnAnimationGap
     ]
   );
   const pauseAnimation = useCallback(
@@ -2992,34 +4000,28 @@ function VizijRuntimeProviderInner({
         return;
       }
       state.playing = false;
-      updateLoopMode();
-    },
-    [updateLoopMode]
-  );
-  const seekAnimation = useCallback(
-    (id, timeSeconds) => {
-      const ensured = ensureClipPlaybackState(id);
-      if (!ensured) {
-        return;
-      }
-      const { clip, state } = ensured;
-      state.time = clampAnimationTime(timeSeconds, state.duration);
-      clipPlaybackRef.current.set(id, state);
-      writeClipOutputs(clip, state, { immediate: true });
+      animationHostRef.current?.pause(id);
+      syncAnimationsSource();
     },
-    [ensureClipPlaybackState, writeClipOutputs]
+    [syncAnimationsSource]
   );
+  const seekAnimation = useCallback((id, timeSeconds) => {
+    if (!clipPlaybackRef.current.has(id)) {
+      return;
+    }
+    animationHostRef.current?.seek(id, Math.max(0, timeSeconds));
+  }, []);
   const setAnimationLoop = useCallback(
     (id, enabled) => {
-      const ensured = ensureClipPlaybackState(id);
+      const ensured = ensureClipState(id);
       if (!ensured) {
         return;
       }
       ensured.state.loop = Boolean(enabled);
-      clipPlaybackRef.current.set(id, ensured.state);
+      animationHostRef.current?.setLoop(id, enabled ? "loop" : "once");
       updateLoopMode();
     },
-    [ensureClipPlaybackState, updateLoopMode]
+    [ensureClipState, updateLoopMode]
   );
   const getAnimationState = useCallback(
     (id) => {
@@ -3027,15 +4029,17 @@ function VizijRuntimeProviderInner({
       if (!state) {
         return null;
       }
+      const playerId = animationHostRef.current?.playerIdOf(id) ?? null;
+      const feedback = playerId !== null ? readPlayerStates().find((entry) => entry.player === playerId) : void 0;
       return {
-        time: state.time,
-        duration: state.duration,
-        playing: state.playing,
+        time: feedback?.time ?? 0,
+        duration: feedback && feedback.duration > 0 ? feedback.duration : state.duration,
+        playing: feedback ? feedback.state === "playing" : state.playing,
         loop: state.loop,
-        speed: state.speed
+        speed: feedback?.speed ?? state.speed
       };
     },
-    []
+    [readPlayerStates]
   );
   const stopAnimation = useCallback(
     (id, options) => {
@@ -3045,12 +4049,19 @@ function VizijRuntimeProviderInner({
         state.playing = false;
         resolveClipPromise(state);
       }
-      if (options?.clearOutputs !== false) {
-        clearClipOutputs(id);
+      const host = animationHostRef.current;
+      if (options?.clearOutputs === false) {
+        host?.pause(id);
+        syncAnimationsSource();
+      } else {
+        host?.stop(id);
+        const unsubscribe = subscribeToStep(() => {
+          unsubscribe();
+          syncAnimationsSource();
+        });
       }
-      updateLoopMode();
     },
-    [clearClipOutputs, resolveClipPromise, updateLoopMode]
+    [resolveClipPromise, subscribeToStep, syncAnimationsSource]
   );
   const refreshControllerStatus = useCallback(() => {
     const controllers = listControllers();
@@ -3199,11 +4210,21 @@ function VizijRuntimeProviderInner({
   ]);
   const playProgram = useCallback(
     (id) => {
-      if (!resolveProgramById(id)) {
+      const program = resolveProgramById(id);
+      if (!program) {
         throw new Error(
           `Program ${id} is not part of the current asset bundle.`
         );
       }
+      deriveProgramInputSeedValues({
+        program,
+        namespace,
+        inputConstraints: inputConstraintsRef.current,
+        getPathSnapshot,
+        stagedInputs: stagedInputsRef.current
+      }).forEach(({ path, value }) => {
+        setInput(path, value);
+      });
       programPlaybackRef.current.set(id, {
         id,
         state: "playing"
@@ -3211,7 +4232,14 @@ function VizijRuntimeProviderInner({
       syncProgramPlaybackControllers();
       markActivity();
     },
-    [markActivity, resolveProgramById, syncProgramPlaybackControllers]
+    [
+      getPathSnapshot,
+      markActivity,
+      namespace,
+      resolveProgramById,
+      setInput,
+      syncProgramPlaybackControllers
+    ]
   );
   const pauseProgram = useCallback(
     (id) => {
@@ -3310,6 +4338,7 @@ function VizijRuntimeProviderInner({
   );
   const registerInputDriver = useCallback(
     (id, factory) => {
+      inputDriverIdsRef.current.add(id);
       const driver = factory({
         setInput,
         setRendererValue,
@@ -3351,6 +4380,8 @@ function VizijRuntimeProviderInner({
               phase: "driver",
               timestamp: performance.now()
             });
+          } finally {
+            inputDriverIdsRef.current.delete(id);
           }
         }
       };
@@ -3358,22 +4389,15 @@ function VizijRuntimeProviderInner({
     },
     [faceId, namespace, pushError, setInput, setRendererValue]
   );
-  const advanceAnimations = useCallback(
-    (dt) => {
-      advanceAnimationTweens(dt);
-      advanceClipPlayback(dt);
-    },
-    [advanceAnimationTweens, advanceClipPlayback]
-  );
   const flushStagedInputs = useCallback(() => {
     if (stagedInputsRef.current.size === 0) {
       return;
     }
     stagedInputsRef.current.forEach(({ value, shape }, path) => {
-      orchestratorSetInput(path, value, shape);
+      deviceSetInput(path, value, shape);
     });
     stagedInputsRef.current.clear();
-  }, [orchestratorSetInput]);
+  }, [deviceSetInput]);
   const step = useCallback(
     (dt, opts) => {
       if (dt > 0 && Number.isFinite(dt)) {
@@ -3381,13 +4405,19 @@ function VizijRuntimeProviderInner({
         const alpha = 0.1;
         avgStepDtRef.current = prev * (1 - alpha) + dt * alpha;
       }
-      advanceAnimations(dt);
+      advanceAnimationTweens(dt);
       flushStagedInputs();
-      if (driveOrchestratorRef.current || opts?.forceRuntime) {
+      if (driveRuntimeRef.current || opts?.forceRuntime) {
         stepRuntime(dt);
       }
+      settleFinishedClips();
     },
-    [advanceAnimations, flushStagedInputs, stepRuntime]
+    [
+      advanceAnimationTweens,
+      flushStagedInputs,
+      settleFinishedClips,
+      stepRuntime
+    ]
   );
   useEffect(() => {
     if (loopMode !== "active") {
@@ -3402,7 +4432,7 @@ function VizijRuntimeProviderInner({
       if (lastTime == null) {
         lastTime = timestamp;
       }
-      const dt = Math.max(0, (timestamp - lastTime) / 1e3);
+      const dt = inferImplicitPause(Math.max(0, (timestamp - lastTime) / 1e3));
       lastTime = timestamp;
       step(dt || 0);
       requestLoopMode(computeDesiredLoopMode());
@@ -3433,7 +4463,7 @@ function VizijRuntimeProviderInner({
         return;
       }
       const current = now();
-      const dt = Math.max(0, (current - lastTime) / 1e3);
+      const dt = inferImplicitPause(Math.max(0, (current - lastTime) / 1e3));
       lastTime = current;
       step(dt || 0);
       requestLoopMode(computeDesiredLoopMode());
@@ -3449,8 +4479,6 @@ function VizijRuntimeProviderInner({
       clipPlaybackRef.current.clear();
       programPlaybackRef.current.clear();
       programControllerIdsRef.current.clear();
-      clipOutputValuesRef.current.clear();
-      clipAggregateValuesRef.current.clear();
     };
   }, []);
   useEffect(() => {
@@ -3503,6 +4531,10 @@ function VizijRuntimeProviderInner({
       ...status,
       assetBundle,
       setInput,
+      getValueSnapshot: getPathSnapshot,
+      getStoreSnapshot,
+      subscribeToStoreChanges,
+      subscribeToStep,
       setGraphBundle,
       setValue: setRendererValue,
       stagePoseNeutral,
@@ -3522,13 +4554,16 @@ function VizijRuntimeProviderInner({
       setAnimationActive,
       isAnimationActive,
       step,
-      advanceAnimations,
       inputConstraints
     }),
     [
       status,
       assetBundle,
       setInput,
+      getPathSnapshot,
+      getStoreSnapshot,
+      subscribeToStoreChanges,
+      subscribeToStep,
       setGraphBundle,
       setRendererValue,
       stagePoseNeutral,
@@ -3548,7 +4583,6 @@ function VizijRuntimeProviderInner({
       setAnimationActive,
       isAnimationActive,
       step,
-      advanceAnimations,
       inputConstraints
     ]
   );
@@ -3560,9 +4594,9 @@ import { memo } from "react";
 import { Vizij } from "@vizij/render";
 
 // src/hooks/useVizijRuntime.ts
-import { useContext as useContext2 } from "react";
+import { useContext } from "react";
 function useVizijRuntime() {
-  const ctx = useContext2(VizijRuntimeContext);
+  const ctx = useContext(VizijRuntimeContext);
   if (!ctx) {
     throw new Error(
       "useVizijRuntime must be used within a VizijRuntimeProvider."
@@ -3593,9 +4627,9 @@ function VizijRuntimeFaceInner({
 var VizijRuntimeFace = memo(VizijRuntimeFaceInner);
 
 // src/hooks/useOptionalVizijRuntime.ts
-import { useContext as useContext3 } from "react";
+import { useContext as useContext2 } from "react";
 function useOptionalVizijRuntime() {
-  return useContext3(VizijRuntimeContext);
+  return useContext2(VizijRuntimeContext);
 }
 
 // src/hooks/useVizijOutputs.ts