@vizij/runtime-react 0.0.14 → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,4077 @@
+"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, {
+  EMOTION_POSE_KEYS: () => EMOTION_POSE_KEYS,
+  EXPRESSIVE_EMOTION_POSE_KEYS: () => EXPRESSIVE_EMOTION_POSE_KEYS,
+  POSE_WEIGHT_INPUT_PATH_PREFIX: () => POSE_WEIGHT_INPUT_PATH_PREFIX,
+  VISEME_POSE_KEYS: () => VISEME_POSE_KEYS,
+  VizijRuntimeFace: () => VizijRuntimeFace,
+  VizijRuntimeProvider: () => VizijRuntimeProvider,
+  buildPoseWeightInputPathSegment: () => buildPoseWeightInputPathSegment,
+  buildPoseWeightPathMap: () => buildPoseWeightPathMap,
+  buildPoseWeightRelativePath: () => buildPoseWeightRelativePath,
+  buildRigInputPath: () => buildRigInputPath,
+  buildSemanticPoseWeightPathMap: () => buildSemanticPoseWeightPathMap,
+  filterPosesBySemanticKind: () => filterPosesBySemanticKind,
+  getPoseSemanticKey: () => getPoseSemanticKey,
+  mapNormalizedControlValue: () => mapNormalizedControlValue,
+  mapUnitControlValue: () => mapUnitControlValue,
+  normalizePoseSemanticKey: () => normalizePoseSemanticKey,
+  resolveFaceControls: () => resolveFaceControls,
+  resolvePoseMembership: () => resolvePoseMembership,
+  resolvePoseSemantics: () => resolvePoseSemantics,
+  resolveRuntimeUpdatePlan: () => resolveRuntimeUpdatePlan,
+  useOptionalVizijRuntime: () => useOptionalVizijRuntime,
+  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_node_graph_authoring = require("@vizij/node-graph-authoring");
+var import_value_json2 = require("@vizij/value-json");
+var import_utils = require("@vizij/utils");
+
+// src/context.ts
+var import_react = require("react");
+var VizijRuntimeContext = (0, import_react.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) {
+  if (!spec || typeof spec !== "object") {
+    return [];
+  }
+  const maybeNodes = spec.nodes;
+  if (!Array.isArray(maybeNodes)) {
+    return [];
+  }
+  return maybeNodes;
+}
+function collectOutputPaths(spec) {
+  const nodes = getNodes(spec);
+  const outputs = /* @__PURE__ */ new Set();
+  nodes.forEach((node) => {
+    if (typeof node !== "object" || !node) {
+      return;
+    }
+    if (String(node.type ?? "").toLowerCase() !== "output") {
+      return;
+    }
+    const path = node.params?.path;
+    if (typeof path === "string" && path.trim()) {
+      outputs.add(path.trim());
+    }
+  });
+  return Array.from(outputs);
+}
+function collectInputPaths(spec) {
+  const nodes = getNodes(spec);
+  const inputs = /* @__PURE__ */ new Set();
+  nodes.forEach((node) => {
+    if (String(node.type ?? "").toLowerCase() !== "input") {
+      return;
+    }
+    const path = node.params?.path;
+    if (typeof path === "string" && path.trim()) {
+      inputs.add(path.trim());
+    }
+  });
+  return Array.from(inputs);
+}
+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") {
+      return;
+    }
+    const path = node.params?.path;
+    if (typeof path !== "string" || !path.trim()) {
+      return;
+    }
+    const id = String(node.id ?? "");
+    const key = id.startsWith("input_") ? id.slice("input_".length) : id || 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");
+function numericArrayToRaw(arr) {
+  const normalised = arr.map((entry) => Number(entry ?? 0));
+  switch (normalised.length) {
+    case 2:
+      return {
+        x: normalised[0],
+        y: normalised[1],
+        r: normalised[0],
+        g: normalised[1]
+      };
+    case 3:
+      return {
+        x: normalised[0],
+        y: normalised[1],
+        z: normalised[2],
+        r: normalised[0],
+        g: normalised[1],
+        b: normalised[2]
+      };
+    case 4:
+      return {
+        x: normalised[0],
+        y: normalised[1],
+        z: normalised[2],
+        w: normalised[3],
+        r: normalised[0],
+        g: normalised[1],
+        b: normalised[2],
+        a: normalised[3]
+      };
+    default:
+      return normalised;
+  }
+}
+function valueJSONToRaw(value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => valueJSONToRaw(entry));
+  }
+  if (typeof value === "object" && !("type" in value)) {
+    const entries = Object.entries(value).map(([key, entry]) => [
+      key,
+      valueJSONToRaw(entry)
+    ]);
+    return Object.fromEntries(entries);
+  }
+  if (!(0, import_value_json.isNormalizedValue)(value)) {
+    return void 0;
+  }
+  switch (value.type) {
+    case "float": {
+      const num = (0, import_value_json.valueAsNumber)(value);
+      return typeof num === "number" ? num : void 0;
+    }
+    case "bool": {
+      const boolVal = (0, import_value_json.valueAsBool)(value);
+      return typeof boolVal === "boolean" ? boolVal : void 0;
+    }
+    case "text": {
+      const text = (0, import_value_json.valueAsText)(value);
+      return typeof text === "string" ? text : void 0;
+    }
+    case "vec2":
+    case "vec3":
+    case "vec4":
+    case "quat":
+    case "vector": {
+      const vec = (0, import_value_json.valueAsVector)(value);
+      return vec ? numericArrayToRaw(vec) : void 0;
+    }
+    case "colorrgba": {
+      const color = (0, import_value_json.valueAsColorRgba)(value);
+      if (!color) {
+        return void 0;
+      }
+      const [r = 0, g = 0, b = 0, a = 1] = color;
+      return { r, g, b, a };
+    }
+    case "transform": {
+      const transform = (0, import_value_json.valueAsTransform)(value);
+      if (!transform) {
+        return void 0;
+      }
+      return {
+        translation: numericArrayToRaw(transform.translation),
+        rotation: numericArrayToRaw(transform.rotation),
+        scale: numericArrayToRaw(transform.scale)
+      };
+    }
+    case "record": {
+      const entries = Object.entries(value.data ?? {}).map(([key, entry]) => [
+        key,
+        valueJSONToRaw(entry)
+      ]);
+      return Object.fromEntries(entries);
+    }
+    case "enum": {
+      const [tag, inner] = value.data;
+      return {
+        tag,
+        value: valueJSONToRaw(inner)
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+
+// src/VizijRuntimeProvider.tsx
+var import_jsx_runtime = require("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,
+  easeOut: (t) => 1 - (1 - t) * (1 - t),
+  easeInOut: (t) => t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2
+};
+function resolveEasing(easing) {
+  if (typeof easing === "function") {
+    return easing;
+  }
+  if (typeof easing === "string" && easing in EASINGS) {
+    return EASINGS[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") {
+      continue;
+    }
+    if (entry.rootBounds && entry.id) {
+      return entry.id;
+    }
+    if (!fallback && entry.id) {
+      fallback = entry.id;
+    }
+  }
+  return fallback;
+}
+function normalisePath(path) {
+  if (!path) {
+    return path;
+  }
+  return path.startsWith("debug/") ? path.slice("debug/".length) : path;
+}
+function normaliseBundleKind(kind) {
+  return typeof kind === "string" ? kind.toLowerCase() : "";
+}
+function addConstraintVariant(map, key, constraint) {
+  if (!key) return;
+  if (!map[key]) {
+    map[key] = constraint;
+  }
+}
+function stripRigFacePrefix(path) {
+  const trimmed = path.startsWith("/") ? path.slice(1) : path;
+  const match = /^rig\/[^/]+\/(.+)$/.exec(trimmed);
+  if (match && match[1]) {
+    return match[1];
+  }
+  if (trimmed.startsWith("rig/")) {
+    return trimmed.slice("rig/".length);
+  }
+  return trimmed;
+}
+function extractInputConstraints(spec, extraInputs, namespace) {
+  if (!spec || typeof spec !== "object") {
+    return {};
+  }
+  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 = (0, import_node_graph_authoring.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 [];
+  }
+  return entries.filter(
+    (entry) => Boolean(entry && typeof entry.id === "string" && entry.clip)
+  ).map((entry) => ({
+    id: entry.id,
+    clip: entry.clip
+  }));
+}
+function resolveChannelId(track) {
+  if (typeof track.componentId !== "string" || track.componentId.length === 0) {
+    return null;
+  }
+  if (typeof track.component === "string" && track.component.length > 0) {
+    return `${track.componentId}:${track.component}`;
+  }
+  const rawIndex = track.componentIndex != null ? Number(track.componentIndex) : void 0;
+  const valueSize = track.valueSize != null ? Number(track.valueSize) : void 0;
+  if (Number.isInteger(rawIndex) && Number.isFinite(rawIndex) && rawIndex >= 0 && Number.isFinite(valueSize) && valueSize > 1) {
+    return `${track.componentId}:${rawIndex}`;
+  }
+  return track.componentId;
+}
+function convertExtractedAnimations(clips) {
+  if (!Array.isArray(clips) || clips.length === 0) {
+    return [];
+  }
+  const assets = [];
+  clips.forEach((clip) => {
+    const clipTracks = Array.isArray(clip.tracks) ? clip.tracks : [];
+    if (clipTracks.length === 0) {
+      return;
+    }
+    const convertedTracks = [];
+    clipTracks.forEach((track) => {
+      const channelId = resolveChannelId(track);
+      if (!channelId) {
+        return;
+      }
+      const rawTimes = Array.isArray(track.times) ? track.times : [];
+      const rawValues = Array.isArray(track.values) ? track.values : [];
+      if (rawTimes.length === 0 || rawValues.length === 0) {
+        return;
+      }
+      const times = [];
+      for (const entry of rawTimes) {
+        const time = Number(entry);
+        if (!Number.isFinite(time)) {
+          return;
+        }
+        times.push(time);
+      }
+      const values = [];
+      for (const entry of rawValues) {
+        const value = Number(entry);
+        if (!Number.isFinite(value)) {
+          return;
+        }
+        values.push(value);
+      }
+      const parsedValueSize = track.valueSize != null ? Number(track.valueSize) : NaN;
+      const valueSize = Number.isFinite(parsedValueSize) && parsedValueSize > 0 ? parsedValueSize : 1;
+      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 flatBase = index * valueSize + componentIndex;
+        const valueBase = hasTripletTangents ? index * valueSize * 3 + valueSize + componentIndex : flatBase;
+        const value = values[valueBase];
+        if (!Number.isFinite(value)) {
+          return;
+        }
+        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,
+        interpolation
+      });
+    });
+    if (convertedTracks.length === 0) {
+      return;
+    }
+    const durationFromTracks = convertedTracks.reduce((maxTime, track) => {
+      const keyframes = Array.isArray(track.keyframes) ? track.keyframes : [];
+      if (keyframes.length === 0) {
+        return maxTime;
+      }
+      const lastKeyframe = keyframes[keyframes.length - 1];
+      const time = Number(lastKeyframe?.time ?? 0);
+      if (!Number.isFinite(time)) {
+        return maxTime;
+      }
+      return time > maxTime ? time : maxTime;
+    }, 0);
+    const duration = typeof clip.duration === "number" && Number.isFinite(clip.duration) ? clip.duration : durationFromTracks;
+    const clipId = typeof clip.id === "string" && clip.id.length > 0 ? clip.id : typeof clip.name === "string" && clip.name.length > 0 ? clip.name : `gltf-animation-${assets.length}`;
+    const metadata = clip.metadata && typeof clip.metadata === "object" && !Array.isArray(clip.metadata) ? clip.metadata : void 0;
+    assets.push({
+      id: clipId,
+      clip: {
+        id: clipId,
+        name: typeof clip.name === "string" ? clip.name : clipId,
+        duration,
+        tracks: convertedTracks,
+        metadata
+      }
+    });
+  });
+  return assets;
+}
+function pickExtractedAnimations(asset) {
+  if (!asset || typeof asset !== "object") {
+    return void 0;
+  }
+  const animations = asset.animations;
+  if (!Array.isArray(animations)) {
+    return void 0;
+  }
+  return animations;
+}
+function mergeAnimationLists(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((anim) => anim.id));
+  let changed = false;
+  const merged = [...explicit];
+  for (const anim of fromBundle) {
+    if (!anim.id || seen.has(anim.id)) {
+      continue;
+    }
+    merged.push(anim);
+    seen.add(anim.id);
+    changed = true;
+  }
+  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(
+    pickBundleGraph(resolvedBundle, ["rig"])
+  );
+  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 = hasBasePoseGraphOverride ? null : convertBundleGraph(
+    pickBundleGraph(resolvedBundle, ["pose-driver", "pose"])
+  );
+  const resolvedPoseGraph = hasBasePoseGraphOverride ? basePose?.graph : basePose?.graph ?? poseGraphFromBundle ?? void 0;
+  const resolvedPoseConfig = hasBasePoseConfigOverride ? basePose?.config : basePose?.config ?? resolvedBundle?.poses?.config ?? void 0;
+  let resolvedPose = basePose;
+  if (basePose) {
+    const nextPose = { ...basePose };
+    let changed = false;
+    if (resolvedPoseGraph && basePose.graph !== resolvedPoseGraph) {
+      nextPose.graph = resolvedPoseGraph;
+      changed = true;
+    }
+    if (resolvedPoseConfig && basePose.config !== resolvedPoseConfig) {
+      nextPose.config = resolvedPoseConfig;
+      changed = true;
+    }
+    if (!resolvedPoseGraph && !basePose.graph) {
+    }
+    if (!resolvedPoseConfig && !basePose.config) {
+    }
+    resolvedPose = changed ? nextPose : basePose;
+  } else if (resolvedPoseGraph || resolvedPoseConfig || typeof poseStageFilter === "function") {
+    resolvedPose = {
+      ...resolvedPoseGraph ? { graph: resolvedPoseGraph } : {},
+      ...resolvedPoseConfig ? { config: resolvedPoseConfig } : {},
+      ...typeof poseStageFilter === "function" ? { stageNeutralFilter: poseStageFilter } : {}
+    };
+  }
+  const animationsFromBundle = convertBundleAnimations(
+    resolvedBundle?.animations
+  );
+  let resolvedAnimations = mergeAnimationLists(
+    base.animations,
+    animationsFromBundle
+  );
+  const animationsFromAsset = extractedAnimations && extractedAnimations.length > 0 ? extractedAnimations : [];
+  if (animationsFromAsset.length > 0) {
+    resolvedAnimations = mergeAnimationLists(
+      resolvedAnimations,
+      animationsFromAsset
+    );
+  }
+  const programsFromBundle = mergeProgramLists(
+    base.programs,
+    convertBundlePrograms(resolvedBundle?.graphs)
+  );
+  const merged = {
+    ...base
+  };
+  if (resolvedRig) {
+    merged.rig = resolvedRig;
+  } else {
+    merged.rig = void 0;
+  }
+  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,
+  transformOutputWrite,
+  orchestratorScope = "auto"
+}) {
+  const storeRef = (0, import_react2.useRef)(null);
+  if (!storeRef.current) {
+    storeRef.current = (0, import_render.createVizijStore)();
+  }
+  const parentOrchestrator = (0, import_react2.useContext)(import_orchestrator_react.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__ */ (0, import_jsx_runtime.jsx)(import_render.VizijContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    VizijRuntimeProviderInner,
+    {
+      assetBundle,
+      namespace: namespaceProp,
+      faceId: faceIdProp,
+      updateTier,
+      autoCreate,
+      autostart,
+      driveOrchestrator,
+      createOptions,
+      mergeStrategy,
+      onRegisterControllers,
+      onStatusChange,
+      transformOutputWrite,
+      store: storeRef.current,
+      children
+    }
+  ) });
+  if (!shouldProvideOrchestrator) {
+    return runtimeTree;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_orchestrator_react.OrchestratorProvider,
+    {
+      autoCreate,
+      createOptions,
+      autostart: false,
+      children: runtimeTree
+    }
+  );
+}
+function VizijRuntimeProviderInner({
+  assetBundle: initialAssetBundle,
+  namespace: namespaceProp,
+  faceId: faceIdProp,
+  updateTier,
+  mergeStrategy,
+  onRegisterControllers,
+  onStatusChange,
+  transformOutputWrite,
+  store,
+  children,
+  autoCreate,
+  autostart,
+  createOptions,
+  driveOrchestrator
+}) {
+  const [assetBundleOverride, setAssetBundleOverride] = (0, import_react2.useState)(null);
+  const [graphUpdateToken, setGraphUpdateToken] = (0, import_react2.useState)(0);
+  const effectiveAssetBundle = assetBundleOverride ?? initialAssetBundle;
+  const latestEffectiveAssetBundleRef = (0, import_react2.useRef)(effectiveAssetBundle);
+  const [extractedBundle, setExtractedBundle] = (0, import_react2.useState)(() => {
+    if (effectiveAssetBundle.bundle) {
+      return effectiveAssetBundle.bundle;
+    }
+    if (effectiveAssetBundle.glb.kind === "world" && effectiveAssetBundle.glb.bundle) {
+      return effectiveAssetBundle.glb.bundle;
+    }
+    return null;
+  });
+  const [extractedAnimations, setExtractedAnimations] = (0, import_react2.useState)([]);
+  const previousBundleRef = (0, import_react2.useRef)(null);
+  const suppressNextBundlePlanRef = (0, import_react2.useRef)(false);
+  const pendingPlanRef = (0, import_react2.useRef)(null);
+  const updateTierRef = (0, import_react2.useRef)(updateTier);
+  (0, import_react2.useEffect)(() => {
+    if (effectiveAssetBundle.bundle) {
+      setExtractedBundle(effectiveAssetBundle.bundle);
+      return;
+    }
+    if (effectiveAssetBundle.glb.kind === "world") {
+      setExtractedBundle(effectiveAssetBundle.glb.bundle ?? null);
+    } else {
+      setExtractedBundle(null);
+    }
+  }, [effectiveAssetBundle]);
+  (0, import_react2.useEffect)(() => {
+    updateTierRef.current = updateTier;
+  }, [updateTier]);
+  const assetBundle = (0, import_react2.useMemo)(
+    () => mergeAssetBundle(
+      effectiveAssetBundle,
+      extractedBundle,
+      extractedAnimations
+    ),
+    [effectiveAssetBundle, extractedBundle, extractedAnimations]
+  );
+  (0, import_react2.useEffect)(() => {
+    latestEffectiveAssetBundleRef.current = effectiveAssetBundle;
+  }, [effectiveAssetBundle]);
+  (0, import_react2.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,
+    registerGraph,
+    registerMergedGraph,
+    registerAnimation,
+    removeGraph,
+    removeAnimation,
+    removeInput,
+    listControllers,
+    setInput: orchestratorSetInput,
+    getPathSnapshot,
+    step: stepRuntime
+  } = (0, import_orchestrator_react.useOrchestrator)();
+  const frame = (0, import_orchestrator_react.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)({
+    loading: true,
+    ready: false,
+    error: null,
+    errors: [],
+    namespace,
+    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 baseOutputPathsRef = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  const namespacedOutputPathsRef = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  const namespaceRef = (0, import_react2.useRef)(namespace);
+  const driveOrchestratorRef = (0, import_react2.useRef)(driveOrchestrator);
+  const rigInputMapRef = (0, import_react2.useRef)({});
+  const rigPoseControlInputIdsRef = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  const registeredGraphsRef = (0, import_react2.useRef)([]);
+  const registeredAnimationsRef = (0, import_react2.useRef)([]);
+  const mergedGraphRef = (0, import_react2.useRef)(null);
+  const poseControlBridgeValuesRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  const poseWeightFallbackMap = (0, import_react2.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 = (0, import_react2.useMemo)(
+    () => shouldUseLegacyPoseWeightFallback(Boolean(assetBundle.pose?.graph)),
+    [assetBundle.pose?.graph]
+  );
+  const resolvedProgramAssets = (0, import_react2.useMemo)(
+    () => assetBundle.programs && assetBundle.programs.length > 0 ? assetBundle.programs : convertBundlePrograms(assetBundle.bundle?.graphs),
+    [assetBundle.bundle?.graphs, assetBundle.programs]
+  );
+  const [inputConstraints, setInputConstraints] = (0, import_react2.useState)({});
+  const inputConstraintsRef = (0, import_react2.useRef)({});
+  const avgStepDtRef = (0, import_react2.useRef)(null);
+  const animationTweensRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  const clipPlaybackRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  const programPlaybackRef = (0, import_react2.useRef)(
+    /* @__PURE__ */ new Map()
+  );
+  const programControllerIdsRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  const clipOutputValuesRef = (0, import_react2.useRef)(
+    /* @__PURE__ */ new Map()
+  );
+  const clipAggregateValuesRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  const animationSystemActiveRef = (0, import_react2.useRef)(true);
+  const stagedInputsRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  const autostartRef = (0, import_react2.useRef)(autostart);
+  const lastActivityTimeRef = (0, import_react2.useRef)(now());
+  const [loopMode, setLoopMode] = (0, import_react2.useState)("stopped");
+  const loopModeRef = (0, import_react2.useRef)("stopped");
+  (0, import_react2.useEffect)(() => {
+    loopModeRef.current = loopMode;
+  }, [loopMode]);
+  const runtimeMountedRef = (0, import_react2.useRef)(true);
+  (0, import_react2.useEffect)(() => {
+    return () => {
+      runtimeMountedRef.current = false;
+    };
+  }, []);
+  (0, import_react2.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 = (0, import_react2.useCallback)((mode) => {
+    if (!runtimeMountedRef.current) {
+      return;
+    }
+    setLoopMode((prev) => prev === mode ? prev : mode);
+  }, []);
+  const hasActiveAnimations = (0, import_react2.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 = (0, import_react2.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 = (0, import_react2.useCallback)(() => {
+    requestLoopMode(computeDesiredLoopMode());
+  }, [computeDesiredLoopMode, requestLoopMode]);
+  const markActivity = (0, import_react2.useCallback)(() => {
+    lastActivityTimeRef.current = now();
+    updateLoopMode();
+  }, [updateLoopMode]);
+  const setInput = (0, import_react2.useCallback)(
+    (path, value, shape) => {
+      const numericValue = (0, import_value_json2.valueAsNumber)(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 = (0, import_react2.useCallback)(
+    (updater) => {
+      setStatus((prev) => {
+        const next = updater(prev);
+        onStatusChange?.(next);
+        return next;
+      });
+    },
+    [onStatusChange]
+  );
+  const pushError = (0, import_react2.useCallback)(
+    (error) => {
+      errorsRef.current = [...errorsRef.current, error];
+      reportStatus((prev) => ({
+        ...prev,
+        error,
+        errors: errorsRef.current
+      }));
+      console.warn("[vizij-runtime]", error.message, error.cause);
+    },
+    [reportStatus]
+  );
+  const resetErrors = (0, import_react2.useCallback)(() => {
+    errorsRef.current = [];
+    reportStatus((prev) => ({
+      ...prev,
+      error: null,
+      errors: []
+    }));
+  }, [reportStatus]);
+  (0, import_react2.useEffect)(() => {
+    autostartRef.current = autostart;
+    updateLoopMode();
+  }, [autostart, updateLoopMode]);
+  const clearControllers = (0, import_react2.useCallback)(() => {
+    const existing = listControllers();
+    existing.graphs.forEach((id) => {
+      try {
+        removeGraph(id);
+      } catch (err) {
+        pushError({
+          message: `Failed to remove graph ${id}`,
+          cause: err,
+          phase: "registration",
+          timestamp: performance.now()
+        });
+      }
+    });
+    existing.anims.forEach((id) => {
+      try {
+        removeAnimation(id);
+      } catch (err) {
+        pushError({
+          message: `Failed to remove animation ${id}`,
+          cause: err,
+          phase: "registration",
+          timestamp: performance.now()
+        });
+      }
+    });
+    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)(() => {
+    namespaceRef.current = namespace;
+    reportStatus((prev) => ({
+      ...prev,
+      namespace,
+      faceId
+    }));
+  }, [namespace, faceId, reportStatus]);
+  (0, import_react2.useEffect)(() => {
+    driveOrchestratorRef.current = driveOrchestrator;
+  }, [driveOrchestrator]);
+  const glbAsset = effectiveAssetBundle.glb;
+  const baseBundle = effectiveAssetBundle.bundle ?? null;
+  (0, import_react2.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,
+      loading: true,
+      rootId: null,
+      ready: false,
+      outputPaths: [],
+      controllers: { graphs: [], anims: [] }
+    }));
+    setExtractedAnimations([]);
+    const loadAssets = async () => {
+      try {
+        let world;
+        let animatables;
+        let bundle = baseBundle;
+        let gltfAnimations;
+        if (glbAsset.kind === "url") {
+          const loaded = await (0, import_render.loadGLTFWithBundle)(
+            glbAsset.src,
+            [namespace],
+            glbAsset.aggressiveImport ?? false,
+            glbAsset.rootBounds
+          );
+          world = loaded.world;
+          animatables = loaded.animatables;
+          bundle = loaded.bundle ?? bundle;
+          gltfAnimations = pickExtractedAnimations(loaded);
+        } else if (glbAsset.kind === "blob") {
+          const loaded = await (0, import_render.loadGLTFFromBlobWithBundle)(
+            glbAsset.blob,
+            [namespace],
+            glbAsset.aggressiveImport ?? false,
+            glbAsset.rootBounds
+          );
+          world = loaded.world;
+          animatables = loaded.animatables;
+          bundle = loaded.bundle ?? bundle;
+          gltfAnimations = pickExtractedAnimations(loaded);
+        } else {
+          world = glbAsset.world;
+          animatables = glbAsset.animatables;
+          bundle = glbAsset.bundle ?? bundle;
+          gltfAnimations = void 0;
+        }
+        if (cancelled) {
+          return;
+        }
+        setExtractedBundle(bundle ?? null);
+        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,
+          rootId,
+          namespace,
+          faceId
+        }));
+      } catch (err) {
+        if (cancelled) {
+          return;
+        }
+        pushError({
+          message: "Failed to load Vizij assets",
+          cause: err,
+          phase: "assets",
+          timestamp: performance.now()
+        });
+        reportStatus((prev) => ({
+          ...prev,
+          loading: false
+        }));
+      }
+    };
+    loadAssets();
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    glbAsset,
+    baseBundle,
+    namespace,
+    faceId,
+    store,
+    pushError,
+    reportStatus,
+    resetErrors,
+    setExtractedBundle,
+    setExtractedAnimations,
+    status.rootId
+  ]);
+  (0, import_react2.useEffect)(() => {
+    if (!ready && autoCreate) {
+      createOrchestrator(createOptions).catch((err) => {
+        pushError({
+          message: "Failed to create orchestrator runtime",
+          cause: err,
+          phase: "orchestrator",
+          timestamp: performance.now()
+        });
+      });
+    }
+  }, [ready, autoCreate, createOptions, createOrchestrator, pushError]);
+  const registerControllers = (0, import_react2.useCallback)(async () => {
+    clearControllers();
+    if (isRuntimeDebugEnabled()) {
+      console.log("[vizij-runtime] registerControllers", {
+        hasRig: Boolean(assetBundle.rig),
+        hasPose: Boolean(assetBundle.pose?.graph),
+        animationCount: assetBundle.animations?.length ?? 0,
+        animationIds: (assetBundle.animations ?? []).map((anim) => anim.id),
+        namespace
+      });
+    }
+    const baseOutputPaths = /* @__PURE__ */ new Set();
+    const namespacedOutputPaths = /* @__PURE__ */ new Set();
+    const recordOutputs = (paths) => {
+      paths.forEach((path) => {
+        const trimmed = path.trim();
+        if (!trimmed) return;
+        const basePath = stripNamespace(trimmed, namespace);
+        baseOutputPaths.add(basePath);
+        namespacedOutputPaths.add(namespaceTypedPath(trimmed, namespace));
+      });
+    };
+    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
+        });
+        mergedGraphRef.current = mergedId;
+        graphIds.push(mergedId);
+      } else {
+        graphConfigs.forEach((cfg) => {
+          const id = registerGraph(cfg);
+          graphIds.push(id);
+        });
+      }
+    } catch (err) {
+      pushError({
+        message: "Failed to register rig graphs",
+        cause: err,
+        phase: "registration",
+        timestamp: performance.now()
+      });
+    }
+    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: controllerId,
+          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,
+          phase: "animation",
+          timestamp: performance.now()
+        });
+      }
+    }
+    registeredAnimationsRef.current = animationIds;
+    if (assetBundle.initialInputs) {
+      Object.entries(assetBundle.initialInputs).forEach(([path, value]) => {
+        try {
+          setInput(path, value);
+        } catch (err) {
+          pushError({
+            message: `Failed to stage initial input ${path}`,
+            cause: err,
+            phase: "registration",
+            timestamp: performance.now()
+          });
+        }
+      });
+    }
+    const controllers = listControllers();
+    if (isRuntimeDebugEnabled()) {
+      console.log("[vizij-runtime] controllers after register", {
+        controllers,
+        graphIds,
+        animationIds
+      });
+    }
+    reportStatus((prev) => ({
+      ...prev,
+      ready: true,
+      controllers,
+      outputPaths: Array.from(outputPathsRef.current)
+    }));
+    onRegisterControllers?.(controllers);
+  }, [
+    assetBundle,
+    clearControllers,
+    listControllers,
+    mergeStrategy,
+    namespace,
+    onRegisterControllers,
+    pushError,
+    registerAnimation,
+    registerGraph,
+    registerMergedGraph,
+    reportStatus,
+    resolvedProgramAssets,
+    setInput
+  ]);
+  (0, import_react2.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",
+        cause: err,
+        phase: "registration",
+        timestamp: performance.now()
+      });
+    });
+  }, [ready, status.loading, graphUpdateToken, registerControllers, pushError]);
+  (0, import_react2.useEffect)(() => {
+    if (!frame) {
+      return;
+    }
+    const writes = frame.merged_writes ?? [];
+    if (!writes.length) {
+      return;
+    }
+    const setWorldValues = store.getState().setValues;
+    const namespaceValue = status.namespace;
+    const currentValues = store.getState().values;
+    const rigInputPathMap = rigInputMapRef.current;
+    const rigPoseControlInputIds = rigPoseControlInputIdsRef.current;
+    const batched = [];
+    const namespacedOutputs = namespacedOutputPathsRef.current;
+    const baseOutputs = baseOutputPathsRef.current;
+    writes.forEach((write) => {
+      const path = normalisePath(write.path);
+      const basePath = stripNamespace(path, namespaceValue);
+      const isTrackedOutput = namespacedOutputs.has(path) || baseOutputs.has(basePath);
+      if (!isTrackedOutput) {
+        return;
+      }
+      const raw = valueJSONToRaw(write.value);
+      if (raw === void 0) {
+        return;
+      }
+      const poseControlMatch = /^rig\/[^/]+\/pose\/control\/(.+)$/.exec(
+        basePath
+      );
+      if (poseControlMatch && typeof raw === "number" && Number.isFinite(raw)) {
+        const inputId = (poseControlMatch[1] ?? "").trim();
+        const hasNativePoseControlInput = inputId.length > 0 && rigPoseControlInputIds.has(inputId);
+        const mappedInputPath = inputId.length === 0 ? void 0 : resolvePoseControlInputPath({
+          inputId,
+          basePath,
+          rigInputPathMap,
+          hasNativePoseControlInput
+        });
+        if (mappedInputPath) {
+          const bridgeKey = `${namespaceValue}:${mappedInputPath}`;
+          const previousValue = poseControlBridgeValuesRef.current.get(bridgeKey);
+          if (previousValue === void 0 || Math.abs(previousValue - raw) > POSE_CONTROL_BRIDGE_EPSILON) {
+            poseControlBridgeValuesRef.current.set(bridgeKey, raw);
+            setInput(mappedInputPath, { float: raw });
+          }
+        }
+      }
+      const targetPath = baseOutputs.has(basePath) ? basePath : path;
+      const currentValue = currentValues.get(
+        (0, import_utils.getLookup)(namespaceValue, targetPath)
+      );
+      const nextWrite = transformOutputWrite ? transformOutputWrite({
+        id: targetPath,
+        namespace: namespaceValue,
+        value: raw,
+        currentValue
+      }) : {
+        id: targetPath,
+        namespace: namespaceValue,
+        value: raw
+      };
+      if (nextWrite) {
+        batched.push(nextWrite);
+      }
+    });
+    if (batched.length > 0) {
+      setWorldValues(batched);
+    }
+  }, [frame, status.namespace, store, transformOutputWrite]);
+  const stagePoseNeutral = (0, import_react2.useCallback)(
+    (force = false) => {
+      const neutral = assetBundle.pose?.config?.neutralInputs ?? {};
+      const rigMap = rigInputMapRef.current;
+      const staged = /* @__PURE__ */ new Set();
+      Object.entries(neutral).forEach(([id, value]) => {
+        const path = rigMap[id];
+        if (!path) {
+          return;
+        }
+        const include = assetBundle.pose?.stageNeutralFilter;
+        if (include && !include(id, path)) {
+          return;
+        }
+        setInput(path, { float: Number.isFinite(value) ? value : 0 });
+        staged.add(path);
+      });
+      if (force) {
+        Object.entries(rigMap).forEach(([id, path]) => {
+          if (staged.has(path)) {
+            return;
+          }
+          const include = assetBundle.pose?.stageNeutralFilter;
+          if (include && !include(id, path)) {
+            return;
+          }
+          setInput(path, { float: 0 });
+        });
+      }
+    },
+    [assetBundle.pose?.config?.neutralInputs, setInput]
+  );
+  const setRendererValue = (0, import_react2.useCallback)(
+    (id, ns, value) => {
+      store.getState().setValue(id, ns, value);
+    },
+    [store]
+  );
+  const cancelAnimation = (0, import_react2.useCallback)((path) => {
+    if (animationTweensRef.current.has(path)) {
+      const entry = animationTweensRef.current.get(path);
+      animationTweensRef.current.delete(path);
+      entry?.resolve();
+    }
+  }, []);
+  const advanceAnimationTweens = (0, import_react2.useCallback)(
+    (dt) => {
+      if (animationTweensRef.current.size === 0) {
+        return;
+      }
+      const map = animationTweensRef.current;
+      const toDelete = [];
+      map.forEach((state, key) => {
+        state.elapsed += dt;
+        const progress = state.duration === 0 ? 1 : Math.min(state.elapsed / state.duration, 1);
+        const eased = state.easing(progress);
+        const value = state.from + (state.to - state.from) * eased;
+        setInput(state.path, { float: value });
+        if (progress >= 1) {
+          toDelete.push(key);
+          state.resolve();
+        }
+      });
+      toDelete.forEach((key) => map.delete(key));
+    },
+    [setInput]
+  );
+  const resolveClipById = (0, import_react2.useCallback)(
+    (id) => {
+      return assetBundle.animations?.find((anim) => anim.id === id);
+    },
+    [assetBundle.animations]
+  );
+  const resolveClipPromise = (0, import_react2.useCallback)((state) => {
+    state.resolve?.();
+    state.resolve = null;
+    state.completion = null;
+  }, []);
+  const ensureClipPromise = (0, import_react2.useCallback)((state) => {
+    if (state.completion) {
+      return state.completion;
+    }
+    const completion = new Promise((resolve) => {
+      state.resolve = resolve;
+    });
+    state.completion = completion;
+    return completion;
+  }, []);
+  const setAnimationInput = (0, import_react2.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 = (0, import_react2.useCallback)(
+    (path) => {
+      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
+      stagedInputsRef.current.delete(namespacedPath);
+      removeInput(namespacedPath);
+    },
+    [removeInput]
+  );
+  const buildClipOutputValues = (0, import_react2.useCallback)(
+    (clip, state) => sampleAnimationClipOutputValues(
+      clip.clip,
+      state.time,
+      state.weight,
+      faceId ?? void 0,
+      rigInputMapRef.current
+    ),
+    [faceId]
+  );
+  const computeClipAggregateValues = (0, import_react2.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 = (0, import_react2.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 = (0, import_react2.useCallback)(
+    (options) => {
+      stageClipAggregateValues(computeClipAggregateValues(), options);
+    },
+    [computeClipAggregateValues, stageClipAggregateValues]
+  );
+  const writeClipOutputs = (0, import_react2.useCallback)(
+    (clip, state, options) => {
+      if (!animationSystemActiveRef.current) {
+        return;
+      }
+      clipOutputValuesRef.current.set(
+        clip.id,
+        buildClipOutputValues(clip, state)
+      );
+      syncClipOutputs(options);
+    },
+    [buildClipOutputValues, syncClipOutputs]
+  );
+  const clearClipOutputs = (0, import_react2.useCallback)(
+    (clipId, options) => {
+      if (!clipOutputValuesRef.current.has(clipId)) {
+        return;
+      }
+      clipOutputValuesRef.current.delete(clipId);
+      syncClipOutputs(options);
+    },
+    [syncClipOutputs]
+  );
+  const createClipPlaybackState = (0, import_react2.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 ensureClipPlaybackState = (0, import_react2.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 = (0, import_react2.useCallback)(
+    (dt) => {
+      if (clipPlaybackRef.current.size === 0) {
+        return;
+      }
+      const toDelete = [];
+      clipPlaybackRef.current.forEach((state, key) => {
+        const clip = resolveClipById(state.id);
+        if (!clip) {
+          toDelete.push(key);
+          resolveClipPromise(state);
+          return;
+        }
+        state.duration = resolveClipDurationSeconds(
+          clip.clip,
+          state.duration
+        );
+        const { time, completed } = advanceClipTime(
+          {
+            time: state.time,
+            duration: state.duration,
+            speed: state.speed,
+            loop: state.loop,
+            playing: state.playing
+          },
+          dt
+        );
+        state.time = clampAnimationTime(time, state.duration);
+        if (state.playing || completed) {
+          writeClipOutputs(clip, state);
+        }
+        if (completed) {
+          toDelete.push(key);
+          resolveClipPromise(state);
+        }
+      });
+      toDelete.forEach((key) => {
+        clipPlaybackRef.current.delete(key);
+        if (animationSystemActiveRef.current) {
+          clearClipOutputs(key);
+        }
+      });
+    },
+    [clearClipOutputs, resolveClipById, resolveClipPromise, writeClipOutputs]
+  );
+  const animateValue = (0, import_react2.useCallback)(
+    (path, target, options) => {
+      const targetValue = (0, import_value_json2.valueAsNumber)(target);
+      const basePath = stripNamespace(
+        normalisePath(path),
+        namespaceRef.current
+      );
+      const poseValues = useLegacyPoseWeightFallback && targetValue != null ? poseWeightFallbackMap.get(basePath) : void 0;
+      if (poseValues && targetValue != null) {
+        const poseFaceId = assetBundle.pose?.config?.faceId ?? faceId ?? "face";
+        const rigMap = rigInputMapRef.current;
+        return Promise.all(
+          Object.entries(poseValues).flatMap(([inputId, poseValue]) => {
+            if (!Number.isFinite(poseValue)) {
+              return [];
+            }
+            const controlPath = resolvePoseControlInputPath({
+              inputId,
+              basePath: buildRigInputPath(
+                poseFaceId,
+                `/pose/control/${inputId}`
+              ),
+              rigInputPathMap: rigMap,
+              hasNativePoseControlInput: true
+            }) ?? buildRigInputPath(poseFaceId, `/pose/control/${inputId}`);
+            return [
+              animateValue(
+                controlPath,
+                { float: Number(poseValue) * targetValue },
+                options
+              )
+            ];
+          })
+        ).then(() => void 0);
+      }
+      const easing = resolveEasing(options?.easing);
+      const duration = Math.max(0, options?.duration ?? DEFAULT_DURATION);
+      cancelAnimation(path);
+      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
+      const current = getPathSnapshot(namespacedPath);
+      const fromValue = (0, import_value_json2.valueAsNumber)(current);
+      const toValue = (0, import_value_json2.valueAsNumber)(target);
+      if (fromValue == null || toValue == null || duration === 0) {
+        setInput(path, target);
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => {
+        animationTweensRef.current.set(path, {
+          // Keep the raw path here so tween updates go through setInput() once
+          // and pick up the active namespace exactly once.
+          path,
+          from: fromValue,
+          to: toValue,
+          duration,
+          elapsed: 0,
+          easing,
+          resolve
+        });
+        markActivity();
+      });
+    },
+    [
+      assetBundle.pose?.config?.faceId,
+      cancelAnimation,
+      faceId,
+      getPathSnapshot,
+      markActivity,
+      poseWeightFallbackMap,
+      setInput,
+      useLegacyPoseWeightFallback
+    ]
+  );
+  const playAnimation = (0, import_react2.useCallback)(
+    (id, options) => {
+      const ensured = ensureClipPlaybackState(id);
+      if (!ensured) {
+        return Promise.reject(
+          new Error(`Animation ${id} is not part of the current asset bundle.`)
+        );
+      }
+      const { clip, state } = ensured;
+      const shouldReset = options?.reset === true;
+      if (shouldReset) {
+        resolveClipPromise(state);
+        state.time = 0;
+      }
+      const speed = options?.speed ?? state.speed ?? 1;
+      const weight = options?.weight ?? state.weight ?? clip.weight ?? 1;
+      state.speed = Number.isFinite(speed) && speed > 0 ? speed : 1;
+      state.weight = Number.isFinite(weight) ? Number(weight) : 1;
+      state.duration = resolveClipDurationSeconds(
+        clip.clip,
+        state.duration
+      );
+      state.time = clampAnimationTime(state.time, state.duration);
+      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 = (0, import_react2.useCallback)(
+    (id) => {
+      const state = clipPlaybackRef.current.get(id);
+      if (!state || !state.playing) {
+        return;
+      }
+      state.playing = false;
+      updateLoopMode();
+    },
+    [updateLoopMode]
+  );
+  const seekAnimation = (0, import_react2.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 = (0, import_react2.useCallback)(
+    (id, enabled) => {
+      const ensured = ensureClipPlaybackState(id);
+      if (!ensured) {
+        return;
+      }
+      ensured.state.loop = Boolean(enabled);
+      clipPlaybackRef.current.set(id, ensured.state);
+      updateLoopMode();
+    },
+    [ensureClipPlaybackState, updateLoopMode]
+  );
+  const getAnimationState = (0, import_react2.useCallback)(
+    (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 = (0, import_react2.useCallback)(
+    (id, options) => {
+      const state = clipPlaybackRef.current.get(id);
+      if (state) {
+        clipPlaybackRef.current.delete(id);
+        state.playing = false;
+        resolveClipPromise(state);
+      }
+      if (options?.clearOutputs !== false) {
+        clearClipOutputs(id);
+      }
+      updateLoopMode();
+    },
+    [clearClipOutputs, resolveClipPromise, updateLoopMode]
+  );
+  const refreshControllerStatus = (0, import_react2.useCallback)(() => {
+    const controllers = listControllers();
+    reportStatus((prev) => ({
+      ...prev,
+      controllers,
+      outputPaths: Array.from(outputPathsRef.current)
+    }));
+    onRegisterControllers?.(controllers);
+  }, [listControllers, onRegisterControllers, reportStatus]);
+  const resolveProgramById = (0, import_react2.useCallback)(
+    (id) => {
+      return resolvedProgramAssets.find((program) => program.id === id);
+    },
+    [resolvedProgramAssets]
+  );
+  const buildProgramRegistrationConfig = (0, import_react2.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 = (0, import_react2.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 = (0, import_react2.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 = (0, import_react2.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 = (0, import_react2.useCallback)(
+    (id) => {
+      if (!resolveProgramById(id)) {
+        return;
+      }
+      programPlaybackRef.current.set(id, {
+        id,
+        state: "paused"
+      });
+      syncProgramPlaybackControllers();
+      updateLoopMode();
+    },
+    [resolveProgramById, syncProgramPlaybackControllers, updateLoopMode]
+  );
+  const stopProgram = (0, import_react2.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();
+    },
+    [
+      deriveProgramResetValues,
+      pushError,
+      refreshControllerStatus,
+      removeGraph,
+      resolveProgramById,
+      setInput,
+      updateLoopMode
+    ]
+  );
+  const getProgramState = (0, import_react2.useCallback)(
+    (id) => {
+      const state = programPlaybackRef.current.get(id);
+      if (!state) {
+        return null;
+      }
+      return { state: state.state };
+    },
+    []
+  );
+  (0, import_react2.useEffect)(() => {
+    if (!ready || status.loading) {
+      return;
+    }
+    syncProgramPlaybackControllers();
+  }, [
+    graphUpdateToken,
+    ready,
+    resolvedProgramAssets,
+    status.loading,
+    syncProgramPlaybackControllers
+  ]);
+  const setAnimationActive = (0, import_react2.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 = (0, import_react2.useCallback)(
+    () => animationSystemActiveRef.current,
+    []
+  );
+  const registerInputDriver = (0, import_react2.useCallback)(
+    (id, factory) => {
+      const driver = factory({
+        setInput,
+        setRendererValue,
+        namespace,
+        faceId
+      });
+      const wrapped = {
+        start: () => {
+          try {
+            driver.start();
+          } catch (err) {
+            pushError({
+              message: `Input driver ${id} failed to start`,
+              cause: err,
+              phase: "driver",
+              timestamp: performance.now()
+            });
+          }
+        },
+        stop: () => {
+          try {
+            driver.stop();
+          } catch (err) {
+            pushError({
+              message: `Input driver ${id} failed to stop`,
+              cause: err,
+              phase: "driver",
+              timestamp: performance.now()
+            });
+          }
+        },
+        dispose: () => {
+          try {
+            driver.dispose();
+          } catch (err) {
+            pushError({
+              message: `Input driver ${id} failed to dispose`,
+              cause: err,
+              phase: "driver",
+              timestamp: performance.now()
+            });
+          }
+        }
+      };
+      return wrapped;
+    },
+    [faceId, namespace, pushError, setInput, setRendererValue]
+  );
+  const advanceAnimations = (0, import_react2.useCallback)(
+    (dt) => {
+      advanceAnimationTweens(dt);
+      advanceClipPlayback(dt);
+    },
+    [advanceAnimationTweens, advanceClipPlayback]
+  );
+  const flushStagedInputs = (0, import_react2.useCallback)(() => {
+    if (stagedInputsRef.current.size === 0) {
+      return;
+    }
+    stagedInputsRef.current.forEach(({ value, shape }, path) => {
+      orchestratorSetInput(path, value, shape);
+    });
+    stagedInputsRef.current.clear();
+  }, [orchestratorSetInput]);
+  const step = (0, import_react2.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);
+      flushStagedInputs();
+      if (driveOrchestratorRef.current || opts?.forceRuntime) {
+        stepRuntime(dt);
+      }
+    },
+    [advanceAnimations, flushStagedInputs, stepRuntime]
+  );
+  (0, import_react2.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 (rafId !== null) {
+        cancelAnimationFrame(rafId);
+      }
+    };
+  }, [loopMode, computeDesiredLoopMode, requestLoopMode, step]);
+  (0, import_react2.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;
+      }
+      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]);
+  (0, import_react2.useEffect)(() => {
+    return () => {
+      animationTweensRef.current.clear();
+      clipPlaybackRef.current.clear();
+      programPlaybackRef.current.clear();
+      programControllerIdsRef.current.clear();
+      clipOutputValuesRef.current.clear();
+      clipAggregateValuesRef.current.clear();
+    };
+  }, []);
+  (0, import_react2.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 = (0, import_react2.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 = (0, import_react2.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,
+      inputConstraints
+    }),
+    [
+      status,
+      assetBundle,
+      setInput,
+      setGraphBundle,
+      setRendererValue,
+      stagePoseNeutral,
+      animateValue,
+      cancelAnimation,
+      registerInputDriver,
+      playAnimation,
+      pauseAnimation,
+      seekAnimation,
+      setAnimationLoop,
+      getAnimationState,
+      stopAnimation,
+      playProgram,
+      pauseProgram,
+      stopProgram,
+      getProgramState,
+      setAnimationActive,
+      isAnimationActive,
+      step,
+      advanceAnimations,
+      inputConstraints
+    ]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(VizijRuntimeContext.Provider, { value: contextValue, children });
+}
+
+// src/VizijRuntimeFace.tsx
+var import_react4 = require("react");
+var import_render2 = require("@vizij/render");
+
+// src/hooks/useVizijRuntime.ts
+var import_react3 = require("react");
+function useVizijRuntime() {
+  const ctx = (0, import_react3.useContext)(VizijRuntimeContext);
+  if (!ctx) {
+    throw new Error(
+      "useVizijRuntime must be used within a VizijRuntimeProvider."
+    );
+  }
+  return ctx;
+}
+
+// src/VizijRuntimeFace.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function VizijRuntimeFaceInner({
+  namespaceOverride,
+  ...props
+}) {
+  const { rootId, namespace } = useVizijRuntime();
+  if (!rootId) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    import_render2.Vizij,
+    {
+      ...props,
+      rootId,
+      namespace: namespaceOverride ?? namespace
+    }
+  );
+}
+var VizijRuntimeFace = (0, import_react4.memo)(VizijRuntimeFaceInner);
+
+// src/hooks/useOptionalVizijRuntime.ts
+var import_react5 = require("react");
+function useOptionalVizijRuntime() {
+  return (0, import_react5.useContext)(VizijRuntimeContext);
+}
+
+// src/hooks/useVizijOutputs.ts
+var import_render3 = require("@vizij/render");
+var import_utils2 = require("@vizij/utils");
+function useVizijOutputs(paths) {
+  const { namespace } = useVizijRuntime();
+  return (0, import_render3.useVizijStore)((state) => {
+    const result = {};
+    paths.forEach((path) => {
+      const lookup = (0, import_utils2.getLookup)(namespace, path);
+      result[path] = state.values.get(lookup);
+    });
+    return result;
+  });
+}
+
+// src/hooks/useRigInput.ts
+var import_react6 = require("react");
+var import_render4 = require("@vizij/render");
+var import_utils3 = require("@vizij/utils");
+function useRigInput(path) {
+  const { namespace, setInput } = useVizijRuntime();
+  const value = (0, import_render4.useVizijStore)((state) => {
+    return state.values.get((0, import_utils3.getLookup)(namespace, path));
+  });
+  const setter = (0, import_react6.useCallback)(
+    (next, shape) => {
+      setInput(path, next, shape);
+    },
+    [path, setInput]
+  );
+  return [value, setter];
+}
+
+// src/utils/faceControls.ts
+var DEFAULT_GAZE_CONTROL = {
+  min: -1,
+  max: 1,
+  defaultValue: 0
+};
+var DEFAULT_BLINK_CONTROL = {
+  min: 0,
+  max: 1,
+  defaultValue: 0
+};
+var STANDARD_VIZIJ_EYE_PATHS = {
+  leftX: "/standard/vizij/left_eye/pos/x",
+  leftY: "/standard/vizij/left_eye/pos/y",
+  rightX: "/standard/vizij/right_eye/pos/x",
+  rightY: "/standard/vizij/right_eye/pos/y",
+  leftUpper: "/standard/vizij/left_eye_top_eyelid/pos/y",
+  rightUpper: "/standard/vizij/right_eye_top_eyelid/pos/y"
+};
+var LEGACY_STANDARD_EYE_PATHS = {
+  leftX: "/standard/left_eye/pos/x",
+  leftY: "/standard/left_eye/pos/y",
+  rightX: "/standard/right_eye/pos/x",
+  rightY: "/standard/right_eye/pos/y",
+  leftUpper: "/standard/left_eye_top_eyelid/pos/y",
+  rightUpper: "/standard/right_eye_top_eyelid/pos/y"
+};
+var PROPSRIG_EYE_PATHS = {
+  leftX: "/propsrig/l_eye/translation/x",
+  leftY: "/propsrig/l_eye/translation/y",
+  rightX: "/propsrig/r_eye/translation/x",
+  rightY: "/propsrig/r_eye/translation/y"
+};
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function normalizeInputPath(path) {
+  const trimmed = path?.trim() ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  if (trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  const rigMatch = trimmed.match(/^rig\/[^/]+(\/.*)$/);
+  if (rigMatch?.[1]) {
+    return rigMatch[1];
+  }
+  return `/${trimmed}`;
+}
+function buildControlsLookup(assetBundle) {
+  const metadata = assetBundle.rig?.inputMetadata ?? [];
+  const metadataByPath = /* @__PURE__ */ new Map();
+  const pathSet = /* @__PURE__ */ new Set();
+  metadata.forEach((entry) => {
+    const normalized = normalizeInputPath(entry.path);
+    if (!normalized) {
+      return;
+    }
+    pathSet.add(normalized);
+    if (!metadataByPath.has(normalized)) {
+      metadataByPath.set(normalized, entry);
+    }
+  });
+  return { pathSet, metadataByPath };
+}
+function resolveConstraint(absolutePath, relativePath, inputConstraints) {
+  if (!inputConstraints) {
+    return null;
+  }
+  const normalizedRelative = relativePath.replace(/^\//, "");
+  const candidates = [
+    absolutePath,
+    relativePath,
+    normalizedRelative,
+    absolutePath.replace(/^rig\/[^/]+\//, "")
+  ];
+  for (const candidate of candidates) {
+    const constraint = inputConstraints[candidate];
+    if (constraint) {
+      return constraint;
+    }
+  }
+  return null;
+}
+function createControl(faceId, lookup, relativePath, inputConstraints, fallback) {
+  const normalizedRelative = normalizeInputPath(relativePath);
+  if (!normalizedRelative || !lookup.pathSet.has(normalizedRelative)) {
+    return null;
+  }
+  const absolutePath = buildRigInputPath(faceId, normalizedRelative);
+  const metadata = lookup.metadataByPath.get(normalizedRelative);
+  const constraint = resolveConstraint(
+    absolutePath,
+    normalizedRelative,
+    inputConstraints
+  );
+  const min = Number.isFinite(Number(constraint?.min ?? metadata?.range?.min)) ? Number(constraint?.min ?? metadata?.range?.min) : fallback.min;
+  const max = Number.isFinite(Number(constraint?.max ?? metadata?.range?.max)) ? Number(constraint?.max ?? metadata?.range?.max) : fallback.max;
+  const midpoint = min + (max - min) / 2;
+  const defaultValue = Number.isFinite(
+    Number(constraint?.defaultValue ?? metadata?.defaultValue)
+  ) ? Number(constraint?.defaultValue ?? metadata?.defaultValue) : Number.isFinite(midpoint) ? midpoint : fallback.defaultValue;
+  return {
+    path: absolutePath,
+    min,
+    max,
+    defaultValue
+  };
+}
+function hasAll(controls, keys) {
+  return keys.every((key) => Boolean(controls[key]));
+}
+function resolveFaceControls(assetBundle, runtimeFaceId, inputConstraints) {
+  const faceId = assetBundle.faceId ?? assetBundle.pose?.config?.faceId ?? runtimeFaceId ?? "face";
+  const lookup = buildControlsLookup(assetBundle);
+  const standardVizijControls = {
+    leftX: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.leftX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftY: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.leftY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightX: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.rightX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightY: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.rightY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftUpper: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.leftUpper,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightUpper: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.rightUpper,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    )
+  };
+  const legacyStandardControls = {
+    leftX: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.leftX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftY: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.leftY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightX: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.rightX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightY: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.rightY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftUpper: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.leftUpper,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightUpper: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.rightUpper,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    )
+  };
+  const propsrigControls = {
+    leftX: createControl(
+      faceId,
+      lookup,
+      PROPSRIG_EYE_PATHS.leftX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftY: createControl(
+      faceId,
+      lookup,
+      PROPSRIG_EYE_PATHS.leftY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightX: createControl(
+      faceId,
+      lookup,
+      PROPSRIG_EYE_PATHS.rightX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightY: createControl(
+      faceId,
+      lookup,
+      PROPSRIG_EYE_PATHS.rightY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    )
+  };
+  const coupledGazeControls = {
+    leftX: createControl(
+      faceId,
+      lookup,
+      "/gaze/left_right",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftY: createControl(
+      faceId,
+      lookup,
+      "/gaze/up_down",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightX: createControl(
+      faceId,
+      lookup,
+      "/gaze/left_right_copy",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ) ?? createControl(
+      faceId,
+      lookup,
+      "/gaze/left_right",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightY: createControl(
+      faceId,
+      lookup,
+      "/gaze/up_down_copy",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ) ?? createControl(
+      faceId,
+      lookup,
+      "/gaze/up_down",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    )
+  };
+  const blinkFromLids = createControl(
+    faceId,
+    lookup,
+    "/lids/blink",
+    inputConstraints,
+    DEFAULT_BLINK_CONTROL
+  );
+  const blinkDirect = createControl(
+    faceId,
+    lookup,
+    "/blink",
+    inputConstraints,
+    DEFAULT_BLINK_CONTROL
+  );
+  if (hasAll(standardVizijControls, ["leftX", "leftY", "rightX", "rightY"])) {
+    return {
+      faceId,
+      gazeSource: "standard-vizij",
+      blinkSource: blinkFromLids ? "lids" : blinkDirect ? "blink" : "none",
+      eyes: {
+        leftX: standardVizijControls.leftX,
+        leftY: standardVizijControls.leftY,
+        rightX: standardVizijControls.rightX,
+        rightY: standardVizijControls.rightY
+      },
+      eyelids: {
+        leftUpper: standardVizijControls.leftUpper,
+        rightUpper: standardVizijControls.rightUpper
+      },
+      blink: blinkFromLids ?? blinkDirect
+    };
+  }
+  if (hasAll(legacyStandardControls, ["leftX", "leftY", "rightX", "rightY"])) {
+    return {
+      faceId,
+      gazeSource: "standard",
+      blinkSource: blinkDirect ? "blink" : blinkFromLids ? "lids" : "none",
+      eyes: {
+        leftX: legacyStandardControls.leftX,
+        leftY: legacyStandardControls.leftY,
+        rightX: legacyStandardControls.rightX,
+        rightY: legacyStandardControls.rightY
+      },
+      eyelids: {
+        leftUpper: legacyStandardControls.leftUpper,
+        rightUpper: legacyStandardControls.rightUpper
+      },
+      blink: blinkDirect ?? blinkFromLids
+    };
+  }
+  if (hasAll(propsrigControls, ["leftX", "leftY", "rightX", "rightY"])) {
+    return {
+      faceId,
+      gazeSource: "propsrig",
+      blinkSource: blinkDirect ? "blink" : blinkFromLids ? "lids" : "none",
+      eyes: {
+        leftX: propsrigControls.leftX,
+        leftY: propsrigControls.leftY,
+        rightX: propsrigControls.rightX,
+        rightY: propsrigControls.rightY
+      },
+      eyelids: {
+        leftUpper: null,
+        rightUpper: null
+      },
+      blink: blinkDirect ?? blinkFromLids
+    };
+  }
+  if (hasAll(coupledGazeControls, ["leftX", "leftY", "rightX", "rightY"])) {
+    return {
+      faceId,
+      gazeSource: "coupled-gaze",
+      blinkSource: blinkFromLids ? "lids" : blinkDirect ? "blink" : "none",
+      eyes: {
+        leftX: coupledGazeControls.leftX,
+        leftY: coupledGazeControls.leftY,
+        rightX: coupledGazeControls.rightX,
+        rightY: coupledGazeControls.rightY
+      },
+      eyelids: {
+        leftUpper: null,
+        rightUpper: null
+      },
+      blink: blinkFromLids ?? blinkDirect
+    };
+  }
+  return {
+    faceId,
+    gazeSource: "none",
+    blinkSource: blinkFromLids ? "lids" : blinkDirect ? "blink" : "none",
+    eyes: {
+      leftX: null,
+      leftY: null,
+      rightX: null,
+      rightY: null
+    },
+    eyelids: {
+      leftUpper: null,
+      rightUpper: null
+    },
+    blink: blinkFromLids ?? blinkDirect
+  };
+}
+function mapNormalizedControlValue(control, normalizedValue) {
+  const value = clamp(normalizedValue, -1, 1);
+  if (value === 0) {
+    return control.defaultValue;
+  }
+  if (value > 0) {
+    return control.defaultValue + (control.max - control.defaultValue) * value;
+  }
+  return control.defaultValue + (control.defaultValue - control.min) * value;
+}
+function mapUnitControlValue(control, unitValue) {
+  const value = clamp(unitValue, 0, 1);
+  return control.defaultValue + (control.max - control.defaultValue) * value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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
+});