@vizij/runtime-react 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,31 +1,494 @@
 // 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
+  };
+  const hasRigOverride = Object.prototype.hasOwnProperty.call(bundle, "rig");
+  const hasPoseOverride = Object.prototype.hasOwnProperty.call(bundle, "pose");
+  const hasAnimationsOverride = Object.prototype.hasOwnProperty.call(
+    bundle,
+    "animations"
+  );
+  const hasProgramsOverride = Object.prototype.hasOwnProperty.call(
+    bundle,
+    "programs"
+  );
+  if (hasRigOverride) {
+    next.rig = bundle.rig;
+  }
+  if (hasPoseOverride) {
+    next.pose = bundle.pose;
+  }
+  if (hasAnimationsOverride) {
+    next.animations = Array.isArray(bundle.animations) ? bundle.animations : void 0;
+  }
+  if (hasProgramsOverride) {
+    next.programs = Array.isArray(bundle.programs) ? bundle.programs : void 0;
+  }
+  return next;
+}
+function normalizeSpecPayload(value) {
+  if (!value) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function glbSignature(glb) {
+  if (glb.kind === "url") {
+    const importOptions = normalizeSpecPayload({
+      aggressiveImport: glb.aggressiveImport ?? false,
+      rootBounds: glb.rootBounds ?? null
+    });
+    return `url:${glb.src}:${importOptions}`;
+  }
+  if (glb.kind === "blob") {
+    const importOptions = normalizeSpecPayload({
+      aggressiveImport: glb.aggressiveImport ?? false,
+      rootBounds: glb.rootBounds ?? null
+    });
+    return `blob:${getBlobIdentity(glb.blob)}:${importOptions}`;
+  }
+  return `world:${normalizeSpecPayload(glb.world)}`;
+}
+function graphSignature(graph) {
+  if (!graph) {
+    return "";
+  }
+  const id = graph.id ?? "";
+  return `${id}:${normalizeSpecPayload(graph.spec ?? graph.ir ?? null)}`;
+}
+function poseSignature(pose) {
+  if (!pose) {
+    return "";
+  }
+  const graph = pose.graph;
+  const config = pose.config;
+  const graphPart = graph ? graphSignature({ id: graph.id, spec: graph.spec }) : "";
+  const configPart = config ? normalizeSpecPayload(config) : "";
+  return `${graphPart}:${configPart}`;
+}
+function animationsSignature(animations) {
+  if (!Array.isArray(animations) || animations.length === 0) {
+    return "";
+  }
+  return animations.map((animation) => {
+    const id = animation.id ?? "";
+    const clipSignature = normalizeSpecPayload(animation.clip ?? null);
+    const setupSignature = normalizeSpecPayload(animation.setup ?? null);
+    const weightSignature = animation.weight == null ? "" : String(animation.weight);
+    return `${id}:${clipSignature}:${setupSignature}:${weightSignature}`;
+  }).sort().join("|");
+}
+function programsSignature(programs) {
+  if (!Array.isArray(programs) || programs.length === 0) {
+    return "";
+  }
+  return programs.map((program) => {
+    const id = program.id ?? "";
+    const label = program.label ?? "";
+    const graphId = program.graph?.id ?? "";
+    const graphPayload = normalizeSpecPayload(
+      program.graph?.spec ?? program.graph?.ir ?? null
+    );
+    const resetValues = normalizeSpecPayload(program.resetValues ?? null);
+    return `${id}:${label}:${graphId}:${graphPayload}:${resetValues}`;
+  }).sort().join("|");
+}
+function resolveRuntimeUpdatePlan(previous, next, tier) {
+  if (!previous) {
+    return { reloadAssets: true, reregisterGraphs: false };
+  }
+  const glbChanged = glbSignature(previous.glb) !== glbSignature(next.glb);
+  const rigChanged = graphSignature(previous.rig) !== graphSignature(next.rig);
+  const poseChanged = poseSignature(previous.pose) !== poseSignature(next.pose);
+  const rigReferenceChanged = previous.rig?.id !== next.rig?.id || previous.rig?.spec !== next.rig?.spec || previous.rig?.ir !== next.rig?.ir;
+  const poseReferenceChanged = previous.pose?.graph?.id !== next.pose?.graph?.id || previous.pose?.graph?.spec !== next.pose?.graph?.spec || previous.pose?.config !== next.pose?.config;
+  const graphsChanged = rigChanged || poseChanged || rigReferenceChanged || poseReferenceChanged;
+  const animationsChanged = animationsSignature(previous.animations) !== animationsSignature(next.animations);
+  const programsChanged = programsSignature(previous.programs) !== programsSignature(next.programs);
+  const controllersChanged = graphsChanged || animationsChanged || programsChanged;
+  if (tier === "assets") {
+    return { reloadAssets: true, reregisterGraphs: false };
+  }
+  if (tier === "graphs") {
+    if (glbChanged) {
+      return { reloadAssets: true, reregisterGraphs: false };
+    }
+    return { reloadAssets: false, reregisterGraphs: controllersChanged };
+  }
+  if (glbChanged) {
+    return { reloadAssets: true, reregisterGraphs: false };
+  }
+  if (controllersChanged) {
+    return { reloadAssets: false, reregisterGraphs: true };
+  }
+  return { reloadAssets: false, reregisterGraphs: false };
+}
+
 // src/utils/graph.ts
 function getNodes(spec) {
   if (!spec || typeof spec !== "object") {
@@ -70,6 +533,12 @@ function collectInputPaths(spec) {
 }
 function collectInputPathMap(spec) {
   const map = {};
+  const addVariant = (key, path, force = false) => {
+    if (!key || !force && map[key]) {
+      return;
+    }
+    map[key] = path;
+  };
   const nodes = getNodes(spec);
   nodes.forEach((node) => {
     if (String(node.type ?? "").toLowerCase() !== "input") {
@@ -81,13 +550,468 @@ function collectInputPathMap(spec) {
     }
     const id = String(node.id ?? "");
     const key = id.startsWith("input_") ? id.slice("input_".length) : id || path.trim();
-    map[key] = path.trim();
+    const trimmedPath = path.trim();
+    addVariant(key, trimmedPath);
+    if (key.startsWith("direct_")) {
+      addVariant(key.slice("direct_".length), trimmedPath, true);
+    }
+    if (key.startsWith("pose_control_")) {
+      addVariant(key.slice("pose_control_".length), trimmedPath);
+    }
   });
   return map;
 }
 
+// src/utils/posePaths.ts
+var POSE_WEIGHT_INPUT_PATH_PREFIX = "/poses/";
+var VISEME_POSE_KEYS = [
+  "a",
+  "at",
+  "b",
+  "e",
+  "e_2",
+  "f",
+  "i",
+  "k",
+  "m",
+  "o",
+  "o_2",
+  "p",
+  "r",
+  "s",
+  "t",
+  "t_2",
+  "u"
+];
+var EXPRESSIVE_EMOTION_POSE_KEYS = [
+  "concerned",
+  "happy",
+  "sad",
+  "sleepy",
+  "surprise"
+];
+var EMOTION_POSE_KEYS = [
+  "concerned",
+  "happy",
+  "neutral",
+  "sad",
+  "sleepy",
+  "surprise",
+  "angry"
+];
+var VISEME_GROUP_NEEDLES = ["viseme", "phoneme", "lip", "mouth"];
+var EMOTION_GROUP_NEEDLES = ["emotion", "expression", "mood", "affect"];
+var VISEME_POSE_KEY_SET = new Set(VISEME_POSE_KEYS);
+var EMOTION_POSE_KEY_SET = new Set(EMOTION_POSE_KEYS);
+var POSE_KEY_ALIASES = {
+  concern: "concerned",
+  surprised: "surprise"
+};
+function buildRigInputPath(faceId, path) {
+  let trimmed = path.startsWith("/") ? path.slice(1) : path;
+  if (!trimmed) {
+    return `rig/${faceId}`;
+  }
+  while (trimmed.startsWith("rig/")) {
+    const segments = trimmed.split("/");
+    if (segments.length >= 3) {
+      const existingFaceId = segments[1];
+      const remainder = segments.slice(2).join("/");
+      if (existingFaceId === faceId) {
+        return trimmed;
+      }
+      trimmed = remainder || "";
+    } else {
+      trimmed = segments.slice(1).join("/");
+    }
+  }
+  const suffix = trimmed ? `/${trimmed}` : "";
+  return `rig/${faceId}${suffix}`;
+}
+function normalizePoseWeightPathSegment(value) {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed) {
+    return "pose";
+  }
+  const normalized = trimmed.replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized || "pose";
+}
+function buildPoseWeightInputPathSegment(poseId) {
+  return normalizePoseWeightPathSegment(poseId);
+}
+function buildPoseWeightRelativePath(poseId) {
+  return `${POSE_WEIGHT_INPUT_PATH_PREFIX}${buildPoseWeightInputPathSegment(
+    poseId
+  )}.weight`;
+}
+function buildPoseWeightPathMap(poses, faceId) {
+  const faceSegment = faceId?.trim() || "face";
+  const map = /* @__PURE__ */ new Map();
+  poses.forEach((pose) => {
+    map.set(
+      pose.id,
+      buildRigInputPath(faceSegment, buildPoseWeightRelativePath(pose.id))
+    );
+  });
+  return map;
+}
+function normalizePoseSemanticKey(value) {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  const normalized = trimmed.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+  if (!normalized) {
+    return null;
+  }
+  return POSE_KEY_ALIASES[normalized] ?? normalized;
+}
+function derivePoseSemanticKeyFromId(poseId) {
+  const trimmed = poseId?.trim() ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  const stripped = trimmed.replace(/^pose_d_/i, "").replace(/^pose_/i, "").replace(/^d_/i, "").replace(/_d$/i, "");
+  return normalizePoseSemanticKey(stripped);
+}
+function getPoseSemanticKey(pose) {
+  return normalizePoseSemanticKey(pose.name) ?? derivePoseSemanticKeyFromId(pose.id) ?? null;
+}
+function normalizePoseGroupPath(value) {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  return trimmed.replace(/^\/+|\/+$/g, "").replace(/\/+/g, "/");
+}
+function sanitizePoseGroupId(value, fallback) {
+  const normalized = (value ?? "").trim().replace(/[^a-zA-Z0-9_/-]+/g, "_").replace(/^\/+|\/+$/g, "").replace(/\/+/g, "_");
+  if (!normalized) {
+    return fallback.replace(/\//g, "_");
+  }
+  return normalized;
+}
+function buildPoseGroupLookup(groups) {
+  const byId = /* @__PURE__ */ new Map();
+  const byPath = /* @__PURE__ */ new Map();
+  const orderById = /* @__PURE__ */ new Map();
+  (groups ?? []).forEach((group, index) => {
+    const path = normalizePoseGroupPath(group.path ?? group.name ?? group.id);
+    if (!path) {
+      return;
+    }
+    const id = sanitizePoseGroupId(group.id, path);
+    const humanizedName = typeof group.name === "string" && group.name.trim().length > 0 ? group.name.trim() : path.split("/").filter(Boolean).pop()?.split(/[_-]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ") ?? path;
+    const normalized = {
+      ...group,
+      id,
+      path,
+      name: humanizedName
+    };
+    byId.set(id, normalized);
+    if (!orderById.has(id)) {
+      orderById.set(id, index);
+    }
+    if (!byPath.has(path)) {
+      byPath.set(path, normalized);
+    }
+  });
+  return { byId, byPath, orderById };
+}
+function orderPoseMembershipIds(groupIds, groups) {
+  const { orderById } = buildPoseGroupLookup(groups);
+  const unique = Array.from(
+    new Set(
+      Array.from(groupIds).map((groupId) => groupId.trim()).filter((groupId) => groupId.length > 0)
+    )
+  );
+  unique.sort((left, right) => {
+    const leftIndex = orderById.get(left);
+    const rightIndex = orderById.get(right);
+    if (leftIndex !== void 0 && rightIndex !== void 0) {
+      return leftIndex - rightIndex;
+    }
+    if (leftIndex !== void 0) {
+      return -1;
+    }
+    if (rightIndex !== void 0) {
+      return 1;
+    }
+    const leftPath = normalizePoseGroupPath(left) ?? left;
+    const rightPath = normalizePoseGroupPath(right) ?? right;
+    const byPath = leftPath.localeCompare(rightPath);
+    if (byPath !== 0) {
+      return byPath;
+    }
+    return left.localeCompare(right);
+  });
+  return unique;
+}
+function valueHasNeedle(value, needles) {
+  const normalized = normalizePoseSemanticKey(value);
+  if (!normalized) {
+    return false;
+  }
+  return needles.some((needle) => normalized.includes(needle));
+}
+function resolvePoseMembership(pose, groups) {
+  const { byId, byPath } = buildPoseGroupLookup(groups);
+  const resolvedGroupIds = [];
+  const pathById = /* @__PURE__ */ new Map();
+  const addMembership = (groupId, path) => {
+    if (!groupId) {
+      return;
+    }
+    if (!resolvedGroupIds.includes(groupId)) {
+      resolvedGroupIds.push(groupId);
+    }
+    if (!path) {
+      return;
+    }
+    const existingPath = pathById.get(groupId);
+    const normalizedGroupIdPath = normalizePoseGroupPath(groupId);
+    const normalizedExistingPath = normalizePoseGroupPath(existingPath) ?? existingPath ?? null;
+    const normalizedIncomingPath = normalizePoseGroupPath(path) ?? path ?? null;
+    const shouldPromotePath = normalizedExistingPath === null || normalizedGroupIdPath !== null && normalizedExistingPath === normalizedGroupIdPath && normalizedIncomingPath !== normalizedGroupIdPath;
+    if (shouldPromotePath) {
+      pathById.set(groupId, path);
+    }
+  };
+  const addByPath = (rawPath) => {
+    const normalizedPath = normalizePoseGroupPath(rawPath);
+    if (!normalizedPath) {
+      return;
+    }
+    const existing = byPath.get(normalizedPath);
+    if (existing) {
+      addMembership(existing.id, existing.path);
+      return;
+    }
+    addMembership(sanitizePoseGroupId(null, normalizedPath), normalizedPath);
+  };
+  const addById = (rawId) => {
+    const trimmed = rawId?.trim() ?? "";
+    if (!trimmed) {
+      return;
+    }
+    const normalizedPath = normalizePoseGroupPath(trimmed);
+    const normalizedId = sanitizePoseGroupId(trimmed, trimmed);
+    const matchedById = byId.get(trimmed) ?? byId.get(normalizedId);
+    if (matchedById) {
+      addMembership(matchedById.id, matchedById.path);
+      return;
+    }
+    if (normalizedPath) {
+      const matchedByPath = byPath.get(normalizedPath);
+      if (matchedByPath) {
+        addMembership(matchedByPath.id, matchedByPath.path);
+        return;
+      }
+    }
+    addMembership(
+      normalizedId,
+      normalizedPath && normalizedPath.length > 0 ? normalizedPath : null
+    );
+  };
+  pose.groupIds?.forEach((groupId) => addById(groupId));
+  addById(pose.groupId);
+  addByPath(pose.group);
+  const orderedGroupIds = orderPoseMembershipIds(resolvedGroupIds, groups);
+  const primaryGroupId = orderedGroupIds[0] ?? null;
+  const primaryGroupPath = primaryGroupId ? byId.get(primaryGroupId)?.path ?? pathById.get(primaryGroupId) ?? null : null;
+  const groupPathsById = {};
+  orderedGroupIds.forEach((groupId) => {
+    const path = byId.get(groupId)?.path ?? pathById.get(groupId) ?? null;
+    if (path) {
+      groupPathsById[groupId] = path;
+    }
+  });
+  return {
+    groupIds: orderedGroupIds,
+    primaryGroupId,
+    primaryGroupPath,
+    groupPathsById
+  };
+}
+function poseMatchesGroupKind(pose, groups, needles) {
+  const membership = resolvePoseMembership(pose, groups);
+  if (valueHasNeedle(pose.group, needles) || valueHasNeedle(pose.groupId, needles)) {
+    return true;
+  }
+  if (pose.groupIds?.some((groupId) => valueHasNeedle(groupId, needles))) {
+    return true;
+  }
+  return membership.groupIds.some((groupId) => {
+    const path = membership.groupPathsById[groupId] ?? null;
+    const group = (groups ?? []).find((entry) => entry.id === groupId) ?? null;
+    return valueHasNeedle(groupId, needles) || valueHasNeedle(path, needles) || valueHasNeedle(group?.name, needles);
+  });
+}
+function resolvePoseSemantics(pose, groups) {
+  const membership = resolvePoseMembership(pose, groups);
+  const key = getPoseSemanticKey(pose);
+  const looksLikeVisemeGroup = poseMatchesGroupKind(
+    pose,
+    groups,
+    VISEME_GROUP_NEEDLES
+  );
+  const looksLikeEmotionGroup = poseMatchesGroupKind(
+    pose,
+    groups,
+    EMOTION_GROUP_NEEDLES
+  );
+  let kind = "other";
+  if (looksLikeVisemeGroup || key && VISEME_POSE_KEY_SET.has(key)) {
+    kind = "viseme";
+  } else if (looksLikeEmotionGroup || key && EMOTION_POSE_KEY_SET.has(key)) {
+    kind = "emotion";
+  }
+  return { key, kind, membership };
+}
+function filterPosesBySemanticKind(poses, groups, kind) {
+  return poses.filter(
+    (pose) => resolvePoseSemantics(pose, groups).kind === kind
+  );
+}
+function buildSemanticPoseWeightPathMap(poses, groups, faceId, kind) {
+  const map = /* @__PURE__ */ new Map();
+  const pathMap = buildPoseWeightPathMap(poses, faceId);
+  poses.forEach((pose) => {
+    const semantics = resolvePoseSemantics(pose, groups);
+    const path = pathMap.get(pose.id);
+    if (semantics.kind !== kind || !semantics.key || !path || map.has(semantics.key)) {
+      return;
+    }
+    map.set(semantics.key, path);
+  });
+  return map;
+}
+
+// src/utils/poseRuntime.ts
+function shouldUseLegacyPoseWeightFallback(hasPoseGraph) {
+  return !hasPoseGraph;
+}
+function resolvePoseControlInputPath({
+  inputId,
+  basePath,
+  rigInputPathMap,
+  hasNativePoseControlInput
+}) {
+  if (!inputId.trim()) {
+    return void 0;
+  }
+  return rigInputPathMap[inputId] ?? rigInputPathMap[`pose_control_${inputId}`] ?? rigInputPathMap[`direct_${inputId}`] ?? (hasNativePoseControlInput ? basePath : void 0);
+}
+
+// src/utils/clipPlayback.ts
+function toFiniteNumber(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function lastKeyframeTime(track) {
+  const keyframes = Array.isArray(track.keyframes) ? track.keyframes : [];
+  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));
+  if (!clip || typeof clip !== "object") {
+    return fallback;
+  }
+  const clipDuration = Number(clip.duration);
+  if (Number.isFinite(clipDuration) && clipDuration > 0) {
+    return clipDuration;
+  }
+  const tracks = Array.isArray(clip.tracks) ? clip.tracks : [];
+  let maxTime = 0;
+  tracks.forEach((track) => {
+    const time = lastKeyframeTime(track);
+    if (time > maxTime) {
+      maxTime = time;
+    }
+  });
+  return maxTime > 0 ? maxTime : fallback;
+}
+
+// src/utils/animationBridge.ts
+function resolveAnimationBridgeOutputPaths(channel, faceId, rigInputMap) {
+  const normalizedChannel = channel.trim().replace(/^\/+/, "");
+  if (!normalizedChannel) {
+    return [];
+  }
+  const outputPaths = /* @__PURE__ */ new Set([normalizedChannel]);
+  if (normalizedChannel.startsWith("animation/")) {
+    return Array.from(outputPaths).sort(
+      (left, right) => left.localeCompare(right)
+    );
+  }
+  if (rigInputMap && Object.keys(rigInputMap).length > 0) {
+    const candidateKeys = /* @__PURE__ */ new Set([normalizedChannel]);
+    const rigChannelMatch2 = /^rig\/[^/]+\/(.+)$/.exec(normalizedChannel);
+    if (rigChannelMatch2?.[1]) {
+      candidateKeys.add(rigChannelMatch2[1]);
+    }
+    candidateKeys.forEach((key) => {
+      const mapped = rigInputMap[key];
+      const normalized = mapped?.trim().replace(/^\/+/, "");
+      if (normalized) {
+        outputPaths.add(normalized);
+      }
+    });
+    const suffix = normalizedChannel.includes("/") ? normalizedChannel : `/${normalizedChannel}`;
+    Object.values(rigInputMap).forEach((mappedPath) => {
+      const normalized = mappedPath?.trim().replace(/^\/+/, "");
+      if (!normalized) {
+        return;
+      }
+      if (normalized === normalizedChannel || normalized.endsWith(suffix)) {
+        outputPaths.add(normalized);
+      }
+    });
+  }
+  if (!faceId) {
+    return Array.from(outputPaths).sort(
+      (left, right) => left.localeCompare(right)
+    );
+  }
+  const rigChannelMatch = /^rig\/[^/]+\/(.+)$/.exec(normalizedChannel);
+  if (rigChannelMatch?.[1]) {
+    outputPaths.add(`rig/${faceId}/${rigChannelMatch[1]}`);
+  } else if (!normalizedChannel.startsWith("rig/")) {
+    outputPaths.add(`rig/${faceId}/${normalizedChannel}`);
+  }
+  return Array.from(outputPaths).sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+function collectAnimationClipOutputPaths(clip, faceId, rigInputMap) {
+  const outputPaths = /* @__PURE__ */ new Set();
+  const tracks = Array.isArray(clip.tracks) ? clip.tracks : [];
+  tracks.forEach((track) => {
+    const channel = typeof track.channel === "string" ? track.channel.trim() : "";
+    if (!channel) {
+      return;
+    }
+    resolveAnimationBridgeOutputPaths(channel, faceId, rigInputMap).forEach(
+      (path) => {
+        outputPaths.add(path);
+      }
+    );
+  });
+  return Array.from(outputPaths).sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+
 // src/utils/valueConversion.ts
 import {
+  fromAroraValueJSON,
   isNormalizedValue,
   valueAsBool,
   valueAsColorRgba,
@@ -140,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":
@@ -168,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;
       }
@@ -180,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;
       }
@@ -190,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)
@@ -209,16 +1139,620 @@ 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";
+})();
+function isRuntimeDebugEnabled() {
+  if (DEV_MODE) {
+    return true;
+  }
+  return Boolean(
+    globalThis.__VIZIJ_RUNTIME_DEBUG__
+  );
+}
 var EASINGS = {
   linear: (t) => t,
   easeIn: (t) => t * t,
@@ -235,12 +1769,19 @@ function resolveEasing(easing) {
   return EASINGS.linear;
 }
 function findRootId(world) {
+  let fallback = null;
   for (const entry of Object.values(world)) {
-    if (entry && typeof entry === "object" && entry.type === "group" && entry.rootBounds && entry.id) {
+    if (!entry || typeof entry !== "object" || entry.type !== "group") {
+      continue;
+    }
+    if (entry.rootBounds && entry.id) {
       return entry.id;
     }
+    if (!fallback && entry.id) {
+      fallback = entry.id;
+    }
   }
-  return null;
+  return fallback;
 }
 function normalisePath(path) {
   if (!path) {
@@ -410,6 +1951,30 @@ function namespaceGraphSpec(spec, namespace) {
     nodes: nextNodes
   };
 }
+function stripNulls(value) {
+  if (value === null) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    const next2 = value.map((entry) => stripNulls(entry)).filter((entry) => entry !== void 0 && entry !== null);
+    return next2;
+  }
+  if (typeof value !== "object" || value === void 0) {
+    return value;
+  }
+  const next = {};
+  Object.entries(value).forEach(([key, entry]) => {
+    if (entry === null) {
+      return;
+    }
+    const cleaned = stripNulls(entry);
+    if (cleaned === void 0) {
+      return;
+    }
+    next[key] = cleaned;
+  });
+  return next;
+}
 var now = () => typeof performance !== "undefined" ? performance.now() : Date.now();
 function pickBundleGraph(bundle, preferredKinds) {
   if (!bundle?.graphs || bundle.graphs.length === 0) {
@@ -580,26 +2145,49 @@ function convertExtractedAnimations(clips) {
       }
       const parsedValueSize = track.valueSize != null ? Number(track.valueSize) : NaN;
       const valueSize = Number.isFinite(parsedValueSize) && parsedValueSize > 0 ? parsedValueSize : 1;
-      if (values.length !== times.length * valueSize) {
+      const interpolationRaw = typeof track.interpolation === "string" ? track.interpolation.trim().toLowerCase() : "linear";
+      const interpolation = interpolationRaw === "step" ? "step" : interpolationRaw === "cubic" || interpolationRaw === "cubicspline" ? "cubic" : "linear";
+      const isCubic = interpolation === "cubic";
+      const hasTripletTangents = isCubic && values.length === times.length * valueSize * 3;
+      const hasFlatValues = values.length === times.length * valueSize;
+      if (!hasTripletTangents && !hasFlatValues) {
         return;
       }
       const rawIndex = track.componentIndex != null ? Number(track.componentIndex) : 0;
       const componentIndex = Number.isInteger(rawIndex) && rawIndex >= 0 ? Math.min(rawIndex, valueSize - 1) : 0;
       const keyframes = [];
       times.forEach((time, index) => {
-        const base = index * valueSize + componentIndex;
-        const value = values[base];
+        const flatBase = index * valueSize + componentIndex;
+        const valueBase = hasTripletTangents ? index * valueSize * 3 + valueSize + componentIndex : flatBase;
+        const value = values[valueBase];
         if (!Number.isFinite(value)) {
           return;
         }
-        keyframes.push({ time, value });
+        const keyframe = {
+          time,
+          value
+        };
+        if (hasTripletTangents) {
+          const inBase = index * valueSize * 3 + componentIndex;
+          const outBase = index * valueSize * 3 + valueSize * 2 + componentIndex;
+          const inTangent = values[inBase];
+          const outTangent = values[outBase];
+          if (Number.isFinite(inTangent)) {
+            keyframe.inTangent = inTangent;
+          }
+          if (Number.isFinite(outTangent)) {
+            keyframe.outTangent = outTangent;
+          }
+        }
+        keyframes.push(keyframe);
       });
       if (keyframes.length === 0) {
         return;
       }
       convertedTracks.push({
         channel: channelId,
-        keyframes
+        keyframes,
+        interpolation
       });
     });
     if (convertedTracks.length === 0) {
@@ -643,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;
@@ -666,21 +2257,153 @@ function mergeAnimationLists(explicit, fromBundle) {
   }
   return changed ? merged : explicit;
 }
+function extractProgramResetValues(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const entries = Object.entries(value).filter(
+    ([, rawValue]) => Number.isFinite(Number(rawValue))
+  );
+  if (entries.length === 0) {
+    return void 0;
+  }
+  return Object.fromEntries(
+    entries.map(([path, rawValue]) => [path, Number(rawValue)])
+  );
+}
+function convertBundlePrograms(entries) {
+  if (!Array.isArray(entries) || entries.length === 0) {
+    return [];
+  }
+  return entries.filter((entry) => normaliseBundleKind(entry?.kind) === "motiongraph").map((entry) => {
+    const graph = convertBundleGraph(entry);
+    if (!graph) {
+      return null;
+    }
+    const metadata = entry.metadata && typeof entry.metadata === "object" && !Array.isArray(entry.metadata) ? entry.metadata : void 0;
+    return {
+      id: entry.id,
+      label: typeof entry.label === "string" ? entry.label : void 0,
+      graph,
+      metadata,
+      resetValues: extractProgramResetValues(metadata?.resetValues)
+    };
+  }).filter(Boolean);
+}
+function resolveConstraintDefault(path, namespace, inputConstraints) {
+  const trimmed = path.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  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;
+  }
+  const seen = new Set(explicit.map((program) => program.id));
+  let changed = false;
+  const merged = [...explicit];
+  for (const program of fromBundle) {
+    if (!program.id || seen.has(program.id)) {
+      continue;
+    }
+    merged.push(program);
+    seen.add(program.id);
+    changed = true;
+  }
+  return changed ? merged : explicit;
+}
 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")
+  );
+  const hasBasePoseConfigOverride = Boolean(
+    basePose && Object.prototype.hasOwnProperty.call(basePose, "config")
+  );
   const poseStageFilter = basePose?.stageNeutralFilter;
-  const poseGraphFromBundle = basePose?.graph ? null : convertBundleGraph(
+  const poseGraphFromBundle = hasBasePoseOverride && !basePose ? null : hasBasePoseGraphOverride ? null : convertBundleGraph(
     pickBundleGraph(resolvedBundle, ["pose-driver", "pose"])
   );
-  const resolvedPoseGraph = basePose?.graph ?? poseGraphFromBundle ?? void 0;
-  const resolvedPoseConfig = basePose?.config ?? resolvedBundle?.poses?.config ?? void 0;
+  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) {
@@ -708,15 +2431,22 @@ 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 = {
     ...base
   };
@@ -727,124 +2457,223 @@ function mergeAssetBundle(base, extracted, extractedAnimations) {
   }
   merged.pose = resolvedPose;
   merged.animations = resolvedAnimations;
+  merged.programs = programsFromBundle;
   merged.bundle = resolvedBundle;
   return merged;
 }
+function normalizeStoredAnimationInterpolation(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 buildStoredAnimationTransitions(mode) {
+  if (mode === "cubic") {
+    return void 0;
+  }
+  if (mode === "step") {
+    return {
+      in: { x: 1, y: 1 },
+      out: { x: 1, y: 0 }
+    };
+  }
+  return {
+    in: { x: 1, y: 1 },
+    out: { x: 0, y: 0 }
+  };
+}
+function toStoredAnimationClip(fallbackId, clip) {
+  const clipId = typeof clip.id === "string" && clip.id.trim().length > 0 ? clip.id.trim() : fallbackId;
+  const clipName = typeof clip.name === "string" && clip.name.trim().length > 0 ? clip.name.trim() : clipId;
+  const durationSeconds = resolveClipDurationSeconds(clip, 0);
+  const durationMs = Math.max(1, Math.round(durationSeconds * 1e3));
+  const tracks = (Array.isArray(clip.tracks) ? clip.tracks : []).map((rawTrack, trackIndex) => {
+    const channel = typeof rawTrack.channel === "string" ? rawTrack.channel.trim() : "";
+    if (!channel) {
+      return null;
+    }
+    const keyframes = (Array.isArray(rawTrack.keyframes) ? rawTrack.keyframes : []).map((keyframe) => {
+      const time = Number(keyframe.time);
+      const value = Number(keyframe.value);
+      const keyframeId = keyframe["id"];
+      const keyframeInterpolation = keyframe["interpolation"];
+      if (!Number.isFinite(time) || !Number.isFinite(value)) {
+        return null;
+      }
+      return {
+        id: typeof keyframeId === "string" && keyframeId.trim().length > 0 ? keyframeId.trim() : `${clipId}:track-${trackIndex.toString().padStart(4, "0")}:point-${time.toFixed(6)}`,
+        time,
+        value,
+        mode: normalizeStoredAnimationInterpolation(
+          keyframeInterpolation ?? rawTrack.interpolation
+        )
+      };
+    }).filter(Boolean);
+    if (keyframes.length === 0) {
+      return null;
+    }
+    keyframes.sort((left, right) => {
+      if (left.time !== right.time) {
+        return left.time - right.time;
+      }
+      return left.id.localeCompare(right.id);
+    });
+    const rawTrackId = rawTrack["id"];
+    const rawTrackName = rawTrack["name"];
+    const trackId = typeof rawTrackId === "string" && rawTrackId.trim().length > 0 ? rawTrackId.trim() : `${clipId}:track-${trackIndex.toString().padStart(4, "0")}`;
+    const trackName = typeof rawTrackName === "string" && rawTrackName.trim().length > 0 ? rawTrackName.trim() : channel.replace(/^\/+/, "") || trackId;
+    const denominator = durationSeconds > 0 ? durationSeconds : 1;
+    return {
+      id: trackId,
+      name: trackName,
+      animatableId: channel,
+      points: keyframes.map((keyframe) => {
+        const stamp = Math.max(0, Math.min(1, keyframe.time / denominator));
+        const transitions = buildStoredAnimationTransitions(keyframe.mode);
+        return {
+          id: keyframe.id,
+          stamp,
+          value: keyframe.value,
+          ...transitions ? { transitions } : {}
+        };
+      })
+    };
+  }).filter(Boolean);
+  return {
+    id: clipId,
+    name: clipName,
+    duration: durationMs,
+    groups: {},
+    tracks
+  };
+}
 function VizijRuntimeProvider({
   assetBundle,
   children,
   namespace: namespaceProp,
   faceId: faceIdProp,
+  updateTier = "auto",
   autoCreate = true,
-  createOptions,
   autostart = false,
-  driveOrchestrator = true,
+  driveRuntime = true,
   mergeStrategy,
   onRegisterControllers,
   onStatusChange,
-  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,
       namespace: namespaceProp,
       faceId: faceIdProp,
+      updateTier,
       autoCreate,
       autostart,
-      driveOrchestrator,
-      createOptions,
+      driveRuntime,
       mergeStrategy,
       onRegisterControllers,
       onStatusChange,
+      transformOutputWrite,
       store: storeRef.current,
       children
     }
   ) });
-  if (!shouldProvideOrchestrator) {
-    return runtimeTree;
-  }
-  return /* @__PURE__ */ jsx(
-    OrchestratorProvider,
-    {
-      autoCreate,
-      createOptions,
-      autostart: false,
-      children: runtimeTree
-    }
-  );
 }
 function VizijRuntimeProviderInner({
   assetBundle: initialAssetBundle,
   namespace: namespaceProp,
   faceId: faceIdProp,
+  updateTier,
   mergeStrategy,
   onRegisterControllers,
   onStatusChange,
+  transformOutputWrite,
   store,
   children,
   autoCreate,
   autostart,
-  createOptions,
-  driveOrchestrator
+  driveRuntime
 }) {
+  const [assetBundleOverride, setAssetBundleOverride] = useState(null);
+  const [graphUpdateToken, setGraphUpdateToken] = useState(0);
+  const effectiveAssetBundle = assetBundleOverride ?? initialAssetBundle;
+  const latestEffectiveAssetBundleRef = useRef(effectiveAssetBundle);
   const [extractedBundle, setExtractedBundle] = useState(() => {
-    if (initialAssetBundle.bundle) {
-      return initialAssetBundle.bundle;
+    if (effectiveAssetBundle.bundle) {
+      return effectiveAssetBundle.bundle;
     }
-    if (initialAssetBundle.glb.kind === "world" && initialAssetBundle.glb.bundle) {
-      return initialAssetBundle.glb.bundle;
+    if (effectiveAssetBundle.glb.kind === "world" && effectiveAssetBundle.glb.bundle) {
+      return effectiveAssetBundle.glb.bundle;
     }
     return null;
   });
   const [extractedAnimations, setExtractedAnimations] = useState([]);
+  const previousBundleRef = useRef(null);
+  const suppressNextBundlePlanRef = useRef(false);
+  const pendingPlanRef = useRef(null);
+  const updateTierRef = useRef(updateTier);
   useEffect(() => {
-    if (initialAssetBundle.bundle) {
-      setExtractedBundle(initialAssetBundle.bundle);
+    if (effectiveAssetBundle.bundle) {
+      setExtractedBundle(effectiveAssetBundle.bundle);
       return;
     }
-    if (initialAssetBundle.glb.kind === "world") {
-      setExtractedBundle(initialAssetBundle.glb.bundle ?? null);
+    if (effectiveAssetBundle.glb.kind === "world") {
+      setExtractedBundle(effectiveAssetBundle.glb.bundle ?? null);
     } else {
       setExtractedBundle(null);
     }
-  }, [initialAssetBundle]);
+  }, [effectiveAssetBundle]);
+  useEffect(() => {
+    updateTierRef.current = updateTier;
+  }, [updateTier]);
   const assetBundle = useMemo(
     () => mergeAssetBundle(
-      initialAssetBundle,
+      effectiveAssetBundle,
       extractedBundle,
       extractedAnimations
     ),
-    [initialAssetBundle, extractedBundle, extractedAnimations]
+    [effectiveAssetBundle, extractedBundle, extractedAnimations]
   );
-  const {
-    ready,
-    createOrchestrator,
-    registerGraph,
-    registerMergedGraph,
-    registerAnimation,
-    removeGraph,
-    removeAnimation,
-    listControllers,
-    setInput: orchestratorSetInput,
-    getPathSnapshot,
-    step: stepRuntime
-  } = useOrchestrator();
-  const frame = useOrchFrame();
+  useEffect(() => {
+    latestEffectiveAssetBundleRef.current = effectiveAssetBundle;
+  }, [effectiveAssetBundle]);
+  useEffect(() => {
+    if (suppressNextBundlePlanRef.current) {
+      suppressNextBundlePlanRef.current = false;
+      previousBundleRef.current = effectiveAssetBundle;
+      return;
+    }
+    const plan = resolveRuntimeUpdatePlan(
+      previousBundleRef.current,
+      effectiveAssetBundle,
+      updateTierRef.current
+    );
+    pendingPlanRef.current = plan;
+    previousBundleRef.current = effectiveAssetBundle;
+    if (plan.reregisterGraphs) {
+      setGraphUpdateToken((prev) => prev + 1);
+    }
+  }, [effectiveAssetBundle]);
+  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,
@@ -857,20 +2686,68 @@ 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([]);
   const registeredAnimationsRef = useRef([]);
   const mergedGraphRef = useRef(null);
+  const poseControlBridgeValuesRef = useRef(/* @__PURE__ */ new Map());
+  const poseWeightFallbackMap = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    const poseConfig = assetBundle.pose?.config;
+    if (!poseConfig) {
+      return map;
+    }
+    const posePaths = buildPoseWeightPathMap(
+      poseConfig.poses ?? [],
+      poseConfig.faceId ?? faceId ?? "face"
+    );
+    (poseConfig.poses ?? []).forEach((pose) => {
+      const posePath = posePaths.get(pose.id);
+      if (!posePath) {
+        return;
+      }
+      const values = Object.fromEntries(
+        Object.entries(pose.values ?? {}).filter(
+          ([, value]) => Number.isFinite(value)
+        )
+      );
+      map.set(posePath, values);
+    });
+    return map;
+  }, [assetBundle.pose?.config, faceId]);
+  const useLegacyPoseWeightFallback = useMemo(
+    () => shouldUseLegacyPoseWeightFallback(Boolean(assetBundle.pose?.graph)),
+    [assetBundle.pose?.graph]
+  );
+  const resolvedProgramAssets = useMemo(
+    () => assetBundle.programs && assetBundle.programs.length > 0 ? assetBundle.programs : convertBundlePrograms(assetBundle.bundle?.graphs),
+    [assetBundle.bundle?.graphs, assetBundle.programs]
+  );
   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 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);
   const lastActivityTimeRef = useRef(now());
@@ -885,9 +2762,62 @@ 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) {
+      inputConstraintsRef.current = {};
       setInputConstraints({});
       return;
     }
@@ -900,15 +2830,8 @@ function VizijRuntimeProviderInner({
       rigAsset.inputMetadata,
       namespace
     );
+    inputConstraintsRef.current = constraints;
     setInputConstraints(constraints);
-    const isDevEnv = typeof globalThis !== "undefined" && Boolean(globalThis?.process?.env?.NODE_ENV !== "production");
-    if (isDevEnv) {
-      const size = Object.keys(constraints).length;
-      console.log("[vizij-runtime] input constraints computed", size, {
-        namespace,
-        rigId: rigAsset.id
-      });
-    }
   }, [assetBundle.rig, namespace]);
   const requestLoopMode = useCallback((mode) => {
     if (!runtimeMountedRef.current) {
@@ -917,7 +2840,28 @@ function VizijRuntimeProviderInner({
     setLoopMode((prev) => prev === mode ? prev : mode);
   }, []);
   const hasActiveAnimations = useCallback(() => {
-    return animationTweensRef.current.size > 0 || clipPlaybackRef.current.size > 0;
+    if (animationTweensRef.current.size > 0) {
+      return true;
+    }
+    if (!animationSystemActiveRef.current) {
+      for (const state of programPlaybackRef.current.values()) {
+        if (state.state === "playing") {
+          return true;
+        }
+      }
+      return false;
+    }
+    for (const state of clipPlaybackRef.current.values()) {
+      if (state.playing) {
+        return true;
+      }
+    }
+    for (const state of programPlaybackRef.current.values()) {
+      if (state.state === "playing") {
+        return true;
+      }
+    }
+    return false;
   }, []);
   const computeDesiredLoopMode = useCallback(() => {
     const hasAnimations = hasActiveAnimations();
@@ -939,11 +2883,50 @@ function VizijRuntimeProviderInner({
   }, [updateLoopMode]);
   const setInput = useCallback(
     (path, value, shape) => {
+      const numericValue = valueAsNumber2(value);
+      const basePath = stripNamespace(
+        normalisePath(path),
+        namespaceRef.current
+      );
+      const poseValues = useLegacyPoseWeightFallback && numericValue != null ? poseWeightFallbackMap.get(basePath) : void 0;
+      if (poseValues && numericValue != null) {
+        const poseFaceId = assetBundle.pose?.config?.faceId ?? faceId ?? "face";
+        const rigMap = rigInputMapRef.current;
+        Object.entries(poseValues).forEach(([inputId, poseValue]) => {
+          if (!Number.isFinite(poseValue)) {
+            return;
+          }
+          const controlPath = resolvePoseControlInputPath({
+            inputId,
+            basePath: buildRigInputPath(
+              poseFaceId,
+              `/pose/control/${inputId}`
+            ),
+            rigInputPathMap: rigMap,
+            hasNativePoseControlInput: true
+          }) ?? buildRigInputPath(poseFaceId, `/pose/control/${inputId}`);
+          setInput(controlPath, { float: Number(poseValue) * numericValue });
+        });
+        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
+        });
+      }
       stagedInputsRef.current.set(namespacedPath, { value, shape });
     },
-    [markActivity]
+    [
+      assetBundle.pose?.config?.faceId,
+      faceId,
+      markActivity,
+      poseWeightFallbackMap,
+      useLegacyPoseWeightFallback
+    ]
   );
   const reportStatus = useCallback(
     (updater) => {
@@ -953,32 +2936,262 @@ function VizijRuntimeProviderInner({
         return next;
       });
     },
-    [onStatusChange]
+    [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);
+      }
+    },
+    [deviceSlot]
+  );
+  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);
+        }
+      });
+    },
+    [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) => {
@@ -1007,10 +3220,12 @@ function VizijRuntimeProviderInner({
     });
     registeredGraphsRef.current = [];
     registeredAnimationsRef.current = [];
+    programControllerIdsRef.current.clear();
     mergedGraphRef.current = null;
     outputPathsRef.current = /* @__PURE__ */ new Set();
     baseOutputPathsRef.current = /* @__PURE__ */ new Set();
     namespacedOutputPathsRef.current = /* @__PURE__ */ new Set();
+    rigPoseControlInputIdsRef.current = /* @__PURE__ */ new Set();
   }, [listControllers, removeAnimation, removeGraph, pushError]);
   useEffect(() => {
     namespaceRef.current = namespace;
@@ -1021,12 +3236,37 @@ function VizijRuntimeProviderInner({
     }));
   }, [namespace, faceId, reportStatus]);
   useEffect(() => {
-    driveOrchestratorRef.current = driveOrchestrator;
-  }, [driveOrchestrator]);
-  const glbAsset = initialAssetBundle.glb;
-  const baseBundle = initialAssetBundle.bundle ?? null;
+    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(() => {
     let cancelled = false;
+    const plan = pendingPlanRef.current;
+    if (plan && !plan.reloadAssets && status.rootId !== null) {
+      reportStatus(
+        (prev) => prev.loading ? { ...prev, loading: false } : prev
+      );
+      return () => {
+        cancelled = true;
+      };
+    }
     resetErrors();
     reportStatus((prev) => ({
       ...prev,
@@ -1078,6 +3318,12 @@ function VizijRuntimeProviderInner({
         setExtractedAnimations(convertExtractedAnimations(gltfAnimations));
         const rootId = findRootId(world);
         store.getState().addWorldElements(world, animatables, true);
+        if (pendingPlanRef.current?.reloadAssets) {
+          pendingPlanRef.current = {
+            ...pendingPlanRef.current,
+            reloadAssets: false
+          };
+        }
         reportStatus((prev) => ({
           ...prev,
           loading: false,
@@ -1115,22 +3361,32 @@ function VizijRuntimeProviderInner({
     reportStatus,
     resetErrors,
     setExtractedBundle,
-    setExtractedAnimations
+    setExtractedAnimations,
+    status.rootId
   ]);
   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()) {
+      console.log("[vizij-runtime] registerControllers", {
+        hasRig: Boolean(assetBundle.rig),
+        hasPose: Boolean(assetBundle.pose?.graph),
+        animationCount: assetBundle.animations?.length ?? 0,
+        animationIds: (assetBundle.animations ?? []).map((anim) => anim.id),
+        namespace
+      });
+    }
     const baseOutputPaths = /* @__PURE__ */ new Set();
     const namespacedOutputPaths = /* @__PURE__ */ new Set();
     const recordOutputs = (paths) => {
@@ -1142,39 +3398,60 @@ function VizijRuntimeProviderInner({
         namespacedOutputPaths.add(namespaceTypedPath(trimmed, namespace));
       });
     };
+    const graphConfigs = [];
+    rigInputMapRef.current = {};
+    rigPoseControlInputIdsRef.current = /* @__PURE__ */ new Set();
+    poseControlBridgeValuesRef.current.clear();
     const rigAsset = assetBundle.rig;
-    if (!rigAsset) {
-      pushError({
-        message: "Asset bundle is missing a rig graph.",
-        phase: "registration",
-        timestamp: performance.now()
-      });
-      return;
-    }
-    const rigSpec = resolveGraphSpec(rigAsset, `${rigAsset.id ?? "rig"} graph`);
-    if (!rigSpec) {
-      pushError({
-        message: "Rig graph is missing a usable spec or IR payload.",
-        phase: "registration",
-        timestamp: performance.now()
-      });
-      return;
-    }
-    const rigOutputs = collectOutputPaths(rigSpec);
-    const rigInputs = collectInputPaths(rigSpec);
-    rigInputMapRef.current = collectInputPathMap(rigSpec);
-    recordOutputs(rigOutputs);
-    const rigSubs = rigAsset.subscriptions ?? {
-      inputs: rigInputs,
-      outputs: rigOutputs
-    };
-    const graphConfigs = [
-      {
-        id: namespaceControllerId(rigAsset.id, namespace, "graph"),
-        spec: namespaceGraphSpec(rigSpec, namespace),
-        subs: namespaceSubscriptions(rigSubs, namespace)
+    if (rigAsset) {
+      const rigSpec = resolveGraphSpec(
+        rigAsset,
+        `${rigAsset.id ?? "rig"} graph`
+      );
+      if (!rigSpec) {
+        pushError({
+          message: "Rig graph is missing a usable spec or IR payload.",
+          phase: "registration",
+          timestamp: performance.now()
+        });
+      } else {
+        const rigOutputs = collectOutputPaths(rigSpec);
+        const rigInputs = collectInputPaths(rigSpec);
+        const rigPoseControlInputIds = /* @__PURE__ */ new Set();
+        rigInputs.forEach((path) => {
+          const poseControlMatch = /^rig\/[^/]+\/pose\/control\/(.+)$/.exec(
+            path.trim()
+          );
+          const inputId = (poseControlMatch?.[1] ?? "").trim();
+          if (inputId.length > 0) {
+            rigPoseControlInputIds.add(inputId);
+          }
+        });
+        rigInputMapRef.current = collectInputPathMap(rigSpec);
+        rigPoseControlInputIdsRef.current = rigPoseControlInputIds;
+        if (isRuntimeDebugEnabled()) {
+          const blinkKeys = Object.keys(rigInputMapRef.current).filter(
+            (key) => key.toLowerCase().includes("blink")
+          );
+          const blinkMappings = blinkKeys.slice(0, 20).map((key) => `${key} => ${rigInputMapRef.current[key] ?? "?"}`);
+          console.log("[vizij-runtime] rig input map sample", {
+            blink: rigInputMapRef.current["blink"] ?? null,
+            blinkKeys: blinkKeys.slice(0, 12),
+            blinkMappings: blinkMappings.join(" | ")
+          });
+        }
+        recordOutputs(rigOutputs);
+        const rigSubs = rigAsset.subscriptions ?? {
+          inputs: rigInputs,
+          outputs: rigOutputs
+        };
+        graphConfigs.push({
+          id: namespaceControllerId(rigAsset.id, namespace, "graph"),
+          spec: stripNulls(namespaceGraphSpec(rigSpec, namespace)),
+          subs: namespaceSubscriptions(rigSubs, namespace)
+        });
       }
-    ];
+    }
     const poseGraphAsset = assetBundle.pose?.graph;
     if (poseGraphAsset) {
       const poseSpec = resolveGraphSpec(
@@ -1191,7 +3468,7 @@ function VizijRuntimeProviderInner({
         };
         graphConfigs.push({
           id: namespaceControllerId(poseGraphAsset.id, namespace, "graph"),
-          spec: namespaceGraphSpec(poseSpec, namespace),
+          spec: stripNulls(namespaceGraphSpec(poseSpec, namespace)),
           subs: namespaceSubscriptions(poseSubs, namespace)
         });
       } else {
@@ -1200,6 +3477,31 @@ function VizijRuntimeProviderInner({
         );
       }
     }
+    for (const animation of assetBundle.animations ?? []) {
+      const bridgeOutputs = collectAnimationClipOutputPaths(
+        animation.clip,
+        faceId ?? void 0,
+        rigInputMapRef.current
+      );
+      if (isRuntimeDebugEnabled()) {
+        console.log("[vizij-runtime] animation output routing", {
+          animationId: animation.id,
+          bridgeOutputs,
+          bridgeOutputsText: bridgeOutputs.join(" | ")
+        });
+      }
+      recordOutputs(bridgeOutputs);
+    }
+    for (const program of resolvedProgramAssets) {
+      const programSpec = resolveGraphSpec(
+        program.graph,
+        `${program.id ?? "program"} graph (outputs)`
+      );
+      if (!programSpec) {
+        continue;
+      }
+      recordOutputs(collectOutputPaths(programSpec));
+    }
     outputPathsRef.current = namespacedOutputPaths;
     baseOutputPathsRef.current = baseOutputPaths;
     namespacedOutputPathsRef.current = namespacedOutputPaths;
@@ -1232,20 +3534,24 @@ function VizijRuntimeProviderInner({
       });
     }
     registeredGraphsRef.current = graphIds;
+    if (isRuntimeDebugEnabled()) {
+      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 config = {
-          id: controllerId,
-          setup: {
-            animation: anim.clip,
-            ...anim.setup ?? {}
-          }
-        };
-        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", {
+            animationId: anim.id,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
         pushError({
           message: `Failed to register animation ${anim.id}`,
           cause: err,
@@ -1254,6 +3560,7 @@ function VizijRuntimeProviderInner({
         });
       }
     }
+    ensureAnimationHost()?.setClips(hostClips);
     registeredAnimationsRef.current = animationIds;
     if (assetBundle.initialInputs) {
       Object.entries(assetBundle.initialInputs).forEach(([path, value]) => {
@@ -1270,6 +3577,13 @@ function VizijRuntimeProviderInner({
       });
     }
     const controllers = listControllers();
+    if (isRuntimeDebugEnabled()) {
+      console.log("[vizij-runtime] controllers after register", {
+        controllers,
+        graphIds,
+        animationIds
+      });
+    }
     reportStatus((prev) => ({
       ...prev,
       ready: true,
@@ -1280,6 +3594,7 @@ function VizijRuntimeProviderInner({
   }, [
     assetBundle,
     clearControllers,
+    ensureAnimationHost,
     listControllers,
     mergeStrategy,
     namespace,
@@ -1289,12 +3604,18 @@ function VizijRuntimeProviderInner({
     registerGraph,
     registerMergedGraph,
     reportStatus,
+    resolvedProgramAssets,
     setInput
   ]);
   useEffect(() => {
     if (!ready || status.loading) {
       return;
     }
+    const plan = pendingPlanRef.current;
+    const hasRegistered = registeredGraphsRef.current.length > 0 || registeredAnimationsRef.current.length > 0 || programControllerIdsRef.current.size > 0;
+    if (plan && !plan.reregisterGraphs && hasRegistered) {
+      return;
+    }
     registerControllers().catch((err) => {
       pushError({
         message: "Failed to register controllers",
@@ -1303,37 +3624,79 @@ function VizijRuntimeProviderInner({
         timestamp: performance.now()
       });
     });
-  }, [ready, status.loading, registerControllers, pushError]);
+  }, [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 batched = [];
-    const namespacedOutputs = namespacedOutputPathsRef.current;
-    const baseOutputs = baseOutputPathsRef.current;
-    writes.forEach((write) => {
-      const path = normalisePath(write.path);
-      if (!namespacedOutputs.has(path)) {
+    applyEngineChangesRef.current = (changes) => {
+      const entries = Object.entries(changes);
+      if (!entries.length) {
         return;
       }
-      const raw = valueJSONToRaw(write.value);
-      if (raw === void 0) {
-        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;
+      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 basePath = stripNamespace(path, namespaceValue);
-      const targetPath = baseOutputs.has(basePath) ? basePath : path;
-      batched.push({ id: targetPath, namespace: namespaceValue, value: raw });
-    });
-    if (batched.length > 0) {
-      setWorldValues(batched);
-    }
-  }, [frame, status.namespace, store]);
+    };
+  }, [status.namespace, store, transformOutputWrite]);
   const stagePoseNeutral = useCallback(
     (force = false) => {
       const neutral = assetBundle.pose?.config?.neutralInputs ?? {};
@@ -1399,165 +3762,583 @@ function VizijRuntimeProviderInner({
       });
       toDelete.forEach((key) => map.delete(key));
     },
-    [setInput]
+    [setInput]
+  );
+  const resolveClipById = useCallback(
+    (id) => {
+      return assetBundle.animations?.find((anim) => anim.id === id);
+    },
+    [assetBundle.animations]
+  );
+  const resolveClipPromise = useCallback((state) => {
+    state.resolve?.();
+    state.resolve = null;
+    state.completion = null;
+  }, []);
+  const ensureClipPromise = useCallback((state) => {
+    if (state.completion) {
+      return state.completion;
+    }
+    const completion = new Promise((resolve) => {
+      state.resolve = resolve;
+    });
+    state.completion = completion;
+    return completion;
+  }, []);
+  const ensureClipState = useCallback(
+    (id) => {
+      const clip = resolveClipById(id);
+      if (!clip) {
+        return null;
+      }
+      const duration = resolveClipDurationSeconds(
+        clip.clip
+      );
+      const existing = clipPlaybackRef.current.get(id);
+      if (existing) {
+        existing.duration = duration;
+        return { clip, state: existing };
+      }
+      const state = {
+        id,
+        duration,
+        speed: 1,
+        weight: 1,
+        loop: true,
+        playing: false,
+        resolve: null,
+        completion: null
+      };
+      clipPlaybackRef.current.set(id, state);
+      return { clip, state };
+    },
+    [resolveClipById]
+  );
+  const animateValue = useCallback(
+    (path, target, options) => {
+      const targetValue = valueAsNumber2(target);
+      const basePath = stripNamespace(
+        normalisePath(path),
+        namespaceRef.current
+      );
+      const poseValues = useLegacyPoseWeightFallback && targetValue != null ? poseWeightFallbackMap.get(basePath) : void 0;
+      if (poseValues && targetValue != null) {
+        const poseFaceId = assetBundle.pose?.config?.faceId ?? faceId ?? "face";
+        const rigMap = rigInputMapRef.current;
+        return Promise.all(
+          Object.entries(poseValues).flatMap(([inputId, poseValue]) => {
+            if (!Number.isFinite(poseValue)) {
+              return [];
+            }
+            const controlPath = resolvePoseControlInputPath({
+              inputId,
+              basePath: buildRigInputPath(
+                poseFaceId,
+                `/pose/control/${inputId}`
+              ),
+              rigInputPathMap: rigMap,
+              hasNativePoseControlInput: true
+            }) ?? buildRigInputPath(poseFaceId, `/pose/control/${inputId}`);
+            return [
+              animateValue(
+                controlPath,
+                { float: Number(poseValue) * targetValue },
+                options
+              )
+            ];
+          })
+        ).then(() => void 0);
+      }
+      const easing = resolveEasing(options?.easing);
+      const duration = Math.max(0, options?.duration ?? DEFAULT_DURATION);
+      cancelAnimation(path);
+      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
+      const current = getPathSnapshot(namespacedPath);
+      const fromValue = valueAsNumber2(current);
+      const toValue = valueAsNumber2(target);
+      if (fromValue == null || toValue == null || duration === 0) {
+        setInput(path, target);
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => {
+        animationTweensRef.current.set(path, {
+          // Keep the raw path here so tween updates go through setInput() once
+          // and pick up the active namespace exactly once.
+          path,
+          from: fromValue,
+          to: toValue,
+          duration,
+          elapsed: 0,
+          easing,
+          resolve
+        });
+        markActivity();
+      });
+    },
+    [
+      assetBundle.pose?.config?.faceId,
+      cancelAnimation,
+      faceId,
+      getPathSnapshot,
+      markActivity,
+      poseWeightFallbackMap,
+      setInput,
+      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 = ensureClipState(id);
+      if (!ensured) {
+        return Promise.reject(
+          new Error(`Animation ${id} is not part of the current asset bundle.`)
+        );
+      }
+      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);
+      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;
+    },
+    [
+      ensureAnimationHost,
+      ensureClipPromise,
+      ensureClipState,
+      markActivity,
+      pushError,
+      syncAnimationsSource,
+      warnAnimationGap
+    ]
+  );
+  const pauseAnimation = useCallback(
+    (id) => {
+      const state = clipPlaybackRef.current.get(id);
+      if (!state || !state.playing) {
+        return;
+      }
+      state.playing = false;
+      animationHostRef.current?.pause(id);
+      syncAnimationsSource();
+    },
+    [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 = ensureClipState(id);
+      if (!ensured) {
+        return;
+      }
+      ensured.state.loop = Boolean(enabled);
+      animationHostRef.current?.setLoop(id, enabled ? "loop" : "once");
+      updateLoopMode();
+    },
+    [ensureClipState, updateLoopMode]
+  );
+  const getAnimationState = useCallback(
+    (id) => {
+      const state = clipPlaybackRef.current.get(id);
+      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: feedback?.time ?? 0,
+        duration: feedback && feedback.duration > 0 ? feedback.duration : state.duration,
+        playing: feedback ? feedback.state === "playing" : state.playing,
+        loop: state.loop,
+        speed: feedback?.speed ?? state.speed
+      };
+    },
+    [readPlayerStates]
+  );
+  const stopAnimation = useCallback(
+    (id, options) => {
+      const state = clipPlaybackRef.current.get(id);
+      if (state) {
+        clipPlaybackRef.current.delete(id);
+        state.playing = false;
+        resolveClipPromise(state);
+      }
+      const host = animationHostRef.current;
+      if (options?.clearOutputs === false) {
+        host?.pause(id);
+        syncAnimationsSource();
+      } else {
+        host?.stop(id);
+        const unsubscribe = subscribeToStep(() => {
+          unsubscribe();
+          syncAnimationsSource();
+        });
+      }
+    },
+    [resolveClipPromise, subscribeToStep, syncAnimationsSource]
+  );
+  const refreshControllerStatus = useCallback(() => {
+    const controllers = listControllers();
+    reportStatus((prev) => ({
+      ...prev,
+      controllers,
+      outputPaths: Array.from(outputPathsRef.current)
+    }));
+    onRegisterControllers?.(controllers);
+  }, [listControllers, onRegisterControllers, reportStatus]);
+  const resolveProgramById = useCallback(
+    (id) => {
+      return resolvedProgramAssets.find((program) => program.id === id);
+    },
+    [resolvedProgramAssets]
   );
-  const sampleTrack = useCallback(
-    (track, time) => {
-      const keyframes = Array.isArray(track.keyframes) ? track.keyframes : [];
-      if (!keyframes.length) {
-        return 0;
-      }
-      const first = keyframes[0];
-      if (!first) {
-        return 0;
-      }
-      if (time <= Number(first.time ?? 0)) {
-        return Number(first.value ?? 0);
-      }
-      for (let i = 0; i < keyframes.length - 1; i += 1) {
-        const current = keyframes[i] ?? {};
-        const next = keyframes[i + 1] ?? {};
-        const start = Number(current.time ?? 0);
-        const end = Number(next.time ?? start);
-        if (time >= start && time <= end) {
-          const range = end - start || 1;
-          const factor = (time - start) / range;
-          const currentValue = Number(current.value ?? 0);
-          const nextValue = Number(next.value ?? currentValue);
-          return currentValue + (nextValue - currentValue) * factor;
-        }
+  const buildProgramRegistrationConfig = useCallback(
+    (program) => {
+      const graphSpec = resolveGraphSpec(
+        program.graph,
+        `${program.id ?? "program"} graph`
+      );
+      if (!graphSpec) {
+        return null;
+      }
+      const outputs = collectOutputPaths(graphSpec);
+      const inputs = collectInputPaths(graphSpec);
+      const subs = program.graph.subscriptions ?? {
+        inputs,
+        outputs
+      };
+      return {
+        id: namespaceControllerId(program.id, namespace, "graph"),
+        spec: stripNulls(namespaceGraphSpec(graphSpec, namespace)),
+        subs: namespaceSubscriptions(subs, namespace)
+      };
+    },
+    [namespace]
+  );
+  const deriveProgramResetValues = useCallback(
+    (program) => {
+      if (program.resetValues) {
+        return Object.entries(program.resetValues).filter(([, value]) => Number.isFinite(value)).map(([path, value]) => ({ path, value }));
+      }
+      const graphSpec = resolveGraphSpec(
+        program.graph,
+        `${program.id ?? "program"} graph (reset)`
+      );
+      if (!graphSpec) {
+        return [];
       }
-      const last = keyframes[keyframes.length - 1];
-      return Number(last?.value ?? 0);
+      return collectOutputPaths(graphSpec).filter((path) => path.trim().length > 0).map((path) => {
+        const defaultValue = inputConstraintsRef.current[path]?.defaultValue ?? 0;
+        return {
+          path,
+          value: Number.isFinite(defaultValue) && defaultValue != null ? defaultValue : 0
+        };
+      });
     },
     []
   );
-  const advanceClipPlayback = useCallback(
-    (dt) => {
-      if (clipPlaybackRef.current.size === 0) {
+  const syncProgramPlaybackControllers = useCallback(() => {
+    if (!ready) {
+      return;
+    }
+    const availableProgramIds = new Set(
+      resolvedProgramAssets.map((program) => program.id)
+    );
+    Array.from(programPlaybackRef.current.keys()).forEach((id) => {
+      if (availableProgramIds.has(id)) {
         return;
       }
-      const map = clipPlaybackRef.current;
-      const toDelete = [];
-      map.forEach((state, key) => {
-        state.time += dt * state.speed;
-        const clip = assetBundle.animations?.find(
-          (anim) => anim.id === state.id
-        );
-        if (!clip) {
-          toDelete.push(key);
-          state.resolve();
+      programPlaybackRef.current.delete(id);
+      const controllerId = programControllerIdsRef.current.get(id);
+      if (controllerId) {
+        try {
+          removeGraph(controllerId);
+        } catch (err) {
+          pushError({
+            message: `Failed to remove program ${id}`,
+            cause: err,
+            phase: "registration",
+            timestamp: performance.now()
+          });
+        }
+        programControllerIdsRef.current.delete(id);
+      }
+    });
+    programPlaybackRef.current.forEach((state, id) => {
+      const program = resolveProgramById(id);
+      const controllerId = programControllerIdsRef.current.get(id);
+      if (!program) {
+        return;
+      }
+      if (state.state !== "playing") {
+        if (!controllerId) {
           return;
         }
-        const clipData = clip.clip;
-        const duration = Number(clipData?.duration ?? state.duration);
-        state.duration = Number.isFinite(duration) && duration > 0 ? duration : state.duration;
-        if (state.time >= state.duration) {
-          toDelete.push(key);
-          state.time = state.duration;
+        try {
+          removeGraph(controllerId);
+        } catch (err) {
+          pushError({
+            message: `Failed to pause program ${id}`,
+            cause: err,
+            phase: "registration",
+            timestamp: performance.now()
+          });
         }
-        const tracks = Array.isArray(clipData?.tracks) ? clipData.tracks : [];
-        tracks.forEach((track) => {
-          const value = sampleTrack(track, state.time) * state.weight;
-          const path = `animation/${clip.id}/${track.channel}`;
-          setInput(path, { float: value });
+        programControllerIdsRef.current.delete(id);
+        return;
+      }
+      if (controllerId) {
+        return;
+      }
+      const config = buildProgramRegistrationConfig(program);
+      if (!config) {
+        pushError({
+          message: `Program ${id} is missing a usable graph payload.`,
+          phase: "registration",
+          timestamp: performance.now()
         });
-        if (toDelete.includes(key)) {
-          state.resolve();
-        }
+        return;
+      }
+      try {
+        const nextControllerId = registerGraph(config);
+        programControllerIdsRef.current.set(id, nextControllerId);
+      } catch (err) {
+        pushError({
+          message: `Failed to register program ${id}`,
+          cause: err,
+          phase: "registration",
+          timestamp: performance.now()
+        });
+      }
+    });
+    refreshControllerStatus();
+  }, [
+    buildProgramRegistrationConfig,
+    pushError,
+    ready,
+    refreshControllerStatus,
+    registerGraph,
+    removeGraph,
+    resolvedProgramAssets,
+    resolveProgramById
+  ]);
+  const playProgram = useCallback(
+    (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);
       });
-      toDelete.forEach((key) => {
-        clipPlaybackRef.current.delete(key);
-        const clip = assetBundle.animations?.find((anim) => anim.id === key);
-        if (clip) {
-          const clipData = clip.clip;
-          const tracks = Array.isArray(clipData?.tracks) ? clipData.tracks : [];
-          tracks.forEach((track) => {
-            const path = `animation/${clip.id}/${track.channel}`;
-            setInput(path, { float: 0 });
-          });
-        }
+      programPlaybackRef.current.set(id, {
+        id,
+        state: "playing"
       });
+      syncProgramPlaybackControllers();
+      markActivity();
     },
-    [assetBundle.animations, sampleTrack, setInput]
+    [
+      getPathSnapshot,
+      markActivity,
+      namespace,
+      resolveProgramById,
+      setInput,
+      syncProgramPlaybackControllers
+    ]
   );
-  const animateValue = useCallback(
-    (path, target, options) => {
-      const easing = resolveEasing(options?.easing);
-      const duration = Math.max(0, options?.duration ?? DEFAULT_DURATION);
-      cancelAnimation(path);
-      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
-      const current = getPathSnapshot(namespacedPath);
-      const fromValue = valueAsNumber2(current);
-      const toValue = valueAsNumber2(target);
-      if (fromValue == null || toValue == null || duration === 0) {
-        setInput(path, target);
-        return Promise.resolve();
+  const pauseProgram = useCallback(
+    (id) => {
+      if (!resolveProgramById(id)) {
+        return;
       }
-      return new Promise((resolve) => {
-        animationTweensRef.current.set(path, {
-          path: namespacedPath,
-          from: fromValue,
-          to: toValue,
-          duration,
-          elapsed: 0,
-          easing,
-          resolve
-        });
-        markActivity();
+      programPlaybackRef.current.set(id, {
+        id,
+        state: "paused"
       });
+      syncProgramPlaybackControllers();
+      updateLoopMode();
     },
-    [cancelAnimation, getPathSnapshot, markActivity, setInput]
+    [resolveProgramById, syncProgramPlaybackControllers, updateLoopMode]
   );
-  const playAnimation = useCallback(
+  const stopProgram = useCallback(
     (id, options) => {
-      const clip = assetBundle.animations?.find((anim) => anim.id === id);
-      if (!clip) {
-        return Promise.reject(
-          new Error(`Animation ${id} is not part of the current asset bundle.`)
-        );
-      }
-      if (clipPlaybackRef.current.has(id)) {
-        clipPlaybackRef.current.delete(id);
+      const program = resolveProgramById(id);
+      const controllerId = programControllerIdsRef.current.get(id);
+      if (controllerId) {
+        try {
+          removeGraph(controllerId);
+        } catch (err) {
+          pushError({
+            message: `Failed to stop program ${id}`,
+            cause: err,
+            phase: "registration",
+            timestamp: performance.now()
+          });
+        }
+        programControllerIdsRef.current.delete(id);
       }
-      return new Promise((resolve) => {
-        const speed = options?.speed ?? 1;
-        const weight = options?.weight ?? clip.weight ?? 1;
-        const clipData = clip.clip;
-        clipPlaybackRef.current.set(id, {
-          id,
-          time: options?.reset ? 0 : 0,
-          duration: Number(clipData?.duration ?? 0),
-          speed: Number.isFinite(speed) && speed > 0 ? speed : 1,
-          weight,
-          resolve
-        });
-        markActivity();
+      programPlaybackRef.current.set(id, {
+        id,
+        state: "stopped"
       });
+      if (program && options?.resetOutputs !== false) {
+        deriveProgramResetValues(program).forEach(({ path, value }) => {
+          setInput(path, { float: value });
+        });
+      }
+      refreshControllerStatus();
+      updateLoopMode();
     },
-    [assetBundle.animations, markActivity]
+    [
+      deriveProgramResetValues,
+      pushError,
+      refreshControllerStatus,
+      removeGraph,
+      resolveProgramById,
+      setInput,
+      updateLoopMode
+    ]
   );
-  const stopAnimation = useCallback(
+  const getProgramState = useCallback(
     (id) => {
-      const clip = assetBundle.animations?.find((anim) => anim.id === id);
-      const state = clipPlaybackRef.current.get(id);
-      if (state) {
-        clipPlaybackRef.current.delete(id);
-        state.resolve();
+      const state = programPlaybackRef.current.get(id);
+      if (!state) {
+        return null;
       }
-      if (clip) {
-        const clipData = clip.clip;
-        const tracks = Array.isArray(clipData?.tracks) ? clipData.tracks : [];
-        tracks.forEach((track) => {
-          const path = `animation/${clip.id}/${track.channel}`;
-          setInput(path, { float: 0 });
+      return { state: state.state };
+    },
+    []
+  );
+  useEffect(() => {
+    if (!ready || status.loading) {
+      return;
+    }
+    syncProgramPlaybackControllers();
+  }, [
+    graphUpdateToken,
+    ready,
+    resolvedProgramAssets,
+    status.loading,
+    syncProgramPlaybackControllers
+  ]);
+  const setAnimationActive = useCallback(
+    (active) => {
+      const next = Boolean(active);
+      if (animationSystemActiveRef.current === next) {
+        return;
+      }
+      animationSystemActiveRef.current = next;
+      if (!next) {
+        clipPlaybackRef.current.forEach((state) => {
+          state.playing = false;
         });
       }
+      updateLoopMode();
     },
-    [assetBundle.animations, setInput]
+    [updateLoopMode]
+  );
+  const isAnimationActive = useCallback(
+    () => animationSystemActiveRef.current,
+    []
   );
   const registerInputDriver = useCallback(
     (id, factory) => {
+      inputDriverIdsRef.current.add(id);
       const driver = factory({
         setInput,
         setRendererValue,
@@ -1599,6 +4380,8 @@ function VizijRuntimeProviderInner({
               phase: "driver",
               timestamp: performance.now()
             });
+          } finally {
+            inputDriverIdsRef.current.delete(id);
           }
         }
       };
@@ -1606,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)) {
@@ -1629,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") {
@@ -1650,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());
@@ -1681,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());
@@ -1695,6 +4477,8 @@ function VizijRuntimeProviderInner({
     return () => {
       animationTweensRef.current.clear();
       clipPlaybackRef.current.clear();
+      programPlaybackRef.current.clear();
+      programControllerIdsRef.current.clear();
     };
   }, []);
   useEffect(() => {
@@ -1710,35 +4494,95 @@ function VizijRuntimeProviderInner({
     }, 500);
     return () => window.clearInterval(id);
   }, [reportStatus]);
+  const setGraphBundle = useCallback(
+    (bundle, options) => {
+      const baseAssetBundle = latestEffectiveAssetBundleRef.current;
+      const nextAssetBundle = applyRuntimeGraphBundle(baseAssetBundle, bundle);
+      const plan = resolveRuntimeUpdatePlan(
+        baseAssetBundle,
+        nextAssetBundle,
+        options?.tier ?? updateTierRef.current
+      );
+      pendingPlanRef.current = plan;
+      previousBundleRef.current = nextAssetBundle;
+      latestEffectiveAssetBundleRef.current = nextAssetBundle;
+      suppressNextBundlePlanRef.current = true;
+      setAssetBundleOverride(nextAssetBundle);
+      if (plan.reregisterGraphs) {
+        setGraphUpdateToken((prev) => prev + 1);
+      }
+      if (plan.reloadAssets) {
+        reportStatus((prev) => ({
+          ...prev,
+          loading: true,
+          ready: false
+        }));
+      } else {
+        reportStatus((prev) => ({
+          ...prev,
+          loading: false
+        }));
+      }
+    },
+    [reportStatus]
+  );
   const contextValue = useMemo(
     () => ({
       ...status,
       assetBundle,
       setInput,
+      getValueSnapshot: getPathSnapshot,
+      getStoreSnapshot,
+      subscribeToStoreChanges,
+      subscribeToStep,
+      setGraphBundle,
       setValue: setRendererValue,
       stagePoseNeutral,
       animateValue,
       cancelAnimation,
       registerInputDriver,
       playAnimation,
+      pauseAnimation,
+      seekAnimation,
+      setAnimationLoop,
+      getAnimationState,
       stopAnimation,
+      playProgram,
+      pauseProgram,
+      stopProgram,
+      getProgramState,
+      setAnimationActive,
+      isAnimationActive,
       step,
-      advanceAnimations,
       inputConstraints
     }),
     [
       status,
       assetBundle,
       setInput,
+      getPathSnapshot,
+      getStoreSnapshot,
+      subscribeToStoreChanges,
+      subscribeToStep,
+      setGraphBundle,
       setRendererValue,
       stagePoseNeutral,
       animateValue,
       cancelAnimation,
       registerInputDriver,
       playAnimation,
+      pauseAnimation,
+      seekAnimation,
+      setAnimationLoop,
+      getAnimationState,
       stopAnimation,
+      playProgram,
+      pauseProgram,
+      stopProgram,
+      getProgramState,
+      setAnimationActive,
+      isAnimationActive,
       step,
-      advanceAnimations,
       inputConstraints
     ]
   );
@@ -1750,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."
@@ -1782,17 +4626,23 @@ function VizijRuntimeFaceInner({
 }
 var VizijRuntimeFace = memo(VizijRuntimeFaceInner);
 
+// src/hooks/useOptionalVizijRuntime.ts
+import { useContext as useContext2 } from "react";
+function useOptionalVizijRuntime() {
+  return useContext2(VizijRuntimeContext);
+}
+
 // src/hooks/useVizijOutputs.ts
 import {
   useVizijStore
 } from "@vizij/render";
-import { getLookup } from "@vizij/utils";
+import { getLookup as getLookup2 } from "@vizij/utils";
 function useVizijOutputs(paths) {
   const { namespace } = useVizijRuntime();
   return useVizijStore((state) => {
     const result = {};
     paths.forEach((path) => {
-      const lookup = getLookup(namespace, path);
+      const lookup = getLookup2(namespace, path);
       result[path] = state.values.get(lookup);
     });
     return result;
@@ -1804,11 +4654,11 @@ import { useCallback as useCallback2 } from "react";
 import {
   useVizijStore as useVizijStore2
 } from "@vizij/render";
-import { getLookup as getLookup2 } from "@vizij/utils";
+import { getLookup as getLookup3 } from "@vizij/utils";
 function useRigInput(path) {
   const { namespace, setInput } = useVizijRuntime();
   const value = useVizijStore2((state) => {
-    return state.values.get(getLookup2(namespace, path));
+    return state.values.get(getLookup3(namespace, path));
   });
   const setter = useCallback2(
     (next, shape) => {
@@ -1818,9 +4668,422 @@ function useRigInput(path) {
   );
   return [value, setter];
 }
+
+// src/utils/faceControls.ts
+var DEFAULT_GAZE_CONTROL = {
+  min: -1,
+  max: 1,
+  defaultValue: 0
+};
+var DEFAULT_BLINK_CONTROL = {
+  min: 0,
+  max: 1,
+  defaultValue: 0
+};
+var STANDARD_VIZIJ_EYE_PATHS = {
+  leftX: "/standard/vizij/left_eye/pos/x",
+  leftY: "/standard/vizij/left_eye/pos/y",
+  rightX: "/standard/vizij/right_eye/pos/x",
+  rightY: "/standard/vizij/right_eye/pos/y",
+  leftUpper: "/standard/vizij/left_eye_top_eyelid/pos/y",
+  rightUpper: "/standard/vizij/right_eye_top_eyelid/pos/y"
+};
+var LEGACY_STANDARD_EYE_PATHS = {
+  leftX: "/standard/left_eye/pos/x",
+  leftY: "/standard/left_eye/pos/y",
+  rightX: "/standard/right_eye/pos/x",
+  rightY: "/standard/right_eye/pos/y",
+  leftUpper: "/standard/left_eye_top_eyelid/pos/y",
+  rightUpper: "/standard/right_eye_top_eyelid/pos/y"
+};
+var PROPSRIG_EYE_PATHS = {
+  leftX: "/propsrig/l_eye/translation/x",
+  leftY: "/propsrig/l_eye/translation/y",
+  rightX: "/propsrig/r_eye/translation/x",
+  rightY: "/propsrig/r_eye/translation/y"
+};
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function normalizeInputPath(path) {
+  const trimmed = path?.trim() ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  if (trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  const rigMatch = trimmed.match(/^rig\/[^/]+(\/.*)$/);
+  if (rigMatch?.[1]) {
+    return rigMatch[1];
+  }
+  return `/${trimmed}`;
+}
+function buildControlsLookup(assetBundle) {
+  const metadata = assetBundle.rig?.inputMetadata ?? [];
+  const metadataByPath = /* @__PURE__ */ new Map();
+  const pathSet = /* @__PURE__ */ new Set();
+  metadata.forEach((entry) => {
+    const normalized = normalizeInputPath(entry.path);
+    if (!normalized) {
+      return;
+    }
+    pathSet.add(normalized);
+    if (!metadataByPath.has(normalized)) {
+      metadataByPath.set(normalized, entry);
+    }
+  });
+  return { pathSet, metadataByPath };
+}
+function resolveConstraint(absolutePath, relativePath, inputConstraints) {
+  if (!inputConstraints) {
+    return null;
+  }
+  const normalizedRelative = relativePath.replace(/^\//, "");
+  const candidates = [
+    absolutePath,
+    relativePath,
+    normalizedRelative,
+    absolutePath.replace(/^rig\/[^/]+\//, "")
+  ];
+  for (const candidate of candidates) {
+    const constraint = inputConstraints[candidate];
+    if (constraint) {
+      return constraint;
+    }
+  }
+  return null;
+}
+function createControl(faceId, lookup, relativePath, inputConstraints, fallback) {
+  const normalizedRelative = normalizeInputPath(relativePath);
+  if (!normalizedRelative || !lookup.pathSet.has(normalizedRelative)) {
+    return null;
+  }
+  const absolutePath = buildRigInputPath(faceId, normalizedRelative);
+  const metadata = lookup.metadataByPath.get(normalizedRelative);
+  const constraint = resolveConstraint(
+    absolutePath,
+    normalizedRelative,
+    inputConstraints
+  );
+  const min = Number.isFinite(Number(constraint?.min ?? metadata?.range?.min)) ? Number(constraint?.min ?? metadata?.range?.min) : fallback.min;
+  const max = Number.isFinite(Number(constraint?.max ?? metadata?.range?.max)) ? Number(constraint?.max ?? metadata?.range?.max) : fallback.max;
+  const midpoint = min + (max - min) / 2;
+  const defaultValue = Number.isFinite(
+    Number(constraint?.defaultValue ?? metadata?.defaultValue)
+  ) ? Number(constraint?.defaultValue ?? metadata?.defaultValue) : Number.isFinite(midpoint) ? midpoint : fallback.defaultValue;
+  return {
+    path: absolutePath,
+    min,
+    max,
+    defaultValue
+  };
+}
+function hasAll(controls, keys) {
+  return keys.every((key) => Boolean(controls[key]));
+}
+function resolveFaceControls(assetBundle, runtimeFaceId, inputConstraints) {
+  const faceId = assetBundle.faceId ?? assetBundle.pose?.config?.faceId ?? runtimeFaceId ?? "face";
+  const lookup = buildControlsLookup(assetBundle);
+  const standardVizijControls = {
+    leftX: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.leftX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftY: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.leftY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightX: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.rightX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightY: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.rightY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftUpper: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.leftUpper,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightUpper: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.rightUpper,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    )
+  };
+  const legacyStandardControls = {
+    leftX: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.leftX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftY: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.leftY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightX: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.rightX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightY: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.rightY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftUpper: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.leftUpper,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightUpper: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.rightUpper,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    )
+  };
+  const propsrigControls = {
+    leftX: createControl(
+      faceId,
+      lookup,
+      PROPSRIG_EYE_PATHS.leftX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftY: createControl(
+      faceId,
+      lookup,
+      PROPSRIG_EYE_PATHS.leftY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightX: createControl(
+      faceId,
+      lookup,
+      PROPSRIG_EYE_PATHS.rightX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightY: createControl(
+      faceId,
+      lookup,
+      PROPSRIG_EYE_PATHS.rightY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    )
+  };
+  const coupledGazeControls = {
+    leftX: createControl(
+      faceId,
+      lookup,
+      "/gaze/left_right",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftY: createControl(
+      faceId,
+      lookup,
+      "/gaze/up_down",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightX: createControl(
+      faceId,
+      lookup,
+      "/gaze/left_right_copy",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ) ?? createControl(
+      faceId,
+      lookup,
+      "/gaze/left_right",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightY: createControl(
+      faceId,
+      lookup,
+      "/gaze/up_down_copy",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ) ?? createControl(
+      faceId,
+      lookup,
+      "/gaze/up_down",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    )
+  };
+  const blinkFromLids = createControl(
+    faceId,
+    lookup,
+    "/lids/blink",
+    inputConstraints,
+    DEFAULT_BLINK_CONTROL
+  );
+  const blinkDirect = createControl(
+    faceId,
+    lookup,
+    "/blink",
+    inputConstraints,
+    DEFAULT_BLINK_CONTROL
+  );
+  if (hasAll(standardVizijControls, ["leftX", "leftY", "rightX", "rightY"])) {
+    return {
+      faceId,
+      gazeSource: "standard-vizij",
+      blinkSource: blinkFromLids ? "lids" : blinkDirect ? "blink" : "none",
+      eyes: {
+        leftX: standardVizijControls.leftX,
+        leftY: standardVizijControls.leftY,
+        rightX: standardVizijControls.rightX,
+        rightY: standardVizijControls.rightY
+      },
+      eyelids: {
+        leftUpper: standardVizijControls.leftUpper,
+        rightUpper: standardVizijControls.rightUpper
+      },
+      blink: blinkFromLids ?? blinkDirect
+    };
+  }
+  if (hasAll(legacyStandardControls, ["leftX", "leftY", "rightX", "rightY"])) {
+    return {
+      faceId,
+      gazeSource: "standard",
+      blinkSource: blinkDirect ? "blink" : blinkFromLids ? "lids" : "none",
+      eyes: {
+        leftX: legacyStandardControls.leftX,
+        leftY: legacyStandardControls.leftY,
+        rightX: legacyStandardControls.rightX,
+        rightY: legacyStandardControls.rightY
+      },
+      eyelids: {
+        leftUpper: legacyStandardControls.leftUpper,
+        rightUpper: legacyStandardControls.rightUpper
+      },
+      blink: blinkDirect ?? blinkFromLids
+    };
+  }
+  if (hasAll(propsrigControls, ["leftX", "leftY", "rightX", "rightY"])) {
+    return {
+      faceId,
+      gazeSource: "propsrig",
+      blinkSource: blinkDirect ? "blink" : blinkFromLids ? "lids" : "none",
+      eyes: {
+        leftX: propsrigControls.leftX,
+        leftY: propsrigControls.leftY,
+        rightX: propsrigControls.rightX,
+        rightY: propsrigControls.rightY
+      },
+      eyelids: {
+        leftUpper: null,
+        rightUpper: null
+      },
+      blink: blinkDirect ?? blinkFromLids
+    };
+  }
+  if (hasAll(coupledGazeControls, ["leftX", "leftY", "rightX", "rightY"])) {
+    return {
+      faceId,
+      gazeSource: "coupled-gaze",
+      blinkSource: blinkFromLids ? "lids" : blinkDirect ? "blink" : "none",
+      eyes: {
+        leftX: coupledGazeControls.leftX,
+        leftY: coupledGazeControls.leftY,
+        rightX: coupledGazeControls.rightX,
+        rightY: coupledGazeControls.rightY
+      },
+      eyelids: {
+        leftUpper: null,
+        rightUpper: null
+      },
+      blink: blinkFromLids ?? blinkDirect
+    };
+  }
+  return {
+    faceId,
+    gazeSource: "none",
+    blinkSource: blinkFromLids ? "lids" : blinkDirect ? "blink" : "none",
+    eyes: {
+      leftX: null,
+      leftY: null,
+      rightX: null,
+      rightY: null
+    },
+    eyelids: {
+      leftUpper: null,
+      rightUpper: null
+    },
+    blink: blinkFromLids ?? blinkDirect
+  };
+}
+function mapNormalizedControlValue(control, normalizedValue) {
+  const value = clamp(normalizedValue, -1, 1);
+  if (value === 0) {
+    return control.defaultValue;
+  }
+  if (value > 0) {
+    return control.defaultValue + (control.max - control.defaultValue) * value;
+  }
+  return control.defaultValue + (control.defaultValue - control.min) * value;
+}
+function mapUnitControlValue(control, unitValue) {
+  const value = clamp(unitValue, 0, 1);
+  return control.defaultValue + (control.max - control.defaultValue) * value;
+}
 export {
+  EMOTION_POSE_KEYS,
+  EXPRESSIVE_EMOTION_POSE_KEYS,
+  POSE_WEIGHT_INPUT_PATH_PREFIX,
+  VISEME_POSE_KEYS,
   VizijRuntimeFace,
   VizijRuntimeProvider,
+  buildPoseWeightInputPathSegment,
+  buildPoseWeightPathMap,
+  buildPoseWeightRelativePath,
+  buildRigInputPath,
+  buildSemanticPoseWeightPathMap,
+  filterPosesBySemanticKind,
+  getPoseSemanticKey,
+  mapNormalizedControlValue,
+  mapUnitControlValue,
+  normalizePoseSemanticKey,
+  resolveFaceControls,
+  resolvePoseMembership,
+  resolvePoseSemantics,
+  resolveRuntimeUpdatePlan,
+  useOptionalVizijRuntime,
   useRigInput,
   useVizijOutputs,
   useVizijRuntime