@vizij/runtime-react 0.0.14 → 0.2.0

package/dist/index.js

@@ -1,42 +1,162 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  VizijRuntimeFace: () => VizijRuntimeFace,
-  VizijRuntimeProvider: () => VizijRuntimeProvider,
-  useRigInput: () => useRigInput,
-  useVizijOutputs: () => useVizijOutputs,
-  useVizijRuntime: () => useVizijRuntime
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/VizijRuntimeProvider.tsx
-var import_react2 = require("react");
-var import_render = require("@vizij/render");
-var import_orchestrator_react = require("@vizij/orchestrator-react");
-var import_value_json2 = require("@vizij/value-json");
+import {
+  useCallback,
+  useContext,
+  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";
 
 // src/context.ts
-var import_react = require("react");
-var VizijRuntimeContext = (0, import_react.createContext)(null);
+import { createContext } from "react";
+var VizijRuntimeContext = createContext(null);
+
+// src/updatePolicy.ts
+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) {
+    if (bundle.rig) {
+      next.rig = bundle.rig;
+    } else {
+      delete next.rig;
+    }
+  }
+  if (hasPoseOverride) {
+    if (bundle.pose) {
+      next.pose = bundle.pose;
+    } else {
+      delete next.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") {
+    return `url:${glb.src}`;
+  }
+  if (glb.kind === "blob") {
+    return `blob:${glb.blob?.size ?? 0}`;
+  }
+  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) {
@@ -82,6 +202,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") {
@@ -93,13 +219,663 @@ 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
+var EPSILON = 1e-6;
+function toFiniteNumber(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function normaliseInterpolation(interpolation) {
+  const mode = typeof interpolation === "string" ? interpolation.trim().toLowerCase() : "linear";
+  if (mode === "step") {
+    return "step";
+  }
+  if (mode === "cubic" || mode === "cubicspline") {
+    return "cubic";
+  }
+  return "linear";
+}
+function asNumericKeyframe(keyframe) {
+  if (!keyframe || typeof keyframe !== "object") {
+    return null;
+  }
+  const time = Number(keyframe.time);
+  const value = Number(keyframe.value);
+  if (!Number.isFinite(time) || !Number.isFinite(value)) {
+    return null;
+  }
+  const inTangentRaw = keyframe.inTangent;
+  const outTangentRaw = keyframe.outTangent;
+  const inTangent = inTangentRaw == null || Number.isFinite(Number(inTangentRaw)) ? inTangentRaw : void 0;
+  const outTangent = outTangentRaw == null || Number.isFinite(Number(outTangentRaw)) ? outTangentRaw : void 0;
+  return {
+    time,
+    value,
+    inTangent,
+    outTangent
+  };
+}
+function getNumericKeyframes(track) {
+  const keyframes = Array.isArray(track.keyframes) ? track.keyframes : [];
+  const numeric = keyframes.map((keyframe) => asNumericKeyframe(keyframe)).filter((keyframe) => Boolean(keyframe));
+  if (numeric.length <= 1) {
+    return numeric;
+  }
+  return [...numeric].sort((a, b) => a.time - b.time);
+}
+function resolveTangent(value, fallback) {
+  const parsed = Number(value);
+  if (Number.isFinite(parsed)) {
+    return parsed;
+  }
+  return fallback;
+}
+function sampleHermite(startValue, endValue, outTangent, inTangent, factor, duration) {
+  const t = factor;
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const h00 = 2 * t3 - 3 * t2 + 1;
+  const h10 = t3 - 2 * t2 + t;
+  const h01 = -2 * t3 + 3 * t2;
+  const h11 = t3 - t2;
+  return h00 * startValue + h10 * outTangent * duration + h01 * endValue + h11 * inTangent * duration;
+}
+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 keyframes = getNumericKeyframes(track);
+    const last = keyframes[keyframes.length - 1];
+    if (last && last.time > maxTime) {
+      maxTime = last.time;
+    }
+  });
+  return maxTime > 0 ? maxTime : fallback;
+}
+function clampAnimationTime(time, duration) {
+  if (!Number.isFinite(duration) || duration <= 0) {
+    return 0;
+  }
+  if (!Number.isFinite(time)) {
+    return 0;
+  }
+  if (time <= 0) {
+    return 0;
+  }
+  if (time >= duration) {
+    return duration;
+  }
+  return time;
+}
+function advanceClipTime(state, dt) {
+  const duration = Math.max(0, toFiniteNumber(state.duration, 0));
+  const speed = Number.isFinite(state.speed) && state.speed > 0 ? state.speed : 1;
+  const currentTime = clampAnimationTime(state.time, duration);
+  const delta = Number.isFinite(dt) && dt > 0 ? Math.max(0, dt) * speed : 0;
+  if (!state.playing || delta <= 0) {
+    return { time: currentTime, completed: false };
+  }
+  if (duration <= 0) {
+    return { time: 0, completed: true };
+  }
+  const nextTime = currentTime + delta;
+  if (state.loop) {
+    if (nextTime < duration) {
+      return { time: nextTime, completed: false };
+    }
+    const wrapped = (nextTime % duration + duration) % duration;
+    return { time: wrapped, completed: false };
+  }
+  if (nextTime >= duration - EPSILON) {
+    return { time: duration, completed: true };
+  }
+  return { time: nextTime, completed: false };
+}
+function sampleTrackAtTime(track, timeSeconds) {
+  const keyframes = getNumericKeyframes(track);
+  if (keyframes.length === 0) {
+    return 0;
+  }
+  if (keyframes.length === 1) {
+    return keyframes[0].value;
+  }
+  const mode = normaliseInterpolation(track.interpolation);
+  const time = Number.isFinite(timeSeconds) ? timeSeconds : 0;
+  const first = keyframes[0];
+  if (time <= first.time + EPSILON) {
+    return first.value;
+  }
+  const last = keyframes[keyframes.length - 1];
+  if (time >= last.time - EPSILON) {
+    return last.value;
+  }
+  for (let i = 0; i < keyframes.length - 1; i += 1) {
+    const current = keyframes[i];
+    const next = keyframes[i + 1];
+    const start = current.time;
+    const end = next.time;
+    const duration = end - start;
+    if (duration <= EPSILON) {
+      if (time <= end + EPSILON) {
+        return next.value;
+      }
+      continue;
+    }
+    if (Math.abs(time - end) <= EPSILON) {
+      return next.value;
+    }
+    if (time < end) {
+      const factor = (time - start) / duration;
+      if (mode === "step") {
+        return current.value;
+      }
+      if (mode === "cubic") {
+        const slope = (next.value - current.value) / duration;
+        const outTangent = resolveTangent(current.outTangent, slope);
+        const inTangent = resolveTangent(next.inTangent, slope);
+        return sampleHermite(
+          current.value,
+          next.value,
+          outTangent,
+          inTangent,
+          factor,
+          duration
+        );
+      }
+      return current.value + (next.value - current.value) * factor;
+    }
+  }
+  return last.value;
+}
+
+// src/utils/animationBridge.ts
+function resolveAnimationBridgeOutputPaths(channel, faceId, rigInputMap) {
+  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)
+  );
+}
+function sampleAnimationClipOutputValues(clip, timeSeconds, weight = 1, faceId, rigInputMap) {
+  const appliedWeight = Number.isFinite(weight) && weight >= 0 ? Number(weight) : 1;
+  const outputValues = /* @__PURE__ */ new Map();
+  const tracks = Array.isArray(clip.tracks) ? clip.tracks : [];
+  tracks.forEach((track) => {
+    const channel = typeof track.channel === "string" ? track.channel.trim() : "";
+    if (!channel) {
+      return;
+    }
+    const sampledValue = sampleTrackAtTime(
+      track,
+      timeSeconds
+    );
+    const weightedValue = sampledValue * appliedWeight;
+    resolveAnimationBridgeOutputPaths(channel, faceId, rigInputMap).forEach(
+      (path) => {
+        outputValues.set(path, (outputValues.get(path) ?? 0) + weightedValue);
+      }
+    );
+  });
+  return outputValues;
+}
+function diffAnimationAggregateValues(previousAggregate, nextAggregate, epsilon = 1e-6) {
+  const operations = [];
+  const changedPaths = /* @__PURE__ */ new Set();
+  previousAggregate.forEach((previousValue, path) => {
+    const nextValue = nextAggregate.get(path);
+    if (nextValue === void 0 || Math.abs(nextValue - previousValue) > epsilon) {
+      changedPaths.add(path);
+    }
+  });
+  nextAggregate.forEach((nextValue, path) => {
+    const previousValue = previousAggregate.get(path);
+    if (previousValue === void 0 || Math.abs(nextValue - previousValue) > epsilon) {
+      changedPaths.add(path);
+    }
+  });
+  changedPaths.forEach((path) => {
+    const nextValue = nextAggregate.get(path);
+    if (nextValue === void 0) {
+      operations.push({ kind: "clear", path });
+      return;
+    }
+    operations.push({ kind: "set", path, value: nextValue });
+  });
+  return operations;
+}
+
 // src/utils/valueConversion.ts
-var import_value_json = require("@vizij/value-json");
+import {
+  isNormalizedValue,
+  valueAsBool,
+  valueAsColorRgba,
+  valueAsNumber,
+  valueAsText,
+  valueAsTransform,
+  valueAsVector
+} from "@vizij/value-json";
 function numericArrayToRaw(arr) {
   const normalised = arr.map((entry) => Number(entry ?? 0));
   switch (normalised.length) {
@@ -151,20 +927,20 @@ function valueJSONToRaw(value) {
     ]);
     return Object.fromEntries(entries);
   }
-  if (!(0, import_value_json.isNormalizedValue)(value)) {
+  if (!isNormalizedValue(value)) {
     return void 0;
   }
   switch (value.type) {
     case "float": {
-      const num = (0, import_value_json.valueAsNumber)(value);
+      const num = valueAsNumber(value);
       return typeof num === "number" ? num : void 0;
     }
     case "bool": {
-      const boolVal = (0, import_value_json.valueAsBool)(value);
+      const boolVal = valueAsBool(value);
       return typeof boolVal === "boolean" ? boolVal : void 0;
     }
     case "text": {
-      const text = (0, import_value_json.valueAsText)(value);
+      const text = valueAsText(value);
       return typeof text === "string" ? text : void 0;
     }
     case "vec2":
@@ -172,11 +948,11 @@ function valueJSONToRaw(value) {
     case "vec4":
     case "quat":
     case "vector": {
-      const vec = (0, import_value_json.valueAsVector)(value);
+      const vec = valueAsVector(value);
       return vec ? numericArrayToRaw(vec) : void 0;
     }
     case "colorrgba": {
-      const color = (0, import_value_json.valueAsColorRgba)(value);
+      const color = valueAsColorRgba(value);
       if (!color) {
         return void 0;
       }
@@ -184,7 +960,7 @@ function valueJSONToRaw(value) {
       return { r, g, b, a };
     }
     case "transform": {
-      const transform = (0, import_value_json.valueAsTransform)(value);
+      const transform = valueAsTransform(value);
       if (!transform) {
         return void 0;
       }
@@ -214,12 +990,28 @@ function valueJSONToRaw(value) {
 }
 
 // src/VizijRuntimeProvider.tsx
-var import_jsx_runtime = require("react/jsx-runtime");
+import { jsx } from "react/jsx-runtime";
+var ACTIVE_GRACE_MS = 250;
+var VISIBLE_IDLE_FPS = 30;
+var HIDDEN_IDLE_FPS = 1;
 var DEFAULT_MERGE = {
   outputs: "add",
   intermediate: "add"
 };
 var DEFAULT_DURATION = 0.35;
+var POSE_CONTROL_BRIDGE_EPSILON = 1e-6;
+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,
@@ -236,12 +1028,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) {
@@ -252,34 +1051,295 @@ function normalisePath(path) {
 function normaliseBundleKind(kind) {
   return typeof kind === "string" ? kind.toLowerCase() : "";
 }
-function pickBundleGraph(bundle, preferredKinds) {
-  if (!bundle?.graphs || bundle.graphs.length === 0) {
-    return null;
+function addConstraintVariant(map, key, constraint) {
+  if (!key) return;
+  if (!map[key]) {
+    map[key] = constraint;
   }
-  const preferred = preferredKinds.map((kind) => kind.toLowerCase());
-  for (const entry of bundle.graphs) {
-    if (!entry || typeof entry !== "object") {
-      continue;
-    }
-    const kind = normaliseBundleKind(entry.kind);
-    if (preferred.includes(kind)) {
-      return entry;
-    }
+}
+function stripRigFacePrefix(path) {
+  const trimmed = path.startsWith("/") ? path.slice(1) : path;
+  const match = /^rig\/[^/]+\/(.+)$/.exec(trimmed);
+  if (match && match[1]) {
+    return match[1];
   }
-  if (bundle.graphs.length === 1) {
-    return bundle.graphs[0] ?? null;
+  if (trimmed.startsWith("rig/")) {
+    return trimmed.slice("rig/".length);
   }
-  return null;
+  return trimmed;
 }
-function convertBundleGraph(entry) {
-  if (!entry || !entry.id || !entry.spec) {
-    return null;
+function extractInputConstraints(spec, extraInputs, namespace) {
+  if (!spec || typeof spec !== "object") {
+    return {};
   }
-  return {
-    id: entry.id,
-    spec: entry.spec
-  };
-}
+  const inputs = [];
+  if (Array.isArray(extraInputs)) {
+    inputs.push(...extraInputs);
+  }
+  const entries = spec.metadata?.vizij?.inputs;
+  if (Array.isArray(entries)) {
+    entries.forEach((entry) => {
+      if (entry && typeof entry === "object") {
+        inputs.push(entry);
+      }
+    });
+  }
+  if (inputs.length === 0) {
+    return {};
+  }
+  const map = {};
+  inputs.forEach((entry) => {
+    const path = entry.path;
+    if (typeof path !== "string") return;
+    const namespaced = namespaceTypedPath(path, namespace);
+    const stripped = stripRigFacePrefix(path);
+    const strippedNamespaced = stripped ? namespaceTypedPath(stripped, namespace) : stripped;
+    const min = entry.range?.min;
+    const max = entry.range?.max;
+    const defaultValue = entry.defaultValue;
+    const constraint = {
+      ...Number.isFinite(Number(min)) ? { min: Number(min) } : {},
+      ...Number.isFinite(Number(max)) ? { max: Number(max) } : {},
+      ...Number.isFinite(Number(defaultValue)) ? { defaultValue: Number(defaultValue) } : {}
+    };
+    addConstraintVariant(map, namespaced, constraint);
+    addConstraintVariant(map, path, constraint);
+    if (stripped) {
+      addConstraintVariant(map, stripped, constraint);
+    }
+    if (strippedNamespaced) {
+      addConstraintVariant(map, strippedNamespaced, constraint);
+    }
+  });
+  return map;
+}
+function namespaceTypedPath(path, namespace) {
+  const trimmed = typeof path === "string" ? path.trim() : "";
+  if (!trimmed) {
+    return trimmed;
+  }
+  const prefix = `${namespace}/`;
+  if (trimmed.startsWith(prefix)) {
+    return trimmed;
+  }
+  if (trimmed.startsWith("debug/")) {
+    const rest = trimmed.slice("debug/".length);
+    const namespacedRest = namespaceTypedPath(rest, namespace);
+    return namespacedRest.startsWith("debug/") ? namespacedRest : `debug/${namespacedRest}`;
+  }
+  return `${prefix}${trimmed}`;
+}
+function stripNamespace(path, namespace) {
+  const prefix = `${namespace}/`;
+  if (path.startsWith(prefix)) {
+    return path.slice(prefix.length);
+  }
+  const debugPrefix = `debug/${prefix}`;
+  if (path.startsWith(debugPrefix)) {
+    return path.slice(debugPrefix.length);
+  }
+  if (path.startsWith("debug/")) {
+    return path.slice("debug/".length);
+  }
+  return path;
+}
+function namespaceControllerId(id, namespace, kind = "graph") {
+  if (!id) {
+    return void 0;
+  }
+  const trimmed = id.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const prefix = `${namespace}/${kind}/`;
+  if (trimmed.startsWith(prefix)) {
+    return trimmed;
+  }
+  return `${prefix}${trimmed}`;
+}
+function namespaceSubscriptions(subs, namespace) {
+  if (!subs) {
+    return void 0;
+  }
+  const inputs = Array.isArray(subs.inputs) ? subs.inputs.map((path) => namespaceTypedPath(path, namespace)) : void 0;
+  const outputs = Array.isArray(subs.outputs) ? subs.outputs.map((path) => namespaceTypedPath(path, namespace)) : void 0;
+  if (!inputs && !outputs) {
+    return subs;
+  }
+  return {
+    ...subs,
+    ...inputs ? { inputs } : {},
+    ...outputs ? { outputs } : {}
+  };
+}
+function namespaceGraphSpec(spec, namespace) {
+  if (!spec || typeof spec !== "object") {
+    return spec;
+  }
+  const nodes = spec.nodes;
+  if (!Array.isArray(nodes)) {
+    return spec;
+  }
+  let changed = false;
+  const nextNodes = nodes.map((node) => {
+    if (!node || typeof node !== "object") {
+      return node;
+    }
+    const path = node.params?.path;
+    if (typeof path !== "string") {
+      return node;
+    }
+    const namespacedPath = namespaceTypedPath(path, namespace);
+    if (namespacedPath === path) {
+      return node;
+    }
+    changed = true;
+    return {
+      ...node,
+      params: {
+        ...node.params ?? {},
+        path: namespacedPath
+      }
+    };
+  });
+  if (!changed) {
+    return spec;
+  }
+  return {
+    ...spec,
+    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) {
+    return null;
+  }
+  const preferred = preferredKinds.map((kind) => kind.toLowerCase());
+  for (const entry of bundle.graphs) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const kind = normaliseBundleKind(entry.kind);
+    if (preferred.includes(kind)) {
+      return entry;
+    }
+  }
+  if (bundle.graphs.length === 1) {
+    return bundle.graphs[0] ?? null;
+  }
+  return null;
+}
+function extractIrGraph(payload) {
+  if (!payload || typeof payload !== "object") {
+    return void 0;
+  }
+  return payload;
+}
+function convertBundleGraph(entry) {
+  if (!entry || !entry.id) {
+    return null;
+  }
+  const rawSpec = entry.spec;
+  const inputMetadata = extractVizijInputMetadata(
+    rawSpec
+  );
+  const spec = rawSpec ? stripVizijMetadata(rawSpec) : void 0;
+  const ir = extractIrGraph(entry.ir);
+  if (!spec && !ir) {
+    return null;
+  }
+  return {
+    id: entry.id,
+    spec,
+    ir: ir ?? null,
+    inputMetadata
+  };
+}
+function resolveGraphSpec(asset, context) {
+  if (asset.spec) {
+    return stripVizijMetadata(asset.spec);
+  }
+  if (asset.ir) {
+    try {
+      const compiled = compileIrGraph(asset.ir, { preferLegacySpec: false });
+      if (compiled.issues && compiled.issues.length > 0) {
+        console.warn(
+          `[vizij-runtime] IR compile for graph "${context}" reported issues`,
+          compiled.issues
+        );
+      }
+      return stripVizijMetadata(compiled.spec);
+    } catch (error) {
+      console.warn(
+        `[vizij-runtime] Failed to compile IR graph "${context}"`,
+        error
+      );
+    }
+  }
+  return null;
+}
+function stripVizijMetadata(spec) {
+  if (!spec || typeof spec !== "object") {
+    return spec;
+  }
+  const cloned = {
+    ...spec,
+    nodes: spec.nodes ? spec.nodes.map((node) => ({ ...node })) : spec.nodes,
+    edges: spec.edges ? spec.edges.map((edge) => ({ ...edge })) : spec.edges
+  };
+  if (cloned.metadata && typeof cloned.metadata === "object") {
+    const metadata = { ...cloned.metadata };
+    if ("vizij" in metadata) {
+      delete metadata.vizij;
+    }
+    if (Object.keys(metadata).length === 0) {
+      delete cloned.metadata;
+    } else {
+      cloned.metadata = metadata;
+    }
+  }
+  return cloned;
+}
+function extractVizijInputMetadata(spec) {
+  if (!spec || typeof spec !== "object") {
+    return [];
+  }
+  const inputs = spec.metadata?.vizij?.inputs;
+  if (!Array.isArray(inputs)) {
+    return [];
+  }
+  return inputs.map((entry) => {
+    if (!entry || typeof entry !== "object") {
+      return null;
+    }
+    return entry;
+  }).filter(Boolean);
+}
 function convertBundleAnimations(entries) {
   if (!Array.isArray(entries) || entries.length === 0) {
     return [];
@@ -344,26 +1404,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) {
@@ -430,6 +1513,62 @@ 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 mergeProgramLists(explicit, fromBundle) {
+  if (!explicit?.length && fromBundle.length === 0) {
+    return void 0;
+  }
+  if (!explicit?.length) {
+    return fromBundle.length > 0 ? fromBundle : void 0;
+  }
+  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 rigFromBundle = convertBundleGraph(
@@ -437,12 +1576,18 @@ function mergeAssetBundle(base, extracted, extractedAnimations) {
   );
   const resolvedRig = 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 = 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) {
     const nextPose = { ...basePose };
@@ -481,6 +1626,10 @@ function mergeAssetBundle(base, extracted, extractedAnimations) {
       animationsFromAsset
     );
   }
+  const programsFromBundle = mergeProgramLists(
+    base.programs,
+    convertBundlePrograms(resolvedBundle?.graphs)
+  );
   const merged = {
     ...base
   };
@@ -491,88 +1640,236 @@ 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,
   mergeStrategy,
   onRegisterControllers,
-  onStatusChange
+  onStatusChange,
+  transformOutputWrite,
+  orchestratorScope = "auto"
 }) {
-  const storeRef = (0, import_react2.useRef)();
+  const storeRef = useRef(null);
   if (!storeRef.current) {
-    storeRef.current = (0, import_render.createVizijStore)();
+    storeRef.current = createVizijStore();
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_render.VizijContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-    import_orchestrator_react.OrchestratorProvider,
+  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(
+    VizijRuntimeProviderInner,
     {
+      assetBundle,
+      namespace: namespaceProp,
+      faceId: faceIdProp,
+      updateTier,
       autoCreate,
-      createOptions,
       autostart,
-      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
-        VizijRuntimeProviderInner,
-        {
-          assetBundle,
-          namespace: namespaceProp,
-          faceId: faceIdProp,
-          autoCreate,
-          mergeStrategy,
-          onRegisterControllers,
-          onStatusChange,
-          store: storeRef.current,
-          children
-        }
-      )
+      driveOrchestrator,
+      createOptions,
+      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
+  autoCreate,
+  autostart,
+  createOptions,
+  driveOrchestrator
 }) {
-  const [extractedBundle, setExtractedBundle] = (0, import_react2.useState)(() => {
-    if (initialAssetBundle.bundle) {
-      return initialAssetBundle.bundle;
+  const [assetBundleOverride, setAssetBundleOverride] = useState(null);
+  const [graphUpdateToken, setGraphUpdateToken] = useState(0);
+  const effectiveAssetBundle = assetBundleOverride ?? initialAssetBundle;
+  const latestEffectiveAssetBundleRef = useRef(effectiveAssetBundle);
+  const [extractedBundle, setExtractedBundle] = useState(() => {
+    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] = (0, import_react2.useState)([]);
-  (0, import_react2.useEffect)(() => {
-    if (initialAssetBundle.bundle) {
-      setExtractedBundle(initialAssetBundle.bundle);
+  const [extractedAnimations, setExtractedAnimations] = useState([]);
+  const previousBundleRef = useRef(null);
+  const suppressNextBundlePlanRef = useRef(false);
+  const pendingPlanRef = useRef(null);
+  const updateTierRef = useRef(updateTier);
+  useEffect(() => {
+    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]);
-  const assetBundle = (0, import_react2.useMemo)(
+  }, [effectiveAssetBundle]);
+  useEffect(() => {
+    updateTierRef.current = updateTier;
+  }, [updateTier]);
+  const assetBundle = useMemo(
     () => mergeAssetBundle(
-      initialAssetBundle,
+      effectiveAssetBundle,
       extractedBundle,
       extractedAnimations
     ),
-    [initialAssetBundle, extractedBundle, extractedAnimations]
+    [effectiveAssetBundle, extractedBundle, extractedAnimations]
   );
+  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 {
     ready,
     createOrchestrator,
@@ -581,15 +1878,16 @@ function VizijRuntimeProviderInner({
     registerAnimation,
     removeGraph,
     removeAnimation,
+    removeInput,
     listControllers,
-    setInput,
+    setInput: orchestratorSetInput,
     getPathSnapshot,
     step: stepRuntime
-  } = (0, import_orchestrator_react.useOrchestrator)();
-  const frame = (0, import_orchestrator_react.useOrchFrame)();
+  } = useOrchestrator();
+  const frame = useOrchFrame();
   const namespace = namespaceProp ?? assetBundle.namespace ?? "default";
   const faceId = faceIdProp ?? assetBundle.faceId ?? assetBundle.pose?.config?.faceId ?? assetBundle.pose?.config?.faceId ?? void 0;
-  const [status, setStatus] = (0, import_react2.useState)({
+  const [status, setStatus] = useState({
     loading: true,
     ready: false,
     error: null,
@@ -598,19 +1896,196 @@ function VizijRuntimeProviderInner({
     faceId,
     rootId: null,
     outputPaths: [],
+    stepHz: void 0,
     controllers: { graphs: [], anims: [] }
   });
-  const errorsRef = (0, import_react2.useRef)([]);
-  const outputPathsRef = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
-  const rigInputMapRef = (0, import_react2.useRef)({});
-  const registeredGraphsRef = (0, import_react2.useRef)([]);
-  const registeredAnimationsRef = (0, import_react2.useRef)([]);
-  const mergedGraphRef = (0, import_react2.useRef)(null);
-  const animationTweensRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
-  const clipPlaybackRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
-  const rafHandleRef = (0, import_react2.useRef)(null);
-  const lastFrameTimeRef = (0, import_react2.useRef)(null);
-  const reportStatus = (0, import_react2.useCallback)(
+  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 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 animationTweensRef = useRef(/* @__PURE__ */ new Map());
+  const clipPlaybackRef = useRef(/* @__PURE__ */ new Map());
+  const programPlaybackRef = useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const programControllerIdsRef = useRef(/* @__PURE__ */ new Map());
+  const clipOutputValuesRef = useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const clipAggregateValuesRef = useRef(/* @__PURE__ */ new Map());
+  const animationSystemActiveRef = useRef(true);
+  const stagedInputsRef = useRef(/* @__PURE__ */ new Map());
+  const autostartRef = useRef(autostart);
+  const lastActivityTimeRef = useRef(now());
+  const [loopMode, setLoopMode] = useState("stopped");
+  const loopModeRef = useRef("stopped");
+  useEffect(() => {
+    loopModeRef.current = loopMode;
+  }, [loopMode]);
+  const runtimeMountedRef = useRef(true);
+  useEffect(() => {
+    return () => {
+      runtimeMountedRef.current = false;
+    };
+  }, []);
+  useEffect(() => {
+    const rigAsset = assetBundle.rig;
+    if (!rigAsset) {
+      inputConstraintsRef.current = {};
+      setInputConstraints({});
+      return;
+    }
+    const rigSpec = resolveGraphSpec(
+      rigAsset,
+      `${rigAsset.id ?? "rig"} graph (constraints)`
+    );
+    const constraints = extractInputConstraints(
+      rigSpec,
+      rigAsset.inputMetadata,
+      namespace
+    );
+    inputConstraintsRef.current = constraints;
+    setInputConstraints(constraints);
+  }, [assetBundle.rig, namespace]);
+  const requestLoopMode = useCallback((mode) => {
+    if (!runtimeMountedRef.current) {
+      return;
+    }
+    setLoopMode((prev) => prev === mode ? prev : mode);
+  }, []);
+  const hasActiveAnimations = useCallback(() => {
+    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();
+    const recentlyActive = now() - lastActivityTimeRef.current <= ACTIVE_GRACE_MS;
+    if (autostartRef.current && (hasAnimations || recentlyActive)) {
+      return "active";
+    }
+    if (autostartRef.current) {
+      return "idle-visible";
+    }
+    return "idle-hidden";
+  }, [hasActiveAnimations]);
+  const updateLoopMode = useCallback(() => {
+    requestLoopMode(computeDesiredLoopMode());
+  }, [computeDesiredLoopMode, requestLoopMode]);
+  const markActivity = useCallback(() => {
+    lastActivityTimeRef.current = now();
+    updateLoopMode();
+  }, [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 });
+    },
+    [
+      assetBundle.pose?.config?.faceId,
+      faceId,
+      markActivity,
+      poseWeightFallbackMap,
+      useLegacyPoseWeightFallback
+    ]
+  );
+  const reportStatus = useCallback(
     (updater) => {
       setStatus((prev) => {
         const next = updater(prev);
@@ -620,7 +2095,7 @@ function VizijRuntimeProviderInner({
     },
     [onStatusChange]
   );
-  const pushError = (0, import_react2.useCallback)(
+  const pushError = useCallback(
     (error) => {
       errorsRef.current = [...errorsRef.current, error];
       reportStatus((prev) => ({
@@ -632,7 +2107,7 @@ function VizijRuntimeProviderInner({
     },
     [reportStatus]
   );
-  const resetErrors = (0, import_react2.useCallback)(() => {
+  const resetErrors = useCallback(() => {
     errorsRef.current = [];
     reportStatus((prev) => ({
       ...prev,
@@ -640,7 +2115,11 @@ function VizijRuntimeProviderInner({
       errors: []
     }));
   }, [reportStatus]);
-  const clearControllers = (0, import_react2.useCallback)(() => {
+  useEffect(() => {
+    autostartRef.current = autostart;
+    updateLoopMode();
+  }, [autostart, updateLoopMode]);
+  const clearControllers = useCallback(() => {
     const existing = listControllers();
     existing.graphs.forEach((id) => {
       try {
@@ -668,19 +2147,39 @@ 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();
+    clipOutputValuesRef.current.clear();
+    clipAggregateValuesRef.current.clear();
   }, [listControllers, removeAnimation, removeGraph, pushError]);
-  (0, import_react2.useEffect)(() => {
+  useEffect(() => {
+    namespaceRef.current = namespace;
     reportStatus((prev) => ({
       ...prev,
       namespace,
       faceId
     }));
   }, [namespace, faceId, reportStatus]);
-  const glbAsset = initialAssetBundle.glb;
-  const baseBundle = initialAssetBundle.bundle ?? null;
-  (0, import_react2.useEffect)(() => {
+  useEffect(() => {
+    driveOrchestratorRef.current = driveOrchestrator;
+  }, [driveOrchestrator]);
+  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,
@@ -698,7 +2197,7 @@ function VizijRuntimeProviderInner({
         let bundle = baseBundle;
         let gltfAnimations;
         if (glbAsset.kind === "url") {
-          const loaded = await (0, import_render.loadGLTFWithBundle)(
+          const loaded = await loadGLTFWithBundle(
             glbAsset.src,
             [namespace],
             glbAsset.aggressiveImport ?? false,
@@ -709,7 +2208,7 @@ function VizijRuntimeProviderInner({
           bundle = loaded.bundle ?? bundle;
           gltfAnimations = pickExtractedAnimations(loaded);
         } else if (glbAsset.kind === "blob") {
-          const loaded = await (0, import_render.loadGLTFFromBlobWithBundle)(
+          const loaded = await loadGLTFFromBlobWithBundle(
             glbAsset.blob,
             [namespace],
             glbAsset.aggressiveImport ?? false,
@@ -732,6 +2231,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,
@@ -769,11 +2274,12 @@ function VizijRuntimeProviderInner({
     reportStatus,
     resetErrors,
     setExtractedBundle,
-    setExtractedAnimations
+    setExtractedAnimations,
+    status.rootId
   ]);
-  (0, import_react2.useEffect)(() => {
+  useEffect(() => {
     if (!ready && autoCreate) {
-      createOrchestrator().catch((err) => {
+      createOrchestrator(createOptions).catch((err) => {
         pushError({
           message: "Failed to create orchestrator runtime",
           cause: err,
@@ -782,50 +2288,145 @@ function VizijRuntimeProviderInner({
         });
       });
     }
-  }, [ready, autoCreate, createOrchestrator, pushError]);
-  const registerControllers = (0, import_react2.useCallback)(async () => {
-    const normalize = (spec) => spec;
+  }, [ready, autoCreate, createOptions, createOrchestrator, pushError]);
+  const registerControllers = useCallback(async () => {
     clearControllers();
-    const rigAsset = assetBundle.rig;
-    if (!rigAsset) {
-      pushError({
-        message: "Asset bundle is missing a rig graph.",
-        phase: "registration",
-        timestamp: performance.now()
+    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
       });
-      return;
     }
-    const rigSpec = normalize(rigAsset.spec);
-    const rigOutputs = collectOutputPaths(rigSpec);
-    const rigInputs = collectInputPaths(rigSpec);
-    rigInputMapRef.current = collectInputPathMap(rigSpec);
-    outputPathsRef.current = new Set(rigOutputs);
-    const rigConfig = {
-      id: rigAsset.id,
-      spec: rigSpec,
-      subs: rigAsset.subscriptions ?? {
-        inputs: rigInputs,
-        outputs: rigOutputs
-      }
-    };
-    const graphConfigs = [rigConfig];
-    if (assetBundle.pose?.graph) {
-      const poseSpec = normalize(assetBundle.pose.graph.spec);
-      const poseOutputs = collectOutputPaths(poseSpec);
-      const poseInputs = collectInputPaths(poseSpec);
-      graphConfigs.push({
-        id: assetBundle.pose.graph.id,
-        spec: poseSpec,
-        subs: assetBundle.pose.graph.subscriptions ?? {
-          inputs: poseInputs,
-          outputs: poseOutputs
-        }
+    const baseOutputPaths = /* @__PURE__ */ new Set();
+    const namespacedOutputPaths = /* @__PURE__ */ new Set();
+    const recordOutputs = (paths) => {
+      paths.forEach((path) => {
+        const trimmed = path.trim();
+        if (!trimmed) return;
+        const basePath = stripNamespace(trimmed, namespace);
+        baseOutputPaths.add(basePath);
+        namespacedOutputPaths.add(namespaceTypedPath(trimmed, namespace));
       });
-    }
-    const graphIds = [];
-    try {
-      if (graphConfigs.length > 1) {
-        const mergedId = registerMergedGraph({
+    };
+    const graphConfigs = [];
+    rigInputMapRef.current = {};
+    rigPoseControlInputIdsRef.current = /* @__PURE__ */ new Set();
+    poseControlBridgeValuesRef.current.clear();
+    const rigAsset = assetBundle.rig;
+    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(
+        poseGraphAsset,
+        `${poseGraphAsset.id ?? "pose"} graph`
+      );
+      if (poseSpec) {
+        const poseOutputs = collectOutputPaths(poseSpec);
+        const poseInputs = collectInputPaths(poseSpec);
+        recordOutputs(poseOutputs);
+        const poseSubs = poseGraphAsset.subscriptions ?? {
+          inputs: poseInputs,
+          outputs: poseOutputs
+        };
+        graphConfigs.push({
+          id: namespaceControllerId(poseGraphAsset.id, namespace, "graph"),
+          spec: stripNulls(namespaceGraphSpec(poseSpec, namespace)),
+          subs: namespaceSubscriptions(poseSubs, namespace)
+        });
+      } else {
+        console.warn(
+          "[vizij-runtime] Pose graph is missing a usable spec or IR payload; skipping registration."
+        );
+      }
+    }
+    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;
+    const graphIds = [];
+    try {
+      if (graphConfigs.length > 1) {
+        const mergedId = registerMergedGraph({
+          id: namespaceControllerId(
+            mergedGraphRef.current ?? `merged-${namespace}`,
+            namespace,
+            "merged"
+          ) ?? void 0,
           graphs: graphConfigs,
           strategy: mergeStrategy ?? DEFAULT_MERGE
         });
@@ -846,19 +2447,30 @@ function VizijRuntimeProviderInner({
       });
     }
     registeredGraphsRef.current = graphIds;
+    if (isRuntimeDebugEnabled()) {
+      console.log("[vizij-runtime] registered graph ids", graphIds);
+    }
     const animationIds = [];
     for (const anim of assetBundle.animations ?? []) {
       try {
+        const controllerId = namespaceControllerId(anim.id, namespace, "animation") ?? anim.id;
+        const animationPayload = anim.setup?.animation ?? toStoredAnimationClip(anim.id, anim.clip);
         const config = {
-          id: anim.id,
+          id: controllerId,
           setup: {
-            animation: anim.clip,
-            ...anim.setup ?? {}
+            ...anim.setup ?? {},
+            animation: animationPayload
           }
         };
         const id = registerAnimation(config);
         animationIds.push(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,
@@ -883,6 +2495,13 @@ function VizijRuntimeProviderInner({
       });
     }
     const controllers = listControllers();
+    if (isRuntimeDebugEnabled()) {
+      console.log("[vizij-runtime] controllers after register", {
+        controllers,
+        graphIds,
+        animationIds
+      });
+    }
     reportStatus((prev) => ({
       ...prev,
       ready: true,
@@ -895,18 +2514,25 @@ function VizijRuntimeProviderInner({
     clearControllers,
     listControllers,
     mergeStrategy,
+    namespace,
     onRegisterControllers,
     pushError,
     registerAnimation,
     registerGraph,
     registerMergedGraph,
     reportStatus,
+    resolvedProgramAssets,
     setInput
   ]);
-  (0, import_react2.useEffect)(() => {
+  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",
@@ -915,8 +2541,8 @@ function VizijRuntimeProviderInner({
         timestamp: performance.now()
       });
     });
-  }, [ready, status.loading, registerControllers, pushError]);
-  (0, import_react2.useEffect)(() => {
+  }, [ready, status.loading, graphUpdateToken, registerControllers, pushError]);
+  useEffect(() => {
     if (!frame) {
       return;
     }
@@ -924,21 +2550,69 @@ function VizijRuntimeProviderInner({
     if (!writes.length) {
       return;
     }
-    const setWorldValue = store.getState().setValue;
+    const setWorldValues = store.getState().setValues;
     const namespaceValue = status.namespace;
+    const currentValues = store.getState().values;
+    const rigInputPathMap = rigInputMapRef.current;
+    const rigPoseControlInputIds = rigPoseControlInputIdsRef.current;
+    const batched = [];
+    const namespacedOutputs = namespacedOutputPathsRef.current;
+    const baseOutputs = baseOutputPathsRef.current;
     writes.forEach((write) => {
       const path = normalisePath(write.path);
-      if (!outputPathsRef.current.has(path)) {
+      const basePath = stripNamespace(path, namespaceValue);
+      const isTrackedOutput = namespacedOutputs.has(path) || baseOutputs.has(basePath);
+      if (!isTrackedOutput) {
         return;
       }
       const raw = valueJSONToRaw(write.value);
       if (raw === void 0) {
         return;
       }
-      setWorldValue(path, namespaceValue, raw);
+      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);
+      }
     });
-  }, [frame, status.namespace, store]);
-  const stagePoseNeutral = (0, import_react2.useCallback)(
+    if (batched.length > 0) {
+      setWorldValues(batched);
+    }
+  }, [frame, status.namespace, store, transformOutputWrite]);
+  const stagePoseNeutral = useCallback(
     (force = false) => {
       const neutral = assetBundle.pose?.config?.neutralInputs ?? {};
       const rigMap = rigInputMapRef.current;
@@ -970,41 +2644,20 @@ function VizijRuntimeProviderInner({
     },
     [assetBundle.pose?.config?.neutralInputs, setInput]
   );
-  const setRendererValue = (0, import_react2.useCallback)(
+  const setRendererValue = useCallback(
     (id, ns, value) => {
       store.getState().setValue(id, ns, value);
     },
     [store]
   );
-  const cancelAnimation = (0, import_react2.useCallback)((path) => {
+  const cancelAnimation = useCallback((path) => {
     if (animationTweensRef.current.has(path)) {
       const entry = animationTweensRef.current.get(path);
       animationTweensRef.current.delete(path);
       entry?.resolve();
     }
   }, []);
-  const scheduleLoop = (0, import_react2.useCallback)(() => {
-    if (rafHandleRef.current !== null) {
-      return;
-    }
-    const tick = (timestamp) => {
-      if (lastFrameTimeRef.current == null) {
-        lastFrameTimeRef.current = timestamp;
-      }
-      const dt = Math.max(0, (timestamp - lastFrameTimeRef.current) / 1e3);
-      lastFrameTimeRef.current = timestamp;
-      advanceAnimationTweens(dt);
-      advanceClipPlayback(dt);
-      if (animationTweensRef.current.size > 0 || clipPlaybackRef.current.size > 0) {
-        rafHandleRef.current = requestAnimationFrame(tick);
-      } else {
-        rafHandleRef.current = null;
-        lastFrameTimeRef.current = null;
-      }
-    };
-    rafHandleRef.current = requestAnimationFrame(tick);
-  }, []);
-  const advanceAnimationTweens = (0, import_react2.useCallback)(
+  const advanceAnimationTweens = useCallback(
     (dt) => {
       if (animationTweensRef.current.size === 0) {
         return;
@@ -1026,100 +2679,252 @@ function VizijRuntimeProviderInner({
     },
     [setInput]
   );
-  const sampleTrack = (0, import_react2.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 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 setAnimationInput = useCallback(
+    (path, value, options) => {
+      setInput(path, { float: value });
+      if (!options?.immediate) {
+        return;
+      }
+      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
+      const staged = stagedInputsRef.current.get(namespacedPath);
+      if (staged) {
+        orchestratorSetInput(namespacedPath, staged.value, staged.shape);
+        stagedInputsRef.current.delete(namespacedPath);
+        return;
+      }
+      orchestratorSetInput(namespacedPath, { float: value });
+    },
+    [orchestratorSetInput, setInput]
+  );
+  const clearAnimationInput = useCallback(
+    (path) => {
+      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
+      stagedInputsRef.current.delete(namespacedPath);
+      removeInput(namespacedPath);
+    },
+    [removeInput]
+  );
+  const buildClipOutputValues = useCallback(
+    (clip, state) => sampleAnimationClipOutputValues(
+      clip.clip,
+      state.time,
+      state.weight,
+      faceId ?? void 0,
+      rigInputMapRef.current
+    ),
+    [faceId]
+  );
+  const computeClipAggregateValues = useCallback(() => {
+    const aggregate = /* @__PURE__ */ new Map();
+    clipOutputValuesRef.current.forEach((outputValues) => {
+      outputValues.forEach((value, path) => {
+        aggregate.set(path, (aggregate.get(path) ?? 0) + value);
+      });
+    });
+    return aggregate;
+  }, []);
+  const stageClipAggregateValues = useCallback(
+    (nextAggregate, options) => {
+      diffAnimationAggregateValues(
+        clipAggregateValuesRef.current,
+        nextAggregate,
+        POSE_CONTROL_BRIDGE_EPSILON
+      ).forEach((operation) => {
+        if (operation.kind === "clear") {
+          clearAnimationInput(operation.path);
+          return;
         }
+        setAnimationInput(operation.path, operation.value, options);
+      });
+      clipAggregateValuesRef.current = nextAggregate;
+    },
+    [clearAnimationInput, setAnimationInput]
+  );
+  const syncClipOutputs = useCallback(
+    (options) => {
+      stageClipAggregateValues(computeClipAggregateValues(), options);
+    },
+    [computeClipAggregateValues, stageClipAggregateValues]
+  );
+  const writeClipOutputs = useCallback(
+    (clip, state, options) => {
+      if (!animationSystemActiveRef.current) {
+        return;
+      }
+      clipOutputValuesRef.current.set(
+        clip.id,
+        buildClipOutputValues(clip, state)
+      );
+      syncClipOutputs(options);
+    },
+    [buildClipOutputValues, syncClipOutputs]
+  );
+  const clearClipOutputs = useCallback(
+    (clipId, options) => {
+      if (!clipOutputValuesRef.current.has(clipId)) {
+        return;
       }
-      const last = keyframes[keyframes.length - 1];
-      return Number(last?.value ?? 0);
+      clipOutputValuesRef.current.delete(clipId);
+      syncClipOutputs(options);
+    },
+    [syncClipOutputs]
+  );
+  const createClipPlaybackState = useCallback(
+    (clip) => {
+      const duration = resolveClipDurationSeconds(
+        clip.clip
+      );
+      return {
+        id: clip.id,
+        time: 0,
+        duration,
+        speed: 1,
+        weight: Number.isFinite(clip.weight) ? Number(clip.weight) : 1,
+        loop: false,
+        playing: false,
+        resolve: null,
+        completion: null
+      };
     },
     []
   );
-  const advanceClipPlayback = (0, import_react2.useCallback)(
+  const ensureClipPlaybackState = useCallback(
+    (id) => {
+      const clip = resolveClipById(id);
+      if (!clip) {
+        return null;
+      }
+      const existing = clipPlaybackRef.current.get(id);
+      if (existing) {
+        existing.duration = resolveClipDurationSeconds(
+          clip.clip,
+          existing.duration
+        );
+        existing.time = clampAnimationTime(existing.time, existing.duration);
+        return { clip, state: existing };
+      }
+      const next = createClipPlaybackState(clip);
+      clipPlaybackRef.current.set(id, next);
+      return { clip, state: next };
+    },
+    [createClipPlaybackState, resolveClipById]
+  );
+  const advanceClipPlayback = useCallback(
     (dt) => {
       if (clipPlaybackRef.current.size === 0) {
         return;
       }
-      const map = clipPlaybackRef.current;
       const toDelete = [];
-      map.forEach((state, key) => {
-        state.time += dt * state.speed;
-        const clip = assetBundle.animations?.find(
-          (anim) => anim.id === state.id
-        );
+      clipPlaybackRef.current.forEach((state, key) => {
+        const clip = resolveClipById(state.id);
         if (!clip) {
           toDelete.push(key);
-          state.resolve();
+          resolveClipPromise(state);
           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;
+        state.duration = resolveClipDurationSeconds(
+          clip.clip,
+          state.duration
+        );
+        const { time, completed } = advanceClipTime(
+          {
+            time: state.time,
+            duration: state.duration,
+            speed: state.speed,
+            loop: state.loop,
+            playing: state.playing
+          },
+          dt
+        );
+        state.time = clampAnimationTime(time, state.duration);
+        if (state.playing || completed) {
+          writeClipOutputs(clip, state);
         }
-        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 });
-        });
-        if (toDelete.includes(key)) {
-          state.resolve();
+        if (completed) {
+          toDelete.push(key);
+          resolveClipPromise(state);
         }
       });
       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 });
-          });
+        if (animationSystemActiveRef.current) {
+          clearClipOutputs(key);
         }
       });
     },
-    [assetBundle.animations, sampleTrack, setInput]
+    [clearClipOutputs, resolveClipById, resolveClipPromise, writeClipOutputs]
   );
-  const animateValue = (0, import_react2.useCallback)(
+  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 current = getPathSnapshot(path);
-      const fromValue = (0, import_value_json2.valueAsNumber)(current);
-      const toValue = (0, import_value_json2.valueAsNumber)(target);
+      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,
@@ -1128,59 +2933,382 @@ function VizijRuntimeProviderInner({
           easing,
           resolve
         });
-        scheduleLoop();
+        markActivity();
       });
     },
-    [cancelAnimation, getPathSnapshot, scheduleLoop, setInput]
+    [
+      assetBundle.pose?.config?.faceId,
+      cancelAnimation,
+      faceId,
+      getPathSnapshot,
+      markActivity,
+      poseWeightFallbackMap,
+      setInput,
+      useLegacyPoseWeightFallback
+    ]
   );
-  const playAnimation = (0, import_react2.useCallback)(
+  const playAnimation = useCallback(
     (id, options) => {
-      const clip = assetBundle.animations?.find((anim) => anim.id === id);
-      if (!clip) {
+      const ensured = ensureClipPlaybackState(id);
+      if (!ensured) {
         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 { clip, state } = ensured;
+      const shouldReset = options?.reset === true;
+      if (shouldReset) {
+        resolveClipPromise(state);
+        state.time = 0;
       }
-      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
-        });
-        scheduleLoop();
-      });
+      const speed = options?.speed ?? state.speed ?? 1;
+      const weight = options?.weight ?? state.weight ?? clip.weight ?? 1;
+      state.speed = Number.isFinite(speed) && speed > 0 ? speed : 1;
+      state.weight = Number.isFinite(weight) ? Number(weight) : 1;
+      state.duration = resolveClipDurationSeconds(
+        clip.clip,
+        state.duration
+      );
+      state.time = clampAnimationTime(state.time, state.duration);
+      state.playing = true;
+      const completion = ensureClipPromise(state);
+      clipPlaybackRef.current.set(id, state);
+      writeClipOutputs(clip, state);
+      markActivity();
+      return completion;
+    },
+    [
+      ensureClipPlaybackState,
+      ensureClipPromise,
+      markActivity,
+      resolveClipPromise,
+      writeClipOutputs
+    ]
+  );
+  const pauseAnimation = useCallback(
+    (id) => {
+      const state = clipPlaybackRef.current.get(id);
+      if (!state || !state.playing) {
+        return;
+      }
+      state.playing = false;
+      updateLoopMode();
+    },
+    [updateLoopMode]
+  );
+  const seekAnimation = useCallback(
+    (id, timeSeconds) => {
+      const ensured = ensureClipPlaybackState(id);
+      if (!ensured) {
+        return;
+      }
+      const { clip, state } = ensured;
+      state.time = clampAnimationTime(timeSeconds, state.duration);
+      clipPlaybackRef.current.set(id, state);
+      writeClipOutputs(clip, state, { immediate: true });
+    },
+    [ensureClipPlaybackState, writeClipOutputs]
+  );
+  const setAnimationLoop = useCallback(
+    (id, enabled) => {
+      const ensured = ensureClipPlaybackState(id);
+      if (!ensured) {
+        return;
+      }
+      ensured.state.loop = Boolean(enabled);
+      clipPlaybackRef.current.set(id, ensured.state);
+      updateLoopMode();
     },
-    [assetBundle.animations, scheduleLoop]
+    [ensureClipPlaybackState, updateLoopMode]
   );
-  const stopAnimation = (0, import_react2.useCallback)(
+  const getAnimationState = useCallback(
     (id) => {
-      const clip = assetBundle.animations?.find((anim) => anim.id === id);
+      const state = clipPlaybackRef.current.get(id);
+      if (!state) {
+        return null;
+      }
+      return {
+        time: state.time,
+        duration: state.duration,
+        playing: state.playing,
+        loop: state.loop,
+        speed: state.speed
+      };
+    },
+    []
+  );
+  const stopAnimation = useCallback(
+    (id, options) => {
       const state = clipPlaybackRef.current.get(id);
       if (state) {
         clipPlaybackRef.current.delete(id);
-        state.resolve();
+        state.playing = false;
+        resolveClipPromise(state);
       }
-      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 });
+      if (options?.clearOutputs !== false) {
+        clearClipOutputs(id);
+      }
+      updateLoopMode();
+    },
+    [clearClipOutputs, resolveClipPromise, updateLoopMode]
+  );
+  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 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 [];
+      }
+      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 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;
+      }
+      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;
+        }
+        try {
+          removeGraph(controllerId);
+        } catch (err) {
+          pushError({
+            message: `Failed to pause program ${id}`,
+            cause: err,
+            phase: "registration",
+            timestamp: performance.now()
+          });
+        }
+        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()
+        });
+        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) => {
+      if (!resolveProgramById(id)) {
+        throw new Error(
+          `Program ${id} is not part of the current asset bundle.`
+        );
+      }
+      programPlaybackRef.current.set(id, {
+        id,
+        state: "playing"
+      });
+      syncProgramPlaybackControllers();
+      markActivity();
+    },
+    [markActivity, resolveProgramById, syncProgramPlaybackControllers]
+  );
+  const pauseProgram = useCallback(
+    (id) => {
+      if (!resolveProgramById(id)) {
+        return;
+      }
+      programPlaybackRef.current.set(id, {
+        id,
+        state: "paused"
+      });
+      syncProgramPlaybackControllers();
+      updateLoopMode();
+    },
+    [resolveProgramById, syncProgramPlaybackControllers, updateLoopMode]
+  );
+  const stopProgram = useCallback(
+    (id, options) => {
+      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);
+      }
+      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, setInput]
+    [
+      deriveProgramResetValues,
+      pushError,
+      refreshControllerStatus,
+      removeGraph,
+      resolveProgramById,
+      setInput,
+      updateLoopMode
+    ]
   );
-  const registerInputDriver = (0, import_react2.useCallback)(
+  const getProgramState = useCallback(
+    (id) => {
+      const state = programPlaybackRef.current.get(id);
+      if (!state) {
+        return null;
+      }
+      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();
+    },
+    [updateLoopMode]
+  );
+  const isAnimationActive = useCallback(
+    () => animationSystemActiveRef.current,
+    []
+  );
+  const registerInputDriver = useCallback(
     (id, factory) => {
       const driver = factory({
         setInput,
@@ -1230,72 +3358,211 @@ function VizijRuntimeProviderInner({
     },
     [faceId, namespace, pushError, setInput, setRendererValue]
   );
-  const advanceAnimations = (0, import_react2.useCallback)(
+  const advanceAnimations = useCallback(
     (dt) => {
       advanceAnimationTweens(dt);
       advanceClipPlayback(dt);
     },
     [advanceAnimationTweens, advanceClipPlayback]
   );
-  const step = (0, import_react2.useCallback)(
-    (dt) => {
+  const flushStagedInputs = useCallback(() => {
+    if (stagedInputsRef.current.size === 0) {
+      return;
+    }
+    stagedInputsRef.current.forEach(({ value, shape }, path) => {
+      orchestratorSetInput(path, value, shape);
+    });
+    stagedInputsRef.current.clear();
+  }, [orchestratorSetInput]);
+  const step = useCallback(
+    (dt, opts) => {
+      if (dt > 0 && Number.isFinite(dt)) {
+        const prev = avgStepDtRef.current ?? dt;
+        const alpha = 0.1;
+        avgStepDtRef.current = prev * (1 - alpha) + dt * alpha;
+      }
       advanceAnimations(dt);
-      stepRuntime(dt);
+      flushStagedInputs();
+      if (driveOrchestratorRef.current || opts?.forceRuntime) {
+        stepRuntime(dt);
+      }
     },
-    [advanceAnimations, stepRuntime]
+    [advanceAnimations, flushStagedInputs, stepRuntime]
   );
-  (0, import_react2.useEffect)(() => {
+  useEffect(() => {
+    if (loopMode !== "active") {
+      return;
+    }
+    let rafId = null;
+    let lastTime = null;
+    const tick = (timestamp) => {
+      if (loopModeRef.current !== "active") {
+        return;
+      }
+      if (lastTime == null) {
+        lastTime = timestamp;
+      }
+      const dt = Math.max(0, (timestamp - lastTime) / 1e3);
+      lastTime = timestamp;
+      step(dt || 0);
+      requestLoopMode(computeDesiredLoopMode());
+      rafId = requestAnimationFrame(tick);
+    };
+    rafId = requestAnimationFrame(tick);
     return () => {
-      if (rafHandleRef.current !== null) {
-        cancelAnimationFrame(rafHandleRef.current);
-        rafHandleRef.current = null;
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+      }
+    };
+  }, [loopMode, computeDesiredLoopMode, requestLoopMode, step]);
+  useEffect(() => {
+    if (loopMode !== "idle-visible" && loopMode !== "idle-hidden") {
+      return;
+    }
+    if (typeof window === "undefined") {
+      return;
+    }
+    const fps = loopMode === "idle-visible" ? VISIBLE_IDLE_FPS : HIDDEN_IDLE_FPS;
+    if (fps <= 0) {
+      return;
+    }
+    let lastTime = now();
+    const interval = 1e3 / fps;
+    const tick = () => {
+      if (loopModeRef.current !== "idle-visible" && loopModeRef.current !== "idle-hidden") {
+        return;
       }
-      lastFrameTimeRef.current = null;
+      const current = now();
+      const dt = Math.max(0, (current - lastTime) / 1e3);
+      lastTime = current;
+      step(dt || 0);
+      requestLoopMode(computeDesiredLoopMode());
+    };
+    const intervalId = window.setInterval(tick, interval);
+    return () => {
+      window.clearInterval(intervalId);
+    };
+  }, [loopMode, computeDesiredLoopMode, requestLoopMode, step]);
+  useEffect(() => {
+    return () => {
       animationTweensRef.current.clear();
       clipPlaybackRef.current.clear();
+      programPlaybackRef.current.clear();
+      programControllerIdsRef.current.clear();
+      clipOutputValuesRef.current.clear();
+      clipAggregateValuesRef.current.clear();
     };
   }, []);
-  const contextValue = (0, import_react2.useMemo)(
+  useEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const id = window.setInterval(() => {
+      const avg = avgStepDtRef.current;
+      const stepHz = avg && Number.isFinite(avg) && avg > 0 ? 1 / avg : void 0;
+      reportStatus(
+        (prev) => prev.stepHz === stepHz ? prev : { ...prev, stepHz }
+      );
+    }, 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,
+      setGraphBundle,
       setValue: setRendererValue,
       stagePoseNeutral,
       animateValue,
       cancelAnimation,
       registerInputDriver,
       playAnimation,
+      pauseAnimation,
+      seekAnimation,
+      setAnimationLoop,
+      getAnimationState,
       stopAnimation,
+      playProgram,
+      pauseProgram,
+      stopProgram,
+      getProgramState,
+      setAnimationActive,
+      isAnimationActive,
       step,
-      advanceAnimations
+      advanceAnimations,
+      inputConstraints
     }),
     [
       status,
       assetBundle,
       setInput,
+      setGraphBundle,
       setRendererValue,
       stagePoseNeutral,
       animateValue,
       cancelAnimation,
       registerInputDriver,
       playAnimation,
+      pauseAnimation,
+      seekAnimation,
+      setAnimationLoop,
+      getAnimationState,
       stopAnimation,
+      playProgram,
+      pauseProgram,
+      stopProgram,
+      getProgramState,
+      setAnimationActive,
+      isAnimationActive,
       step,
-      advanceAnimations
+      advanceAnimations,
+      inputConstraints
     ]
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(VizijRuntimeContext.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ jsx(VizijRuntimeContext.Provider, { value: contextValue, children });
 }
 
 // src/VizijRuntimeFace.tsx
-var import_react4 = require("react");
-var import_render2 = require("@vizij/render");
+import { memo } from "react";
+import { Vizij } from "@vizij/render";
 
 // src/hooks/useVizijRuntime.ts
-var import_react3 = require("react");
+import { useContext as useContext2 } from "react";
 function useVizijRuntime() {
-  const ctx = (0, import_react3.useContext)(VizijRuntimeContext);
+  const ctx = useContext2(VizijRuntimeContext);
   if (!ctx) {
     throw new Error(
       "useVizijRuntime must be used within a VizijRuntimeProvider."
@@ -1305,7 +3572,7 @@ function useVizijRuntime() {
 }
 
 // src/VizijRuntimeFace.tsx
-var import_jsx_runtime2 = require("react/jsx-runtime");
+import { jsx as jsx2 } from "react/jsx-runtime";
 function VizijRuntimeFaceInner({
   namespaceOverride,
   ...props
@@ -1314,8 +3581,8 @@ function VizijRuntimeFaceInner({
   if (!rootId) {
     return null;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-    import_render2.Vizij,
+  return /* @__PURE__ */ jsx2(
+    Vizij,
     {
       ...props,
       rootId,
@@ -1323,17 +3590,25 @@ function VizijRuntimeFaceInner({
     }
   );
 }
-var VizijRuntimeFace = (0, import_react4.memo)(VizijRuntimeFaceInner);
+var VizijRuntimeFace = memo(VizijRuntimeFaceInner);
+
+// src/hooks/useOptionalVizijRuntime.ts
+import { useContext as useContext3 } from "react";
+function useOptionalVizijRuntime() {
+  return useContext3(VizijRuntimeContext);
+}
 
 // src/hooks/useVizijOutputs.ts
-var import_render3 = require("@vizij/render");
-var import_utils = require("@vizij/utils");
+import {
+  useVizijStore
+} from "@vizij/render";
+import { getLookup as getLookup2 } from "@vizij/utils";
 function useVizijOutputs(paths) {
   const { namespace } = useVizijRuntime();
-  return (0, import_render3.useVizijStore)((state) => {
+  return useVizijStore((state) => {
     const result = {};
     paths.forEach((path) => {
-      const lookup = (0, import_utils.getLookup)(namespace, path);
+      const lookup = getLookup2(namespace, path);
       result[path] = state.values.get(lookup);
     });
     return result;
@@ -1341,15 +3616,17 @@ function useVizijOutputs(paths) {
 }
 
 // src/hooks/useRigInput.ts
-var import_react5 = require("react");
-var import_render4 = require("@vizij/render");
-var import_utils2 = require("@vizij/utils");
+import { useCallback as useCallback2 } from "react";
+import {
+  useVizijStore as useVizijStore2
+} from "@vizij/render";
+import { getLookup as getLookup3 } from "@vizij/utils";
 function useRigInput(path) {
   const { namespace, setInput } = useVizijRuntime();
-  const value = (0, import_render4.useVizijStore)((state) => {
-    return state.values.get((0, import_utils2.getLookup)(namespace, path));
+  const value = useVizijStore2((state) => {
+    return state.values.get(getLookup3(namespace, path));
   });
-  const setter = (0, import_react5.useCallback)(
+  const setter = useCallback2(
     (next, shape) => {
       setInput(path, next, shape);
     },
@@ -1357,11 +3634,423 @@ function useRigInput(path) {
   );
   return [value, setter];
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+
+// 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
-});
+};