@vizij/runtime-react 0.1.0 → 0.2.0

package/dist/index.js

@@ -21,11 +21,143 @@ import {
 } from "@vizij/orchestrator-react";
 import { compileIrGraph } from "@vizij/node-graph-authoring";
 import { valueAsNumber as valueAsNumber2 } from "@vizij/value-json";
+import { getLookup } from "@vizij/utils";
 
 // src/context.ts
 import { createContext } from "react";
 var VizijRuntimeContext = createContext(null);
 
+// src/updatePolicy.ts
+function applyRuntimeGraphBundle(base, bundle) {
+  const next = {
+    ...base
+  };
+  const hasRigOverride = Object.prototype.hasOwnProperty.call(bundle, "rig");
+  const hasPoseOverride = Object.prototype.hasOwnProperty.call(bundle, "pose");
+  const hasAnimationsOverride = Object.prototype.hasOwnProperty.call(
+    bundle,
+    "animations"
+  );
+  const hasProgramsOverride = Object.prototype.hasOwnProperty.call(
+    bundle,
+    "programs"
+  );
+  if (hasRigOverride) {
+    if (bundle.rig) {
+      next.rig = bundle.rig;
+    } else {
+      delete next.rig;
+    }
+  }
+  if (hasPoseOverride) {
+    if (bundle.pose) {
+      next.pose = bundle.pose;
+    } else {
+      delete next.pose;
+    }
+  }
+  if (hasAnimationsOverride) {
+    next.animations = Array.isArray(bundle.animations) ? bundle.animations : void 0;
+  }
+  if (hasProgramsOverride) {
+    next.programs = Array.isArray(bundle.programs) ? bundle.programs : void 0;
+  }
+  return next;
+}
+function normalizeSpecPayload(value) {
+  if (!value) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function glbSignature(glb) {
+  if (glb.kind === "url") {
+    return `url:${glb.src}`;
+  }
+  if (glb.kind === "blob") {
+    return `blob:${glb.blob?.size ?? 0}`;
+  }
+  return `world:${normalizeSpecPayload(glb.world)}`;
+}
+function graphSignature(graph) {
+  if (!graph) {
+    return "";
+  }
+  const id = graph.id ?? "";
+  return `${id}:${normalizeSpecPayload(graph.spec ?? graph.ir ?? null)}`;
+}
+function poseSignature(pose) {
+  if (!pose) {
+    return "";
+  }
+  const graph = pose.graph;
+  const config = pose.config;
+  const graphPart = graph ? graphSignature({ id: graph.id, spec: graph.spec }) : "";
+  const configPart = config ? normalizeSpecPayload(config) : "";
+  return `${graphPart}:${configPart}`;
+}
+function animationsSignature(animations) {
+  if (!Array.isArray(animations) || animations.length === 0) {
+    return "";
+  }
+  return animations.map((animation) => {
+    const id = animation.id ?? "";
+    const clipSignature = normalizeSpecPayload(animation.clip ?? null);
+    const setupSignature = normalizeSpecPayload(animation.setup ?? null);
+    const weightSignature = animation.weight == null ? "" : String(animation.weight);
+    return `${id}:${clipSignature}:${setupSignature}:${weightSignature}`;
+  }).sort().join("|");
+}
+function programsSignature(programs) {
+  if (!Array.isArray(programs) || programs.length === 0) {
+    return "";
+  }
+  return programs.map((program) => {
+    const id = program.id ?? "";
+    const label = program.label ?? "";
+    const graphId = program.graph?.id ?? "";
+    const graphPayload = normalizeSpecPayload(
+      program.graph?.spec ?? program.graph?.ir ?? null
+    );
+    const resetValues = normalizeSpecPayload(program.resetValues ?? null);
+    return `${id}:${label}:${graphId}:${graphPayload}:${resetValues}`;
+  }).sort().join("|");
+}
+function resolveRuntimeUpdatePlan(previous, next, tier) {
+  if (!previous) {
+    return { reloadAssets: true, reregisterGraphs: false };
+  }
+  const glbChanged = glbSignature(previous.glb) !== glbSignature(next.glb);
+  const rigChanged = graphSignature(previous.rig) !== graphSignature(next.rig);
+  const poseChanged = poseSignature(previous.pose) !== poseSignature(next.pose);
+  const rigReferenceChanged = previous.rig?.id !== next.rig?.id || previous.rig?.spec !== next.rig?.spec || previous.rig?.ir !== next.rig?.ir;
+  const poseReferenceChanged = previous.pose?.graph?.id !== next.pose?.graph?.id || previous.pose?.graph?.spec !== next.pose?.graph?.spec || previous.pose?.config !== next.pose?.config;
+  const graphsChanged = rigChanged || poseChanged || rigReferenceChanged || poseReferenceChanged;
+  const animationsChanged = animationsSignature(previous.animations) !== animationsSignature(next.animations);
+  const programsChanged = programsSignature(previous.programs) !== programsSignature(next.programs);
+  const controllersChanged = graphsChanged || animationsChanged || programsChanged;
+  if (tier === "assets") {
+    return { reloadAssets: true, reregisterGraphs: false };
+  }
+  if (tier === "graphs") {
+    if (glbChanged) {
+      return { reloadAssets: true, reregisterGraphs: false };
+    }
+    return { reloadAssets: false, reregisterGraphs: controllersChanged };
+  }
+  if (glbChanged) {
+    return { reloadAssets: true, reregisterGraphs: false };
+  }
+  if (controllersChanged) {
+    return { reloadAssets: false, reregisterGraphs: true };
+  }
+  return { reloadAssets: false, reregisterGraphs: false };
+}
+
 // src/utils/graph.ts
 function getNodes(spec) {
   if (!spec || typeof spec !== "object") {
@@ -70,6 +202,12 @@ function collectInputPaths(spec) {
 }
 function collectInputPathMap(spec) {
   const map = {};
+  const addVariant = (key, path, force = false) => {
+    if (!key || !force && map[key]) {
+      return;
+    }
+    map[key] = path;
+  };
   const nodes = getNodes(spec);
   nodes.forEach((node) => {
     if (String(node.type ?? "").toLowerCase() !== "input") {
@@ -81,11 +219,653 @@ function collectInputPathMap(spec) {
     }
     const id = String(node.id ?? "");
     const key = id.startsWith("input_") ? id.slice("input_".length) : id || path.trim();
-    map[key] = path.trim();
+    const trimmedPath = path.trim();
+    addVariant(key, trimmedPath);
+    if (key.startsWith("direct_")) {
+      addVariant(key.slice("direct_".length), trimmedPath, true);
+    }
+    if (key.startsWith("pose_control_")) {
+      addVariant(key.slice("pose_control_".length), trimmedPath);
+    }
+  });
+  return map;
+}
+
+// src/utils/posePaths.ts
+var POSE_WEIGHT_INPUT_PATH_PREFIX = "/poses/";
+var VISEME_POSE_KEYS = [
+  "a",
+  "at",
+  "b",
+  "e",
+  "e_2",
+  "f",
+  "i",
+  "k",
+  "m",
+  "o",
+  "o_2",
+  "p",
+  "r",
+  "s",
+  "t",
+  "t_2",
+  "u"
+];
+var EXPRESSIVE_EMOTION_POSE_KEYS = [
+  "concerned",
+  "happy",
+  "sad",
+  "sleepy",
+  "surprise"
+];
+var EMOTION_POSE_KEYS = [
+  "concerned",
+  "happy",
+  "neutral",
+  "sad",
+  "sleepy",
+  "surprise",
+  "angry"
+];
+var VISEME_GROUP_NEEDLES = ["viseme", "phoneme", "lip", "mouth"];
+var EMOTION_GROUP_NEEDLES = ["emotion", "expression", "mood", "affect"];
+var VISEME_POSE_KEY_SET = new Set(VISEME_POSE_KEYS);
+var EMOTION_POSE_KEY_SET = new Set(EMOTION_POSE_KEYS);
+var POSE_KEY_ALIASES = {
+  concern: "concerned",
+  surprised: "surprise"
+};
+function buildRigInputPath(faceId, path) {
+  let trimmed = path.startsWith("/") ? path.slice(1) : path;
+  if (!trimmed) {
+    return `rig/${faceId}`;
+  }
+  while (trimmed.startsWith("rig/")) {
+    const segments = trimmed.split("/");
+    if (segments.length >= 3) {
+      const existingFaceId = segments[1];
+      const remainder = segments.slice(2).join("/");
+      if (existingFaceId === faceId) {
+        return trimmed;
+      }
+      trimmed = remainder || "";
+    } else {
+      trimmed = segments.slice(1).join("/");
+    }
+  }
+  const suffix = trimmed ? `/${trimmed}` : "";
+  return `rig/${faceId}${suffix}`;
+}
+function normalizePoseWeightPathSegment(value) {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed) {
+    return "pose";
+  }
+  const normalized = trimmed.replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized || "pose";
+}
+function buildPoseWeightInputPathSegment(poseId) {
+  return normalizePoseWeightPathSegment(poseId);
+}
+function buildPoseWeightRelativePath(poseId) {
+  return `${POSE_WEIGHT_INPUT_PATH_PREFIX}${buildPoseWeightInputPathSegment(
+    poseId
+  )}.weight`;
+}
+function buildPoseWeightPathMap(poses, faceId) {
+  const faceSegment = faceId?.trim() || "face";
+  const map = /* @__PURE__ */ new Map();
+  poses.forEach((pose) => {
+    map.set(
+      pose.id,
+      buildRigInputPath(faceSegment, buildPoseWeightRelativePath(pose.id))
+    );
+  });
+  return map;
+}
+function normalizePoseSemanticKey(value) {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  const normalized = trimmed.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+  if (!normalized) {
+    return null;
+  }
+  return POSE_KEY_ALIASES[normalized] ?? normalized;
+}
+function derivePoseSemanticKeyFromId(poseId) {
+  const trimmed = poseId?.trim() ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  const stripped = trimmed.replace(/^pose_d_/i, "").replace(/^pose_/i, "").replace(/^d_/i, "").replace(/_d$/i, "");
+  return normalizePoseSemanticKey(stripped);
+}
+function getPoseSemanticKey(pose) {
+  return normalizePoseSemanticKey(pose.name) ?? derivePoseSemanticKeyFromId(pose.id) ?? null;
+}
+function normalizePoseGroupPath(value) {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  return trimmed.replace(/^\/+|\/+$/g, "").replace(/\/+/g, "/");
+}
+function sanitizePoseGroupId(value, fallback) {
+  const normalized = (value ?? "").trim().replace(/[^a-zA-Z0-9_/-]+/g, "_").replace(/^\/+|\/+$/g, "").replace(/\/+/g, "_");
+  if (!normalized) {
+    return fallback.replace(/\//g, "_");
+  }
+  return normalized;
+}
+function buildPoseGroupLookup(groups) {
+  const byId = /* @__PURE__ */ new Map();
+  const byPath = /* @__PURE__ */ new Map();
+  const orderById = /* @__PURE__ */ new Map();
+  (groups ?? []).forEach((group, index) => {
+    const path = normalizePoseGroupPath(group.path ?? group.name ?? group.id);
+    if (!path) {
+      return;
+    }
+    const id = sanitizePoseGroupId(group.id, path);
+    const humanizedName = typeof group.name === "string" && group.name.trim().length > 0 ? group.name.trim() : path.split("/").filter(Boolean).pop()?.split(/[_-]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ") ?? path;
+    const normalized = {
+      ...group,
+      id,
+      path,
+      name: humanizedName
+    };
+    byId.set(id, normalized);
+    if (!orderById.has(id)) {
+      orderById.set(id, index);
+    }
+    if (!byPath.has(path)) {
+      byPath.set(path, normalized);
+    }
+  });
+  return { byId, byPath, orderById };
+}
+function orderPoseMembershipIds(groupIds, groups) {
+  const { orderById } = buildPoseGroupLookup(groups);
+  const unique = Array.from(
+    new Set(
+      Array.from(groupIds).map((groupId) => groupId.trim()).filter((groupId) => groupId.length > 0)
+    )
+  );
+  unique.sort((left, right) => {
+    const leftIndex = orderById.get(left);
+    const rightIndex = orderById.get(right);
+    if (leftIndex !== void 0 && rightIndex !== void 0) {
+      return leftIndex - rightIndex;
+    }
+    if (leftIndex !== void 0) {
+      return -1;
+    }
+    if (rightIndex !== void 0) {
+      return 1;
+    }
+    const leftPath = normalizePoseGroupPath(left) ?? left;
+    const rightPath = normalizePoseGroupPath(right) ?? right;
+    const byPath = leftPath.localeCompare(rightPath);
+    if (byPath !== 0) {
+      return byPath;
+    }
+    return left.localeCompare(right);
+  });
+  return unique;
+}
+function valueHasNeedle(value, needles) {
+  const normalized = normalizePoseSemanticKey(value);
+  if (!normalized) {
+    return false;
+  }
+  return needles.some((needle) => normalized.includes(needle));
+}
+function resolvePoseMembership(pose, groups) {
+  const { byId, byPath } = buildPoseGroupLookup(groups);
+  const resolvedGroupIds = [];
+  const pathById = /* @__PURE__ */ new Map();
+  const addMembership = (groupId, path) => {
+    if (!groupId) {
+      return;
+    }
+    if (!resolvedGroupIds.includes(groupId)) {
+      resolvedGroupIds.push(groupId);
+    }
+    if (!path) {
+      return;
+    }
+    const existingPath = pathById.get(groupId);
+    const normalizedGroupIdPath = normalizePoseGroupPath(groupId);
+    const normalizedExistingPath = normalizePoseGroupPath(existingPath) ?? existingPath ?? null;
+    const normalizedIncomingPath = normalizePoseGroupPath(path) ?? path ?? null;
+    const shouldPromotePath = normalizedExistingPath === null || normalizedGroupIdPath !== null && normalizedExistingPath === normalizedGroupIdPath && normalizedIncomingPath !== normalizedGroupIdPath;
+    if (shouldPromotePath) {
+      pathById.set(groupId, path);
+    }
+  };
+  const addByPath = (rawPath) => {
+    const normalizedPath = normalizePoseGroupPath(rawPath);
+    if (!normalizedPath) {
+      return;
+    }
+    const existing = byPath.get(normalizedPath);
+    if (existing) {
+      addMembership(existing.id, existing.path);
+      return;
+    }
+    addMembership(sanitizePoseGroupId(null, normalizedPath), normalizedPath);
+  };
+  const addById = (rawId) => {
+    const trimmed = rawId?.trim() ?? "";
+    if (!trimmed) {
+      return;
+    }
+    const normalizedPath = normalizePoseGroupPath(trimmed);
+    const normalizedId = sanitizePoseGroupId(trimmed, trimmed);
+    const matchedById = byId.get(trimmed) ?? byId.get(normalizedId);
+    if (matchedById) {
+      addMembership(matchedById.id, matchedById.path);
+      return;
+    }
+    if (normalizedPath) {
+      const matchedByPath = byPath.get(normalizedPath);
+      if (matchedByPath) {
+        addMembership(matchedByPath.id, matchedByPath.path);
+        return;
+      }
+    }
+    addMembership(
+      normalizedId,
+      normalizedPath && normalizedPath.length > 0 ? normalizedPath : null
+    );
+  };
+  pose.groupIds?.forEach((groupId) => addById(groupId));
+  addById(pose.groupId);
+  addByPath(pose.group);
+  const orderedGroupIds = orderPoseMembershipIds(resolvedGroupIds, groups);
+  const primaryGroupId = orderedGroupIds[0] ?? null;
+  const primaryGroupPath = primaryGroupId ? byId.get(primaryGroupId)?.path ?? pathById.get(primaryGroupId) ?? null : null;
+  const groupPathsById = {};
+  orderedGroupIds.forEach((groupId) => {
+    const path = byId.get(groupId)?.path ?? pathById.get(groupId) ?? null;
+    if (path) {
+      groupPathsById[groupId] = path;
+    }
+  });
+  return {
+    groupIds: orderedGroupIds,
+    primaryGroupId,
+    primaryGroupPath,
+    groupPathsById
+  };
+}
+function poseMatchesGroupKind(pose, groups, needles) {
+  const membership = resolvePoseMembership(pose, groups);
+  if (valueHasNeedle(pose.group, needles) || valueHasNeedle(pose.groupId, needles)) {
+    return true;
+  }
+  if (pose.groupIds?.some((groupId) => valueHasNeedle(groupId, needles))) {
+    return true;
+  }
+  return membership.groupIds.some((groupId) => {
+    const path = membership.groupPathsById[groupId] ?? null;
+    const group = (groups ?? []).find((entry) => entry.id === groupId) ?? null;
+    return valueHasNeedle(groupId, needles) || valueHasNeedle(path, needles) || valueHasNeedle(group?.name, needles);
+  });
+}
+function resolvePoseSemantics(pose, groups) {
+  const membership = resolvePoseMembership(pose, groups);
+  const key = getPoseSemanticKey(pose);
+  const looksLikeVisemeGroup = poseMatchesGroupKind(
+    pose,
+    groups,
+    VISEME_GROUP_NEEDLES
+  );
+  const looksLikeEmotionGroup = poseMatchesGroupKind(
+    pose,
+    groups,
+    EMOTION_GROUP_NEEDLES
+  );
+  let kind = "other";
+  if (looksLikeVisemeGroup || key && VISEME_POSE_KEY_SET.has(key)) {
+    kind = "viseme";
+  } else if (looksLikeEmotionGroup || key && EMOTION_POSE_KEY_SET.has(key)) {
+    kind = "emotion";
+  }
+  return { key, kind, membership };
+}
+function filterPosesBySemanticKind(poses, groups, kind) {
+  return poses.filter(
+    (pose) => resolvePoseSemantics(pose, groups).kind === kind
+  );
+}
+function buildSemanticPoseWeightPathMap(poses, groups, faceId, kind) {
+  const map = /* @__PURE__ */ new Map();
+  const pathMap = buildPoseWeightPathMap(poses, faceId);
+  poses.forEach((pose) => {
+    const semantics = resolvePoseSemantics(pose, groups);
+    const path = pathMap.get(pose.id);
+    if (semantics.kind !== kind || !semantics.key || !path || map.has(semantics.key)) {
+      return;
+    }
+    map.set(semantics.key, path);
   });
   return map;
 }
 
+// src/utils/poseRuntime.ts
+function shouldUseLegacyPoseWeightFallback(hasPoseGraph) {
+  return !hasPoseGraph;
+}
+function resolvePoseControlInputPath({
+  inputId,
+  basePath,
+  rigInputPathMap,
+  hasNativePoseControlInput
+}) {
+  if (!inputId.trim()) {
+    return void 0;
+  }
+  return rigInputPathMap[inputId] ?? rigInputPathMap[`pose_control_${inputId}`] ?? rigInputPathMap[`direct_${inputId}`] ?? (hasNativePoseControlInput ? basePath : void 0);
+}
+
+// src/utils/clipPlayback.ts
+var EPSILON = 1e-6;
+function toFiniteNumber(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function normaliseInterpolation(interpolation) {
+  const mode = typeof interpolation === "string" ? interpolation.trim().toLowerCase() : "linear";
+  if (mode === "step") {
+    return "step";
+  }
+  if (mode === "cubic" || mode === "cubicspline") {
+    return "cubic";
+  }
+  return "linear";
+}
+function asNumericKeyframe(keyframe) {
+  if (!keyframe || typeof keyframe !== "object") {
+    return null;
+  }
+  const time = Number(keyframe.time);
+  const value = Number(keyframe.value);
+  if (!Number.isFinite(time) || !Number.isFinite(value)) {
+    return null;
+  }
+  const inTangentRaw = keyframe.inTangent;
+  const outTangentRaw = keyframe.outTangent;
+  const inTangent = inTangentRaw == null || Number.isFinite(Number(inTangentRaw)) ? inTangentRaw : void 0;
+  const outTangent = outTangentRaw == null || Number.isFinite(Number(outTangentRaw)) ? outTangentRaw : void 0;
+  return {
+    time,
+    value,
+    inTangent,
+    outTangent
+  };
+}
+function getNumericKeyframes(track) {
+  const keyframes = Array.isArray(track.keyframes) ? track.keyframes : [];
+  const numeric = keyframes.map((keyframe) => asNumericKeyframe(keyframe)).filter((keyframe) => Boolean(keyframe));
+  if (numeric.length <= 1) {
+    return numeric;
+  }
+  return [...numeric].sort((a, b) => a.time - b.time);
+}
+function resolveTangent(value, fallback) {
+  const parsed = Number(value);
+  if (Number.isFinite(parsed)) {
+    return parsed;
+  }
+  return fallback;
+}
+function sampleHermite(startValue, endValue, outTangent, inTangent, factor, duration) {
+  const t = factor;
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const h00 = 2 * t3 - 3 * t2 + 1;
+  const h10 = t3 - 2 * t2 + t;
+  const h01 = -2 * t3 + 3 * t2;
+  const h11 = t3 - t2;
+  return h00 * startValue + h10 * outTangent * duration + h01 * endValue + h11 * inTangent * duration;
+}
+function resolveClipDurationSeconds(clip, fallbackDurationSeconds = 0) {
+  const fallback = Math.max(0, toFiniteNumber(fallbackDurationSeconds, 0));
+  if (!clip || typeof clip !== "object") {
+    return fallback;
+  }
+  const clipDuration = Number(clip.duration);
+  if (Number.isFinite(clipDuration) && clipDuration > 0) {
+    return clipDuration;
+  }
+  const tracks = Array.isArray(clip.tracks) ? clip.tracks : [];
+  let maxTime = 0;
+  tracks.forEach((track) => {
+    const keyframes = getNumericKeyframes(track);
+    const last = keyframes[keyframes.length - 1];
+    if (last && last.time > maxTime) {
+      maxTime = last.time;
+    }
+  });
+  return maxTime > 0 ? maxTime : fallback;
+}
+function clampAnimationTime(time, duration) {
+  if (!Number.isFinite(duration) || duration <= 0) {
+    return 0;
+  }
+  if (!Number.isFinite(time)) {
+    return 0;
+  }
+  if (time <= 0) {
+    return 0;
+  }
+  if (time >= duration) {
+    return duration;
+  }
+  return time;
+}
+function advanceClipTime(state, dt) {
+  const duration = Math.max(0, toFiniteNumber(state.duration, 0));
+  const speed = Number.isFinite(state.speed) && state.speed > 0 ? state.speed : 1;
+  const currentTime = clampAnimationTime(state.time, duration);
+  const delta = Number.isFinite(dt) && dt > 0 ? Math.max(0, dt) * speed : 0;
+  if (!state.playing || delta <= 0) {
+    return { time: currentTime, completed: false };
+  }
+  if (duration <= 0) {
+    return { time: 0, completed: true };
+  }
+  const nextTime = currentTime + delta;
+  if (state.loop) {
+    if (nextTime < duration) {
+      return { time: nextTime, completed: false };
+    }
+    const wrapped = (nextTime % duration + duration) % duration;
+    return { time: wrapped, completed: false };
+  }
+  if (nextTime >= duration - EPSILON) {
+    return { time: duration, completed: true };
+  }
+  return { time: nextTime, completed: false };
+}
+function sampleTrackAtTime(track, timeSeconds) {
+  const keyframes = getNumericKeyframes(track);
+  if (keyframes.length === 0) {
+    return 0;
+  }
+  if (keyframes.length === 1) {
+    return keyframes[0].value;
+  }
+  const mode = normaliseInterpolation(track.interpolation);
+  const time = Number.isFinite(timeSeconds) ? timeSeconds : 0;
+  const first = keyframes[0];
+  if (time <= first.time + EPSILON) {
+    return first.value;
+  }
+  const last = keyframes[keyframes.length - 1];
+  if (time >= last.time - EPSILON) {
+    return last.value;
+  }
+  for (let i = 0; i < keyframes.length - 1; i += 1) {
+    const current = keyframes[i];
+    const next = keyframes[i + 1];
+    const start = current.time;
+    const end = next.time;
+    const duration = end - start;
+    if (duration <= EPSILON) {
+      if (time <= end + EPSILON) {
+        return next.value;
+      }
+      continue;
+    }
+    if (Math.abs(time - end) <= EPSILON) {
+      return next.value;
+    }
+    if (time < end) {
+      const factor = (time - start) / duration;
+      if (mode === "step") {
+        return current.value;
+      }
+      if (mode === "cubic") {
+        const slope = (next.value - current.value) / duration;
+        const outTangent = resolveTangent(current.outTangent, slope);
+        const inTangent = resolveTangent(next.inTangent, slope);
+        return sampleHermite(
+          current.value,
+          next.value,
+          outTangent,
+          inTangent,
+          factor,
+          duration
+        );
+      }
+      return current.value + (next.value - current.value) * factor;
+    }
+  }
+  return last.value;
+}
+
+// src/utils/animationBridge.ts
+function resolveAnimationBridgeOutputPaths(channel, faceId, rigInputMap) {
+  const normalizedChannel = channel.trim().replace(/^\/+/, "");
+  if (!normalizedChannel) {
+    return [];
+  }
+  const outputPaths = /* @__PURE__ */ new Set([normalizedChannel]);
+  if (normalizedChannel.startsWith("animation/")) {
+    return Array.from(outputPaths).sort(
+      (left, right) => left.localeCompare(right)
+    );
+  }
+  if (rigInputMap && Object.keys(rigInputMap).length > 0) {
+    const candidateKeys = /* @__PURE__ */ new Set([normalizedChannel]);
+    const rigChannelMatch2 = /^rig\/[^/]+\/(.+)$/.exec(normalizedChannel);
+    if (rigChannelMatch2?.[1]) {
+      candidateKeys.add(rigChannelMatch2[1]);
+    }
+    candidateKeys.forEach((key) => {
+      const mapped = rigInputMap[key];
+      const normalized = mapped?.trim().replace(/^\/+/, "");
+      if (normalized) {
+        outputPaths.add(normalized);
+      }
+    });
+    const suffix = normalizedChannel.includes("/") ? normalizedChannel : `/${normalizedChannel}`;
+    Object.values(rigInputMap).forEach((mappedPath) => {
+      const normalized = mappedPath?.trim().replace(/^\/+/, "");
+      if (!normalized) {
+        return;
+      }
+      if (normalized === normalizedChannel || normalized.endsWith(suffix)) {
+        outputPaths.add(normalized);
+      }
+    });
+  }
+  if (!faceId) {
+    return Array.from(outputPaths).sort(
+      (left, right) => left.localeCompare(right)
+    );
+  }
+  const rigChannelMatch = /^rig\/[^/]+\/(.+)$/.exec(normalizedChannel);
+  if (rigChannelMatch?.[1]) {
+    outputPaths.add(`rig/${faceId}/${rigChannelMatch[1]}`);
+  } else if (!normalizedChannel.startsWith("rig/")) {
+    outputPaths.add(`rig/${faceId}/${normalizedChannel}`);
+  }
+  return Array.from(outputPaths).sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+function collectAnimationClipOutputPaths(clip, faceId, rigInputMap) {
+  const outputPaths = /* @__PURE__ */ new Set();
+  const tracks = Array.isArray(clip.tracks) ? clip.tracks : [];
+  tracks.forEach((track) => {
+    const channel = typeof track.channel === "string" ? track.channel.trim() : "";
+    if (!channel) {
+      return;
+    }
+    resolveAnimationBridgeOutputPaths(channel, faceId, rigInputMap).forEach(
+      (path) => {
+        outputPaths.add(path);
+      }
+    );
+  });
+  return Array.from(outputPaths).sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+function sampleAnimationClipOutputValues(clip, timeSeconds, weight = 1, faceId, rigInputMap) {
+  const appliedWeight = Number.isFinite(weight) && weight >= 0 ? Number(weight) : 1;
+  const outputValues = /* @__PURE__ */ new Map();
+  const tracks = Array.isArray(clip.tracks) ? clip.tracks : [];
+  tracks.forEach((track) => {
+    const channel = typeof track.channel === "string" ? track.channel.trim() : "";
+    if (!channel) {
+      return;
+    }
+    const sampledValue = sampleTrackAtTime(
+      track,
+      timeSeconds
+    );
+    const weightedValue = sampledValue * appliedWeight;
+    resolveAnimationBridgeOutputPaths(channel, faceId, rigInputMap).forEach(
+      (path) => {
+        outputValues.set(path, (outputValues.get(path) ?? 0) + weightedValue);
+      }
+    );
+  });
+  return outputValues;
+}
+function diffAnimationAggregateValues(previousAggregate, nextAggregate, epsilon = 1e-6) {
+  const operations = [];
+  const changedPaths = /* @__PURE__ */ new Set();
+  previousAggregate.forEach((previousValue, path) => {
+    const nextValue = nextAggregate.get(path);
+    if (nextValue === void 0 || Math.abs(nextValue - previousValue) > epsilon) {
+      changedPaths.add(path);
+    }
+  });
+  nextAggregate.forEach((nextValue, path) => {
+    const previousValue = previousAggregate.get(path);
+    if (previousValue === void 0 || Math.abs(nextValue - previousValue) > epsilon) {
+      changedPaths.add(path);
+    }
+  });
+  changedPaths.forEach((path) => {
+    const nextValue = nextAggregate.get(path);
+    if (nextValue === void 0) {
+      operations.push({ kind: "clear", path });
+      return;
+    }
+    operations.push({ kind: "set", path, value: nextValue });
+  });
+  return operations;
+}
+
 // src/utils/valueConversion.ts
 import {
   isNormalizedValue,
@@ -219,6 +999,19 @@ var DEFAULT_MERGE = {
   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,
@@ -235,12 +1028,19 @@ function resolveEasing(easing) {
   return EASINGS.linear;
 }
 function findRootId(world) {
+  let fallback = null;
   for (const entry of Object.values(world)) {
-    if (entry && typeof entry === "object" && entry.type === "group" && entry.rootBounds && entry.id) {
+    if (!entry || typeof entry !== "object" || entry.type !== "group") {
+      continue;
+    }
+    if (entry.rootBounds && entry.id) {
       return entry.id;
     }
+    if (!fallback && entry.id) {
+      fallback = entry.id;
+    }
   }
-  return null;
+  return fallback;
 }
 function normalisePath(path) {
   if (!path) {
@@ -410,6 +1210,30 @@ function namespaceGraphSpec(spec, namespace) {
     nodes: nextNodes
   };
 }
+function stripNulls(value) {
+  if (value === null) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    const next2 = value.map((entry) => stripNulls(entry)).filter((entry) => entry !== void 0 && entry !== null);
+    return next2;
+  }
+  if (typeof value !== "object" || value === void 0) {
+    return value;
+  }
+  const next = {};
+  Object.entries(value).forEach(([key, entry]) => {
+    if (entry === null) {
+      return;
+    }
+    const cleaned = stripNulls(entry);
+    if (cleaned === void 0) {
+      return;
+    }
+    next[key] = cleaned;
+  });
+  return next;
+}
 var now = () => typeof performance !== "undefined" ? performance.now() : Date.now();
 function pickBundleGraph(bundle, preferredKinds) {
   if (!bundle?.graphs || bundle.graphs.length === 0) {
@@ -580,26 +1404,49 @@ function convertExtractedAnimations(clips) {
       }
       const parsedValueSize = track.valueSize != null ? Number(track.valueSize) : NaN;
       const valueSize = Number.isFinite(parsedValueSize) && parsedValueSize > 0 ? parsedValueSize : 1;
-      if (values.length !== times.length * valueSize) {
+      const interpolationRaw = typeof track.interpolation === "string" ? track.interpolation.trim().toLowerCase() : "linear";
+      const interpolation = interpolationRaw === "step" ? "step" : interpolationRaw === "cubic" || interpolationRaw === "cubicspline" ? "cubic" : "linear";
+      const isCubic = interpolation === "cubic";
+      const hasTripletTangents = isCubic && values.length === times.length * valueSize * 3;
+      const hasFlatValues = values.length === times.length * valueSize;
+      if (!hasTripletTangents && !hasFlatValues) {
         return;
       }
       const rawIndex = track.componentIndex != null ? Number(track.componentIndex) : 0;
       const componentIndex = Number.isInteger(rawIndex) && rawIndex >= 0 ? Math.min(rawIndex, valueSize - 1) : 0;
       const keyframes = [];
       times.forEach((time, index) => {
-        const base = index * valueSize + componentIndex;
-        const value = values[base];
+        const flatBase = index * valueSize + componentIndex;
+        const valueBase = hasTripletTangents ? index * valueSize * 3 + valueSize + componentIndex : flatBase;
+        const value = values[valueBase];
         if (!Number.isFinite(value)) {
           return;
         }
-        keyframes.push({ time, value });
+        const keyframe = {
+          time,
+          value
+        };
+        if (hasTripletTangents) {
+          const inBase = index * valueSize * 3 + componentIndex;
+          const outBase = index * valueSize * 3 + valueSize * 2 + componentIndex;
+          const inTangent = values[inBase];
+          const outTangent = values[outBase];
+          if (Number.isFinite(inTangent)) {
+            keyframe.inTangent = inTangent;
+          }
+          if (Number.isFinite(outTangent)) {
+            keyframe.outTangent = outTangent;
+          }
+        }
+        keyframes.push(keyframe);
       });
       if (keyframes.length === 0) {
         return;
       }
       convertedTracks.push({
         channel: channelId,
-        keyframes
+        keyframes,
+        interpolation
       });
     });
     if (convertedTracks.length === 0) {
@@ -666,29 +1513,91 @@ function mergeAnimationLists(explicit, fromBundle) {
   }
   return changed ? merged : explicit;
 }
-function mergeAssetBundle(base, extracted, extractedAnimations) {
-  const resolvedBundle = base.bundle ?? extracted ?? null;
-  const rigFromBundle = convertBundleGraph(
-    pickBundleGraph(resolvedBundle, ["rig"])
+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))
   );
-  const resolvedRig = base.rig ?? rigFromBundle ?? void 0;
-  const basePose = base.pose;
-  const poseStageFilter = basePose?.stageNeutralFilter;
-  const poseGraphFromBundle = basePose?.graph ? null : convertBundleGraph(
-    pickBundleGraph(resolvedBundle, ["pose-driver", "pose"])
+  if (entries.length === 0) {
+    return void 0;
+  }
+  return Object.fromEntries(
+    entries.map(([path, rawValue]) => [path, Number(rawValue)])
   );
-  const resolvedPoseGraph = basePose?.graph ?? poseGraphFromBundle ?? void 0;
-  const resolvedPoseConfig = 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;
+}
+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;
     }
-    if (resolvedPoseConfig && basePose.config !== resolvedPoseConfig) {
-      nextPose.config = resolvedPoseConfig;
+    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) {
@@ -717,6 +1626,10 @@ function mergeAssetBundle(base, extracted, extractedAnimations) {
       animationsFromAsset
     );
   }
+  const programsFromBundle = mergeProgramLists(
+    base.programs,
+    convertBundlePrograms(resolvedBundle?.graphs)
+  );
   const merged = {
     ...base
   };
@@ -727,14 +1640,106 @@ function mergeAssetBundle(base, extracted, extractedAnimations) {
   }
   merged.pose = resolvedPose;
   merged.animations = resolvedAnimations;
+  merged.programs = programsFromBundle;
   merged.bundle = resolvedBundle;
   return merged;
 }
+function normalizeStoredAnimationInterpolation(interpolation) {
+  const mode = typeof interpolation === "string" ? interpolation.trim().toLowerCase() : "linear";
+  if (mode === "step") {
+    return "step";
+  }
+  if (mode === "cubic" || mode === "cubicspline") {
+    return "cubic";
+  }
+  return "linear";
+}
+function buildStoredAnimationTransitions(mode) {
+  if (mode === "cubic") {
+    return void 0;
+  }
+  if (mode === "step") {
+    return {
+      in: { x: 1, y: 1 },
+      out: { x: 1, y: 0 }
+    };
+  }
+  return {
+    in: { x: 1, y: 1 },
+    out: { x: 0, y: 0 }
+  };
+}
+function toStoredAnimationClip(fallbackId, clip) {
+  const clipId = typeof clip.id === "string" && clip.id.trim().length > 0 ? clip.id.trim() : fallbackId;
+  const clipName = typeof clip.name === "string" && clip.name.trim().length > 0 ? clip.name.trim() : clipId;
+  const durationSeconds = resolveClipDurationSeconds(clip, 0);
+  const durationMs = Math.max(1, Math.round(durationSeconds * 1e3));
+  const tracks = (Array.isArray(clip.tracks) ? clip.tracks : []).map((rawTrack, trackIndex) => {
+    const channel = typeof rawTrack.channel === "string" ? rawTrack.channel.trim() : "";
+    if (!channel) {
+      return null;
+    }
+    const keyframes = (Array.isArray(rawTrack.keyframes) ? rawTrack.keyframes : []).map((keyframe) => {
+      const time = Number(keyframe.time);
+      const value = Number(keyframe.value);
+      const keyframeId = keyframe["id"];
+      const keyframeInterpolation = keyframe["interpolation"];
+      if (!Number.isFinite(time) || !Number.isFinite(value)) {
+        return null;
+      }
+      return {
+        id: typeof keyframeId === "string" && keyframeId.trim().length > 0 ? keyframeId.trim() : `${clipId}:track-${trackIndex.toString().padStart(4, "0")}:point-${time.toFixed(6)}`,
+        time,
+        value,
+        mode: normalizeStoredAnimationInterpolation(
+          keyframeInterpolation ?? rawTrack.interpolation
+        )
+      };
+    }).filter(Boolean);
+    if (keyframes.length === 0) {
+      return null;
+    }
+    keyframes.sort((left, right) => {
+      if (left.time !== right.time) {
+        return left.time - right.time;
+      }
+      return left.id.localeCompare(right.id);
+    });
+    const rawTrackId = rawTrack["id"];
+    const rawTrackName = rawTrack["name"];
+    const trackId = typeof rawTrackId === "string" && rawTrackId.trim().length > 0 ? rawTrackId.trim() : `${clipId}:track-${trackIndex.toString().padStart(4, "0")}`;
+    const trackName = typeof rawTrackName === "string" && rawTrackName.trim().length > 0 ? rawTrackName.trim() : channel.replace(/^\/+/, "") || trackId;
+    const denominator = durationSeconds > 0 ? durationSeconds : 1;
+    return {
+      id: trackId,
+      name: trackName,
+      animatableId: channel,
+      points: keyframes.map((keyframe) => {
+        const stamp = Math.max(0, Math.min(1, keyframe.time / denominator));
+        const transitions = buildStoredAnimationTransitions(keyframe.mode);
+        return {
+          id: keyframe.id,
+          stamp,
+          value: keyframe.value,
+          ...transitions ? { transitions } : {}
+        };
+      })
+    };
+  }).filter(Boolean);
+  return {
+    id: clipId,
+    name: clipName,
+    duration: durationMs,
+    groups: {},
+    tracks
+  };
+}
 function VizijRuntimeProvider({
   assetBundle,
   children,
   namespace: namespaceProp,
   faceId: faceIdProp,
+  updateTier = "auto",
   autoCreate = true,
   createOptions,
   autostart = false,
@@ -742,6 +1747,7 @@ function VizijRuntimeProvider({
   mergeStrategy,
   onRegisterControllers,
   onStatusChange,
+  transformOutputWrite,
   orchestratorScope = "auto"
 }) {
   const storeRef = useRef(null);
@@ -762,6 +1768,7 @@ function VizijRuntimeProvider({
       assetBundle,
       namespace: namespaceProp,
       faceId: faceIdProp,
+      updateTier,
       autoCreate,
       autostart,
       driveOrchestrator,
@@ -769,6 +1776,7 @@ function VizijRuntimeProvider({
       mergeStrategy,
       onRegisterControllers,
       onStatusChange,
+      transformOutputWrite,
       store: storeRef.current,
       children
     }
@@ -790,9 +1798,11 @@ function VizijRuntimeProviderInner({
   assetBundle: initialAssetBundle,
   namespace: namespaceProp,
   faceId: faceIdProp,
+  updateTier,
   mergeStrategy,
   onRegisterControllers,
   onStatusChange,
+  transformOutputWrite,
   store,
   children,
   autoCreate,
@@ -800,35 +1810,66 @@ function VizijRuntimeProviderInner({
   createOptions,
   driveOrchestrator
 }) {
+  const [assetBundleOverride, setAssetBundleOverride] = useState(null);
+  const [graphUpdateToken, setGraphUpdateToken] = useState(0);
+  const effectiveAssetBundle = assetBundleOverride ?? initialAssetBundle;
+  const latestEffectiveAssetBundleRef = useRef(effectiveAssetBundle);
   const [extractedBundle, setExtractedBundle] = useState(() => {
-    if (initialAssetBundle.bundle) {
-      return initialAssetBundle.bundle;
+    if (effectiveAssetBundle.bundle) {
+      return effectiveAssetBundle.bundle;
     }
-    if (initialAssetBundle.glb.kind === "world" && initialAssetBundle.glb.bundle) {
-      return initialAssetBundle.glb.bundle;
+    if (effectiveAssetBundle.glb.kind === "world" && effectiveAssetBundle.glb.bundle) {
+      return effectiveAssetBundle.glb.bundle;
     }
     return null;
   });
   const [extractedAnimations, setExtractedAnimations] = useState([]);
+  const previousBundleRef = useRef(null);
+  const suppressNextBundlePlanRef = useRef(false);
+  const pendingPlanRef = useRef(null);
+  const updateTierRef = useRef(updateTier);
   useEffect(() => {
-    if (initialAssetBundle.bundle) {
-      setExtractedBundle(initialAssetBundle.bundle);
+    if (effectiveAssetBundle.bundle) {
+      setExtractedBundle(effectiveAssetBundle.bundle);
       return;
     }
-    if (initialAssetBundle.glb.kind === "world") {
-      setExtractedBundle(initialAssetBundle.glb.bundle ?? null);
+    if (effectiveAssetBundle.glb.kind === "world") {
+      setExtractedBundle(effectiveAssetBundle.glb.bundle ?? null);
     } else {
       setExtractedBundle(null);
     }
-  }, [initialAssetBundle]);
+  }, [effectiveAssetBundle]);
+  useEffect(() => {
+    updateTierRef.current = updateTier;
+  }, [updateTier]);
   const assetBundle = useMemo(
     () => mergeAssetBundle(
-      initialAssetBundle,
+      effectiveAssetBundle,
       extractedBundle,
       extractedAnimations
     ),
-    [initialAssetBundle, extractedBundle, extractedAnimations]
+    [effectiveAssetBundle, extractedBundle, extractedAnimations]
   );
+  useEffect(() => {
+    latestEffectiveAssetBundleRef.current = effectiveAssetBundle;
+  }, [effectiveAssetBundle]);
+  useEffect(() => {
+    if (suppressNextBundlePlanRef.current) {
+      suppressNextBundlePlanRef.current = false;
+      previousBundleRef.current = effectiveAssetBundle;
+      return;
+    }
+    const plan = resolveRuntimeUpdatePlan(
+      previousBundleRef.current,
+      effectiveAssetBundle,
+      updateTierRef.current
+    );
+    pendingPlanRef.current = plan;
+    previousBundleRef.current = effectiveAssetBundle;
+    if (plan.reregisterGraphs) {
+      setGraphUpdateToken((prev) => prev + 1);
+    }
+  }, [effectiveAssetBundle]);
   const {
     ready,
     createOrchestrator,
@@ -837,6 +1878,7 @@ function VizijRuntimeProviderInner({
     registerAnimation,
     removeGraph,
     removeAnimation,
+    removeInput,
     listControllers,
     setInput: orchestratorSetInput,
     getPathSnapshot,
@@ -864,13 +1906,57 @@ function VizijRuntimeProviderInner({
   const namespaceRef = useRef(namespace);
   const driveOrchestratorRef = useRef(driveOrchestrator);
   const rigInputMapRef = useRef({});
+  const rigPoseControlInputIdsRef = useRef(/* @__PURE__ */ new Set());
   const registeredGraphsRef = useRef([]);
   const registeredAnimationsRef = useRef([]);
   const mergedGraphRef = useRef(null);
+  const poseControlBridgeValuesRef = useRef(/* @__PURE__ */ new Map());
+  const poseWeightFallbackMap = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    const poseConfig = assetBundle.pose?.config;
+    if (!poseConfig) {
+      return map;
+    }
+    const posePaths = buildPoseWeightPathMap(
+      poseConfig.poses ?? [],
+      poseConfig.faceId ?? faceId ?? "face"
+    );
+    (poseConfig.poses ?? []).forEach((pose) => {
+      const posePath = posePaths.get(pose.id);
+      if (!posePath) {
+        return;
+      }
+      const values = Object.fromEntries(
+        Object.entries(pose.values ?? {}).filter(
+          ([, value]) => Number.isFinite(value)
+        )
+      );
+      map.set(posePath, values);
+    });
+    return map;
+  }, [assetBundle.pose?.config, faceId]);
+  const useLegacyPoseWeightFallback = useMemo(
+    () => shouldUseLegacyPoseWeightFallback(Boolean(assetBundle.pose?.graph)),
+    [assetBundle.pose?.graph]
+  );
+  const resolvedProgramAssets = useMemo(
+    () => assetBundle.programs && assetBundle.programs.length > 0 ? assetBundle.programs : convertBundlePrograms(assetBundle.bundle?.graphs),
+    [assetBundle.bundle?.graphs, assetBundle.programs]
+  );
   const [inputConstraints, setInputConstraints] = useState({});
+  const inputConstraintsRef = useRef({});
   const avgStepDtRef = useRef(null);
   const animationTweensRef = useRef(/* @__PURE__ */ new Map());
   const clipPlaybackRef = useRef(/* @__PURE__ */ new Map());
+  const programPlaybackRef = useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const programControllerIdsRef = useRef(/* @__PURE__ */ new Map());
+  const clipOutputValuesRef = useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const clipAggregateValuesRef = useRef(/* @__PURE__ */ new Map());
+  const animationSystemActiveRef = useRef(true);
   const stagedInputsRef = useRef(/* @__PURE__ */ new Map());
   const autostartRef = useRef(autostart);
   const lastActivityTimeRef = useRef(now());
@@ -888,6 +1974,7 @@ function VizijRuntimeProviderInner({
   useEffect(() => {
     const rigAsset = assetBundle.rig;
     if (!rigAsset) {
+      inputConstraintsRef.current = {};
       setInputConstraints({});
       return;
     }
@@ -900,15 +1987,8 @@ function VizijRuntimeProviderInner({
       rigAsset.inputMetadata,
       namespace
     );
+    inputConstraintsRef.current = constraints;
     setInputConstraints(constraints);
-    const isDevEnv = typeof globalThis !== "undefined" && Boolean(globalThis?.process?.env?.NODE_ENV !== "production");
-    if (isDevEnv) {
-      const size = Object.keys(constraints).length;
-      console.log("[vizij-runtime] input constraints computed", size, {
-        namespace,
-        rigId: rigAsset.id
-      });
-    }
   }, [assetBundle.rig, namespace]);
   const requestLoopMode = useCallback((mode) => {
     if (!runtimeMountedRef.current) {
@@ -917,7 +1997,28 @@ function VizijRuntimeProviderInner({
     setLoopMode((prev) => prev === mode ? prev : mode);
   }, []);
   const hasActiveAnimations = useCallback(() => {
-    return animationTweensRef.current.size > 0 || clipPlaybackRef.current.size > 0;
+    if (animationTweensRef.current.size > 0) {
+      return true;
+    }
+    if (!animationSystemActiveRef.current) {
+      for (const state of programPlaybackRef.current.values()) {
+        if (state.state === "playing") {
+          return true;
+        }
+      }
+      return false;
+    }
+    for (const state of clipPlaybackRef.current.values()) {
+      if (state.playing) {
+        return true;
+      }
+    }
+    for (const state of programPlaybackRef.current.values()) {
+      if (state.state === "playing") {
+        return true;
+      }
+    }
+    return false;
   }, []);
   const computeDesiredLoopMode = useCallback(() => {
     const hasAnimations = hasActiveAnimations();
@@ -939,11 +2040,50 @@ function VizijRuntimeProviderInner({
   }, [updateLoopMode]);
   const setInput = useCallback(
     (path, value, shape) => {
+      const numericValue = valueAsNumber2(value);
+      const basePath = stripNamespace(
+        normalisePath(path),
+        namespaceRef.current
+      );
+      const poseValues = useLegacyPoseWeightFallback && numericValue != null ? poseWeightFallbackMap.get(basePath) : void 0;
+      if (poseValues && numericValue != null) {
+        const poseFaceId = assetBundle.pose?.config?.faceId ?? faceId ?? "face";
+        const rigMap = rigInputMapRef.current;
+        Object.entries(poseValues).forEach(([inputId, poseValue]) => {
+          if (!Number.isFinite(poseValue)) {
+            return;
+          }
+          const controlPath = resolvePoseControlInputPath({
+            inputId,
+            basePath: buildRigInputPath(
+              poseFaceId,
+              `/pose/control/${inputId}`
+            ),
+            rigInputPathMap: rigMap,
+            hasNativePoseControlInput: true
+          }) ?? buildRigInputPath(poseFaceId, `/pose/control/${inputId}`);
+          setInput(controlPath, { float: Number(poseValue) * numericValue });
+        });
+        return;
+      }
       markActivity();
       const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
+      if (isRuntimeDebugEnabled() && (namespacedPath.includes("animation/authoring.timeline.main") || namespacedPath.endsWith("/blink"))) {
+        console.log("[vizij-runtime] stage input", {
+          path,
+          namespacedPath,
+          value
+        });
+      }
       stagedInputsRef.current.set(namespacedPath, { value, shape });
     },
-    [markActivity]
+    [
+      assetBundle.pose?.config?.faceId,
+      faceId,
+      markActivity,
+      poseWeightFallbackMap,
+      useLegacyPoseWeightFallback
+    ]
   );
   const reportStatus = useCallback(
     (updater) => {
@@ -1007,10 +2147,14 @@ function VizijRuntimeProviderInner({
     });
     registeredGraphsRef.current = [];
     registeredAnimationsRef.current = [];
+    programControllerIdsRef.current.clear();
     mergedGraphRef.current = null;
     outputPathsRef.current = /* @__PURE__ */ new Set();
     baseOutputPathsRef.current = /* @__PURE__ */ new Set();
     namespacedOutputPathsRef.current = /* @__PURE__ */ new Set();
+    rigPoseControlInputIdsRef.current = /* @__PURE__ */ new Set();
+    clipOutputValuesRef.current.clear();
+    clipAggregateValuesRef.current.clear();
   }, [listControllers, removeAnimation, removeGraph, pushError]);
   useEffect(() => {
     namespaceRef.current = namespace;
@@ -1023,10 +2167,19 @@ function VizijRuntimeProviderInner({
   useEffect(() => {
     driveOrchestratorRef.current = driveOrchestrator;
   }, [driveOrchestrator]);
-  const glbAsset = initialAssetBundle.glb;
-  const baseBundle = initialAssetBundle.bundle ?? null;
+  const glbAsset = effectiveAssetBundle.glb;
+  const baseBundle = effectiveAssetBundle.bundle ?? null;
   useEffect(() => {
     let cancelled = false;
+    const plan = pendingPlanRef.current;
+    if (plan && !plan.reloadAssets && status.rootId !== null) {
+      reportStatus(
+        (prev) => prev.loading ? { ...prev, loading: false } : prev
+      );
+      return () => {
+        cancelled = true;
+      };
+    }
     resetErrors();
     reportStatus((prev) => ({
       ...prev,
@@ -1078,6 +2231,12 @@ function VizijRuntimeProviderInner({
         setExtractedAnimations(convertExtractedAnimations(gltfAnimations));
         const rootId = findRootId(world);
         store.getState().addWorldElements(world, animatables, true);
+        if (pendingPlanRef.current?.reloadAssets) {
+          pendingPlanRef.current = {
+            ...pendingPlanRef.current,
+            reloadAssets: false
+          };
+        }
         reportStatus((prev) => ({
           ...prev,
           loading: false,
@@ -1115,7 +2274,8 @@ function VizijRuntimeProviderInner({
     reportStatus,
     resetErrors,
     setExtractedBundle,
-    setExtractedAnimations
+    setExtractedAnimations,
+    status.rootId
   ]);
   useEffect(() => {
     if (!ready && autoCreate) {
@@ -1131,6 +2291,15 @@ function VizijRuntimeProviderInner({
   }, [ready, autoCreate, createOptions, createOrchestrator, pushError]);
   const registerControllers = useCallback(async () => {
     clearControllers();
+    if (isRuntimeDebugEnabled()) {
+      console.log("[vizij-runtime] registerControllers", {
+        hasRig: Boolean(assetBundle.rig),
+        hasPose: Boolean(assetBundle.pose?.graph),
+        animationCount: assetBundle.animations?.length ?? 0,
+        animationIds: (assetBundle.animations ?? []).map((anim) => anim.id),
+        namespace
+      });
+    }
     const baseOutputPaths = /* @__PURE__ */ new Set();
     const namespacedOutputPaths = /* @__PURE__ */ new Set();
     const recordOutputs = (paths) => {
@@ -1142,39 +2311,60 @@ function VizijRuntimeProviderInner({
         namespacedOutputPaths.add(namespaceTypedPath(trimmed, namespace));
       });
     };
+    const graphConfigs = [];
+    rigInputMapRef.current = {};
+    rigPoseControlInputIdsRef.current = /* @__PURE__ */ new Set();
+    poseControlBridgeValuesRef.current.clear();
     const rigAsset = assetBundle.rig;
-    if (!rigAsset) {
-      pushError({
-        message: "Asset bundle is missing a rig graph.",
-        phase: "registration",
-        timestamp: performance.now()
-      });
-      return;
-    }
-    const rigSpec = resolveGraphSpec(rigAsset, `${rigAsset.id ?? "rig"} graph`);
-    if (!rigSpec) {
-      pushError({
-        message: "Rig graph is missing a usable spec or IR payload.",
-        phase: "registration",
-        timestamp: performance.now()
-      });
-      return;
-    }
-    const rigOutputs = collectOutputPaths(rigSpec);
-    const rigInputs = collectInputPaths(rigSpec);
-    rigInputMapRef.current = collectInputPathMap(rigSpec);
-    recordOutputs(rigOutputs);
-    const rigSubs = rigAsset.subscriptions ?? {
-      inputs: rigInputs,
-      outputs: rigOutputs
-    };
-    const graphConfigs = [
-      {
-        id: namespaceControllerId(rigAsset.id, namespace, "graph"),
-        spec: namespaceGraphSpec(rigSpec, namespace),
-        subs: namespaceSubscriptions(rigSubs, namespace)
+    if (rigAsset) {
+      const rigSpec = resolveGraphSpec(
+        rigAsset,
+        `${rigAsset.id ?? "rig"} graph`
+      );
+      if (!rigSpec) {
+        pushError({
+          message: "Rig graph is missing a usable spec or IR payload.",
+          phase: "registration",
+          timestamp: performance.now()
+        });
+      } else {
+        const rigOutputs = collectOutputPaths(rigSpec);
+        const rigInputs = collectInputPaths(rigSpec);
+        const rigPoseControlInputIds = /* @__PURE__ */ new Set();
+        rigInputs.forEach((path) => {
+          const poseControlMatch = /^rig\/[^/]+\/pose\/control\/(.+)$/.exec(
+            path.trim()
+          );
+          const inputId = (poseControlMatch?.[1] ?? "").trim();
+          if (inputId.length > 0) {
+            rigPoseControlInputIds.add(inputId);
+          }
+        });
+        rigInputMapRef.current = collectInputPathMap(rigSpec);
+        rigPoseControlInputIdsRef.current = rigPoseControlInputIds;
+        if (isRuntimeDebugEnabled()) {
+          const blinkKeys = Object.keys(rigInputMapRef.current).filter(
+            (key) => key.toLowerCase().includes("blink")
+          );
+          const blinkMappings = blinkKeys.slice(0, 20).map((key) => `${key} => ${rigInputMapRef.current[key] ?? "?"}`);
+          console.log("[vizij-runtime] rig input map sample", {
+            blink: rigInputMapRef.current["blink"] ?? null,
+            blinkKeys: blinkKeys.slice(0, 12),
+            blinkMappings: blinkMappings.join(" | ")
+          });
+        }
+        recordOutputs(rigOutputs);
+        const rigSubs = rigAsset.subscriptions ?? {
+          inputs: rigInputs,
+          outputs: rigOutputs
+        };
+        graphConfigs.push({
+          id: namespaceControllerId(rigAsset.id, namespace, "graph"),
+          spec: stripNulls(namespaceGraphSpec(rigSpec, namespace)),
+          subs: namespaceSubscriptions(rigSubs, namespace)
+        });
       }
-    ];
+    }
     const poseGraphAsset = assetBundle.pose?.graph;
     if (poseGraphAsset) {
       const poseSpec = resolveGraphSpec(
@@ -1191,7 +2381,7 @@ function VizijRuntimeProviderInner({
         };
         graphConfigs.push({
           id: namespaceControllerId(poseGraphAsset.id, namespace, "graph"),
-          spec: namespaceGraphSpec(poseSpec, namespace),
+          spec: stripNulls(namespaceGraphSpec(poseSpec, namespace)),
           subs: namespaceSubscriptions(poseSubs, namespace)
         });
       } else {
@@ -1200,6 +2390,31 @@ function VizijRuntimeProviderInner({
         );
       }
     }
+    for (const animation of assetBundle.animations ?? []) {
+      const bridgeOutputs = collectAnimationClipOutputPaths(
+        animation.clip,
+        faceId ?? void 0,
+        rigInputMapRef.current
+      );
+      if (isRuntimeDebugEnabled()) {
+        console.log("[vizij-runtime] animation output routing", {
+          animationId: animation.id,
+          bridgeOutputs,
+          bridgeOutputsText: bridgeOutputs.join(" | ")
+        });
+      }
+      recordOutputs(bridgeOutputs);
+    }
+    for (const program of resolvedProgramAssets) {
+      const programSpec = resolveGraphSpec(
+        program.graph,
+        `${program.id ?? "program"} graph (outputs)`
+      );
+      if (!programSpec) {
+        continue;
+      }
+      recordOutputs(collectOutputPaths(programSpec));
+    }
     outputPathsRef.current = namespacedOutputPaths;
     baseOutputPathsRef.current = baseOutputPaths;
     namespacedOutputPathsRef.current = namespacedOutputPaths;
@@ -1232,20 +2447,30 @@ function VizijRuntimeProviderInner({
       });
     }
     registeredGraphsRef.current = graphIds;
+    if (isRuntimeDebugEnabled()) {
+      console.log("[vizij-runtime] registered graph ids", graphIds);
+    }
     const animationIds = [];
     for (const anim of assetBundle.animations ?? []) {
       try {
         const controllerId = namespaceControllerId(anim.id, namespace, "animation") ?? anim.id;
+        const animationPayload = anim.setup?.animation ?? toStoredAnimationClip(anim.id, anim.clip);
         const config = {
           id: controllerId,
           setup: {
-            animation: anim.clip,
-            ...anim.setup ?? {}
+            ...anim.setup ?? {},
+            animation: animationPayload
           }
         };
         const id = registerAnimation(config);
         animationIds.push(id);
       } catch (err) {
+        if (isRuntimeDebugEnabled()) {
+          console.warn("[vizij-runtime] failed animation registration", {
+            animationId: anim.id,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
         pushError({
           message: `Failed to register animation ${anim.id}`,
           cause: err,
@@ -1270,6 +2495,13 @@ function VizijRuntimeProviderInner({
       });
     }
     const controllers = listControllers();
+    if (isRuntimeDebugEnabled()) {
+      console.log("[vizij-runtime] controllers after register", {
+        controllers,
+        graphIds,
+        animationIds
+      });
+    }
     reportStatus((prev) => ({
       ...prev,
       ready: true,
@@ -1289,12 +2521,18 @@ function VizijRuntimeProviderInner({
     registerGraph,
     registerMergedGraph,
     reportStatus,
+    resolvedProgramAssets,
     setInput
   ]);
   useEffect(() => {
     if (!ready || status.loading) {
       return;
     }
+    const plan = pendingPlanRef.current;
+    const hasRegistered = registeredGraphsRef.current.length > 0 || registeredAnimationsRef.current.length > 0 || programControllerIdsRef.current.size > 0;
+    if (plan && !plan.reregisterGraphs && hasRegistered) {
+      return;
+    }
     registerControllers().catch((err) => {
       pushError({
         message: "Failed to register controllers",
@@ -1303,7 +2541,7 @@ function VizijRuntimeProviderInner({
         timestamp: performance.now()
       });
     });
-  }, [ready, status.loading, registerControllers, pushError]);
+  }, [ready, status.loading, graphUpdateToken, registerControllers, pushError]);
   useEffect(() => {
     if (!frame) {
       return;
@@ -1314,26 +2552,66 @@ function VizijRuntimeProviderInner({
     }
     const setWorldValues = store.getState().setValues;
     const namespaceValue = status.namespace;
+    const currentValues = store.getState().values;
+    const rigInputPathMap = rigInputMapRef.current;
+    const rigPoseControlInputIds = rigPoseControlInputIdsRef.current;
     const batched = [];
     const namespacedOutputs = namespacedOutputPathsRef.current;
     const baseOutputs = baseOutputPathsRef.current;
     writes.forEach((write) => {
       const path = normalisePath(write.path);
-      if (!namespacedOutputs.has(path)) {
+      const basePath = stripNamespace(path, namespaceValue);
+      const isTrackedOutput = namespacedOutputs.has(path) || baseOutputs.has(basePath);
+      if (!isTrackedOutput) {
         return;
       }
       const raw = valueJSONToRaw(write.value);
       if (raw === void 0) {
         return;
       }
-      const basePath = stripNamespace(path, namespaceValue);
+      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;
-      batched.push({ id: targetPath, namespace: namespaceValue, value: raw });
+      const currentValue = currentValues.get(
+        getLookup(namespaceValue, targetPath)
+      );
+      const nextWrite = transformOutputWrite ? transformOutputWrite({
+        id: targetPath,
+        namespace: namespaceValue,
+        value: raw,
+        currentValue
+      }) : {
+        id: targetPath,
+        namespace: namespaceValue,
+        value: raw
+      };
+      if (nextWrite) {
+        batched.push(nextWrite);
+      }
     });
     if (batched.length > 0) {
       setWorldValues(batched);
     }
-  }, [frame, status.namespace, store]);
+  }, [frame, status.namespace, store, transformOutputWrite]);
   const stagePoseNeutral = useCallback(
     (force = false) => {
       const neutral = assetBundle.pose?.config?.neutralInputs ?? {};
@@ -1401,88 +2679,237 @@ function VizijRuntimeProviderInner({
     },
     [setInput]
   );
-  const sampleTrack = useCallback(
-    (track, time) => {
-      const keyframes = Array.isArray(track.keyframes) ? track.keyframes : [];
-      if (!keyframes.length) {
-        return 0;
-      }
-      const first = keyframes[0];
-      if (!first) {
-        return 0;
-      }
-      if (time <= Number(first.time ?? 0)) {
-        return Number(first.value ?? 0);
-      }
-      for (let i = 0; i < keyframes.length - 1; i += 1) {
-        const current = keyframes[i] ?? {};
-        const next = keyframes[i + 1] ?? {};
-        const start = Number(current.time ?? 0);
-        const end = Number(next.time ?? start);
-        if (time >= start && time <= end) {
-          const range = end - start || 1;
-          const factor = (time - start) / range;
-          const currentValue = Number(current.value ?? 0);
-          const nextValue = Number(next.value ?? currentValue);
-          return currentValue + (nextValue - currentValue) * factor;
+  const resolveClipById = useCallback(
+    (id) => {
+      return assetBundle.animations?.find((anim) => anim.id === id);
+    },
+    [assetBundle.animations]
+  );
+  const resolveClipPromise = useCallback((state) => {
+    state.resolve?.();
+    state.resolve = null;
+    state.completion = null;
+  }, []);
+  const ensureClipPromise = useCallback((state) => {
+    if (state.completion) {
+      return state.completion;
+    }
+    const completion = new Promise((resolve) => {
+      state.resolve = resolve;
+    });
+    state.completion = completion;
+    return completion;
+  }, []);
+  const setAnimationInput = useCallback(
+    (path, value, options) => {
+      setInput(path, { float: value });
+      if (!options?.immediate) {
+        return;
+      }
+      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
+      const staged = stagedInputsRef.current.get(namespacedPath);
+      if (staged) {
+        orchestratorSetInput(namespacedPath, staged.value, staged.shape);
+        stagedInputsRef.current.delete(namespacedPath);
+        return;
+      }
+      orchestratorSetInput(namespacedPath, { float: value });
+    },
+    [orchestratorSetInput, setInput]
+  );
+  const clearAnimationInput = useCallback(
+    (path) => {
+      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
+      stagedInputsRef.current.delete(namespacedPath);
+      removeInput(namespacedPath);
+    },
+    [removeInput]
+  );
+  const buildClipOutputValues = useCallback(
+    (clip, state) => sampleAnimationClipOutputValues(
+      clip.clip,
+      state.time,
+      state.weight,
+      faceId ?? void 0,
+      rigInputMapRef.current
+    ),
+    [faceId]
+  );
+  const computeClipAggregateValues = useCallback(() => {
+    const aggregate = /* @__PURE__ */ new Map();
+    clipOutputValuesRef.current.forEach((outputValues) => {
+      outputValues.forEach((value, path) => {
+        aggregate.set(path, (aggregate.get(path) ?? 0) + value);
+      });
+    });
+    return aggregate;
+  }, []);
+  const stageClipAggregateValues = useCallback(
+    (nextAggregate, options) => {
+      diffAnimationAggregateValues(
+        clipAggregateValuesRef.current,
+        nextAggregate,
+        POSE_CONTROL_BRIDGE_EPSILON
+      ).forEach((operation) => {
+        if (operation.kind === "clear") {
+          clearAnimationInput(operation.path);
+          return;
         }
+        setAnimationInput(operation.path, operation.value, options);
+      });
+      clipAggregateValuesRef.current = nextAggregate;
+    },
+    [clearAnimationInput, setAnimationInput]
+  );
+  const syncClipOutputs = useCallback(
+    (options) => {
+      stageClipAggregateValues(computeClipAggregateValues(), options);
+    },
+    [computeClipAggregateValues, stageClipAggregateValues]
+  );
+  const writeClipOutputs = useCallback(
+    (clip, state, options) => {
+      if (!animationSystemActiveRef.current) {
+        return;
       }
-      const last = keyframes[keyframes.length - 1];
-      return Number(last?.value ?? 0);
+      clipOutputValuesRef.current.set(
+        clip.id,
+        buildClipOutputValues(clip, state)
+      );
+      syncClipOutputs(options);
+    },
+    [buildClipOutputValues, syncClipOutputs]
+  );
+  const clearClipOutputs = useCallback(
+    (clipId, options) => {
+      if (!clipOutputValuesRef.current.has(clipId)) {
+        return;
+      }
+      clipOutputValuesRef.current.delete(clipId);
+      syncClipOutputs(options);
+    },
+    [syncClipOutputs]
+  );
+  const createClipPlaybackState = useCallback(
+    (clip) => {
+      const duration = resolveClipDurationSeconds(
+        clip.clip
+      );
+      return {
+        id: clip.id,
+        time: 0,
+        duration,
+        speed: 1,
+        weight: Number.isFinite(clip.weight) ? Number(clip.weight) : 1,
+        loop: false,
+        playing: false,
+        resolve: null,
+        completion: null
+      };
     },
     []
   );
+  const ensureClipPlaybackState = useCallback(
+    (id) => {
+      const clip = resolveClipById(id);
+      if (!clip) {
+        return null;
+      }
+      const existing = clipPlaybackRef.current.get(id);
+      if (existing) {
+        existing.duration = resolveClipDurationSeconds(
+          clip.clip,
+          existing.duration
+        );
+        existing.time = clampAnimationTime(existing.time, existing.duration);
+        return { clip, state: existing };
+      }
+      const next = createClipPlaybackState(clip);
+      clipPlaybackRef.current.set(id, next);
+      return { clip, state: next };
+    },
+    [createClipPlaybackState, resolveClipById]
+  );
   const advanceClipPlayback = useCallback(
     (dt) => {
       if (clipPlaybackRef.current.size === 0) {
         return;
       }
-      const map = clipPlaybackRef.current;
       const toDelete = [];
-      map.forEach((state, key) => {
-        state.time += dt * state.speed;
-        const clip = assetBundle.animations?.find(
-          (anim) => anim.id === state.id
-        );
+      clipPlaybackRef.current.forEach((state, key) => {
+        const clip = resolveClipById(state.id);
         if (!clip) {
           toDelete.push(key);
-          state.resolve();
+          resolveClipPromise(state);
           return;
         }
-        const clipData = clip.clip;
-        const duration = Number(clipData?.duration ?? state.duration);
-        state.duration = Number.isFinite(duration) && duration > 0 ? duration : state.duration;
-        if (state.time >= state.duration) {
-          toDelete.push(key);
-          state.time = state.duration;
+        state.duration = resolveClipDurationSeconds(
+          clip.clip,
+          state.duration
+        );
+        const { time, completed } = advanceClipTime(
+          {
+            time: state.time,
+            duration: state.duration,
+            speed: state.speed,
+            loop: state.loop,
+            playing: state.playing
+          },
+          dt
+        );
+        state.time = clampAnimationTime(time, state.duration);
+        if (state.playing || completed) {
+          writeClipOutputs(clip, state);
         }
-        const tracks = Array.isArray(clipData?.tracks) ? clipData.tracks : [];
-        tracks.forEach((track) => {
-          const value = sampleTrack(track, state.time) * state.weight;
-          const path = `animation/${clip.id}/${track.channel}`;
-          setInput(path, { float: value });
-        });
-        if (toDelete.includes(key)) {
-          state.resolve();
+        if (completed) {
+          toDelete.push(key);
+          resolveClipPromise(state);
         }
       });
       toDelete.forEach((key) => {
         clipPlaybackRef.current.delete(key);
-        const clip = assetBundle.animations?.find((anim) => anim.id === key);
-        if (clip) {
-          const clipData = clip.clip;
-          const tracks = Array.isArray(clipData?.tracks) ? clipData.tracks : [];
-          tracks.forEach((track) => {
-            const path = `animation/${clip.id}/${track.channel}`;
-            setInput(path, { float: 0 });
-          });
+        if (animationSystemActiveRef.current) {
+          clearClipOutputs(key);
         }
       });
     },
-    [assetBundle.animations, sampleTrack, setInput]
+    [clearClipOutputs, resolveClipById, resolveClipPromise, writeClipOutputs]
   );
   const animateValue = useCallback(
     (path, target, options) => {
+      const targetValue = valueAsNumber2(target);
+      const basePath = stripNamespace(
+        normalisePath(path),
+        namespaceRef.current
+      );
+      const poseValues = useLegacyPoseWeightFallback && targetValue != null ? poseWeightFallbackMap.get(basePath) : void 0;
+      if (poseValues && targetValue != null) {
+        const poseFaceId = assetBundle.pose?.config?.faceId ?? faceId ?? "face";
+        const rigMap = rigInputMapRef.current;
+        return Promise.all(
+          Object.entries(poseValues).flatMap(([inputId, poseValue]) => {
+            if (!Number.isFinite(poseValue)) {
+              return [];
+            }
+            const controlPath = resolvePoseControlInputPath({
+              inputId,
+              basePath: buildRigInputPath(
+                poseFaceId,
+                `/pose/control/${inputId}`
+              ),
+              rigInputPathMap: rigMap,
+              hasNativePoseControlInput: true
+            }) ?? buildRigInputPath(poseFaceId, `/pose/control/${inputId}`);
+            return [
+              animateValue(
+                controlPath,
+                { float: Number(poseValue) * targetValue },
+                options
+              )
+            ];
+          })
+        ).then(() => void 0);
+      }
       const easing = resolveEasing(options?.easing);
       const duration = Math.max(0, options?.duration ?? DEFAULT_DURATION);
       cancelAnimation(path);
@@ -1496,7 +2923,9 @@ function VizijRuntimeProviderInner({
       }
       return new Promise((resolve) => {
         animationTweensRef.current.set(path, {
-          path: namespacedPath,
+          // 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,
@@ -1507,54 +2936,377 @@ function VizijRuntimeProviderInner({
         markActivity();
       });
     },
-    [cancelAnimation, getPathSnapshot, markActivity, setInput]
+    [
+      assetBundle.pose?.config?.faceId,
+      cancelAnimation,
+      faceId,
+      getPathSnapshot,
+      markActivity,
+      poseWeightFallbackMap,
+      setInput,
+      useLegacyPoseWeightFallback
+    ]
   );
   const playAnimation = useCallback(
     (id, options) => {
-      const clip = assetBundle.animations?.find((anim) => anim.id === id);
-      if (!clip) {
+      const ensured = ensureClipPlaybackState(id);
+      if (!ensured) {
         return Promise.reject(
           new Error(`Animation ${id} is not part of the current asset bundle.`)
         );
       }
-      if (clipPlaybackRef.current.has(id)) {
-        clipPlaybackRef.current.delete(id);
+      const { clip, state } = ensured;
+      const shouldReset = options?.reset === true;
+      if (shouldReset) {
+        resolveClipPromise(state);
+        state.time = 0;
       }
-      return new Promise((resolve) => {
-        const speed = options?.speed ?? 1;
-        const weight = options?.weight ?? clip.weight ?? 1;
-        const clipData = clip.clip;
-        clipPlaybackRef.current.set(id, {
-          id,
-          time: options?.reset ? 0 : 0,
-          duration: Number(clipData?.duration ?? 0),
-          speed: Number.isFinite(speed) && speed > 0 ? speed : 1,
-          weight,
-          resolve
-        });
-        markActivity();
-      });
+      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;
     },
-    [assetBundle.animations, markActivity]
+    [
+      ensureClipPlaybackState,
+      ensureClipPromise,
+      markActivity,
+      resolveClipPromise,
+      writeClipOutputs
+    ]
   );
-  const stopAnimation = useCallback(
+  const pauseAnimation = useCallback(
     (id) => {
-      const clip = assetBundle.animations?.find((anim) => anim.id === id);
+      const state = clipPlaybackRef.current.get(id);
+      if (!state || !state.playing) {
+        return;
+      }
+      state.playing = false;
+      updateLoopMode();
+    },
+    [updateLoopMode]
+  );
+  const seekAnimation = useCallback(
+    (id, timeSeconds) => {
+      const ensured = ensureClipPlaybackState(id);
+      if (!ensured) {
+        return;
+      }
+      const { clip, state } = ensured;
+      state.time = clampAnimationTime(timeSeconds, state.duration);
+      clipPlaybackRef.current.set(id, state);
+      writeClipOutputs(clip, state, { immediate: true });
+    },
+    [ensureClipPlaybackState, writeClipOutputs]
+  );
+  const setAnimationLoop = useCallback(
+    (id, enabled) => {
+      const ensured = ensureClipPlaybackState(id);
+      if (!ensured) {
+        return;
+      }
+      ensured.state.loop = Boolean(enabled);
+      clipPlaybackRef.current.set(id, ensured.state);
+      updateLoopMode();
+    },
+    [ensureClipPlaybackState, updateLoopMode]
+  );
+  const getAnimationState = 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 = useCallback(
+    (id, options) => {
       const state = clipPlaybackRef.current.get(id);
       if (state) {
         clipPlaybackRef.current.delete(id);
-        state.resolve();
+        state.playing = false;
+        resolveClipPromise(state);
       }
-      if (clip) {
-        const clipData = clip.clip;
-        const tracks = Array.isArray(clipData?.tracks) ? clipData.tracks : [];
-        tracks.forEach((track) => {
-          const path = `animation/${clip.id}/${track.channel}`;
-          setInput(path, { float: 0 });
+      if (options?.clearOutputs !== false) {
+        clearClipOutputs(id);
+      }
+      updateLoopMode();
+    },
+    [clearClipOutputs, resolveClipPromise, updateLoopMode]
+  );
+  const refreshControllerStatus = useCallback(() => {
+    const controllers = listControllers();
+    reportStatus((prev) => ({
+      ...prev,
+      controllers,
+      outputPaths: Array.from(outputPathsRef.current)
+    }));
+    onRegisterControllers?.(controllers);
+  }, [listControllers, onRegisterControllers, reportStatus]);
+  const resolveProgramById = useCallback(
+    (id) => {
+      return resolvedProgramAssets.find((program) => program.id === id);
+    },
+    [resolvedProgramAssets]
+  );
+  const buildProgramRegistrationConfig = useCallback(
+    (program) => {
+      const graphSpec = resolveGraphSpec(
+        program.graph,
+        `${program.id ?? "program"} graph`
+      );
+      if (!graphSpec) {
+        return null;
+      }
+      const outputs = collectOutputPaths(graphSpec);
+      const inputs = collectInputPaths(graphSpec);
+      const subs = program.graph.subscriptions ?? {
+        inputs,
+        outputs
+      };
+      return {
+        id: namespaceControllerId(program.id, namespace, "graph"),
+        spec: stripNulls(namespaceGraphSpec(graphSpec, namespace)),
+        subs: namespaceSubscriptions(subs, namespace)
+      };
+    },
+    [namespace]
+  );
+  const deriveProgramResetValues = useCallback(
+    (program) => {
+      if (program.resetValues) {
+        return Object.entries(program.resetValues).filter(([, value]) => Number.isFinite(value)).map(([path, value]) => ({ path, value }));
+      }
+      const graphSpec = resolveGraphSpec(
+        program.graph,
+        `${program.id ?? "program"} graph (reset)`
+      );
+      if (!graphSpec) {
+        return [];
+      }
+      return collectOutputPaths(graphSpec).filter((path) => path.trim().length > 0).map((path) => {
+        const defaultValue = inputConstraintsRef.current[path]?.defaultValue ?? 0;
+        return {
+          path,
+          value: Number.isFinite(defaultValue) && defaultValue != null ? defaultValue : 0
+        };
+      });
+    },
+    []
+  );
+  const syncProgramPlaybackControllers = useCallback(() => {
+    if (!ready) {
+      return;
+    }
+    const availableProgramIds = new Set(
+      resolvedProgramAssets.map((program) => program.id)
+    );
+    Array.from(programPlaybackRef.current.keys()).forEach((id) => {
+      if (availableProgramIds.has(id)) {
+        return;
+      }
+      programPlaybackRef.current.delete(id);
+      const controllerId = programControllerIdsRef.current.get(id);
+      if (controllerId) {
+        try {
+          removeGraph(controllerId);
+        } catch (err) {
+          pushError({
+            message: `Failed to remove program ${id}`,
+            cause: err,
+            phase: "registration",
+            timestamp: performance.now()
+          });
+        }
+        programControllerIdsRef.current.delete(id);
+      }
+    });
+    programPlaybackRef.current.forEach((state, id) => {
+      const program = resolveProgramById(id);
+      const controllerId = programControllerIdsRef.current.get(id);
+      if (!program) {
+        return;
+      }
+      if (state.state !== "playing") {
+        if (!controllerId) {
+          return;
+        }
+        try {
+          removeGraph(controllerId);
+        } catch (err) {
+          pushError({
+            message: `Failed to pause program ${id}`,
+            cause: err,
+            phase: "registration",
+            timestamp: performance.now()
+          });
+        }
+        programControllerIdsRef.current.delete(id);
+        return;
+      }
+      if (controllerId) {
+        return;
+      }
+      const config = buildProgramRegistrationConfig(program);
+      if (!config) {
+        pushError({
+          message: `Program ${id} is missing a usable graph payload.`,
+          phase: "registration",
+          timestamp: performance.now()
+        });
+        return;
+      }
+      try {
+        const nextControllerId = registerGraph(config);
+        programControllerIdsRef.current.set(id, nextControllerId);
+      } catch (err) {
+        pushError({
+          message: `Failed to register program ${id}`,
+          cause: err,
+          phase: "registration",
+          timestamp: performance.now()
         });
       }
+    });
+    refreshControllerStatus();
+  }, [
+    buildProgramRegistrationConfig,
+    pushError,
+    ready,
+    refreshControllerStatus,
+    registerGraph,
+    removeGraph,
+    resolvedProgramAssets,
+    resolveProgramById
+  ]);
+  const playProgram = useCallback(
+    (id) => {
+      if (!resolveProgramById(id)) {
+        throw new Error(
+          `Program ${id} is not part of the current asset bundle.`
+        );
+      }
+      programPlaybackRef.current.set(id, {
+        id,
+        state: "playing"
+      });
+      syncProgramPlaybackControllers();
+      markActivity();
     },
-    [assetBundle.animations, setInput]
+    [markActivity, resolveProgramById, syncProgramPlaybackControllers]
+  );
+  const pauseProgram = useCallback(
+    (id) => {
+      if (!resolveProgramById(id)) {
+        return;
+      }
+      programPlaybackRef.current.set(id, {
+        id,
+        state: "paused"
+      });
+      syncProgramPlaybackControllers();
+      updateLoopMode();
+    },
+    [resolveProgramById, syncProgramPlaybackControllers, updateLoopMode]
+  );
+  const stopProgram = useCallback(
+    (id, options) => {
+      const program = resolveProgramById(id);
+      const controllerId = programControllerIdsRef.current.get(id);
+      if (controllerId) {
+        try {
+          removeGraph(controllerId);
+        } catch (err) {
+          pushError({
+            message: `Failed to stop program ${id}`,
+            cause: err,
+            phase: "registration",
+            timestamp: performance.now()
+          });
+        }
+        programControllerIdsRef.current.delete(id);
+      }
+      programPlaybackRef.current.set(id, {
+        id,
+        state: "stopped"
+      });
+      if (program && options?.resetOutputs !== false) {
+        deriveProgramResetValues(program).forEach(({ path, value }) => {
+          setInput(path, { float: value });
+        });
+      }
+      refreshControllerStatus();
+      updateLoopMode();
+    },
+    [
+      deriveProgramResetValues,
+      pushError,
+      refreshControllerStatus,
+      removeGraph,
+      resolveProgramById,
+      setInput,
+      updateLoopMode
+    ]
+  );
+  const getProgramState = useCallback(
+    (id) => {
+      const state = programPlaybackRef.current.get(id);
+      if (!state) {
+        return null;
+      }
+      return { state: state.state };
+    },
+    []
+  );
+  useEffect(() => {
+    if (!ready || status.loading) {
+      return;
+    }
+    syncProgramPlaybackControllers();
+  }, [
+    graphUpdateToken,
+    ready,
+    resolvedProgramAssets,
+    status.loading,
+    syncProgramPlaybackControllers
+  ]);
+  const setAnimationActive = useCallback(
+    (active) => {
+      const next = Boolean(active);
+      if (animationSystemActiveRef.current === next) {
+        return;
+      }
+      animationSystemActiveRef.current = next;
+      if (!next) {
+        clipPlaybackRef.current.forEach((state) => {
+          state.playing = false;
+        });
+      }
+      updateLoopMode();
+    },
+    [updateLoopMode]
+  );
+  const isAnimationActive = useCallback(
+    () => animationSystemActiveRef.current,
+    []
   );
   const registerInputDriver = useCallback(
     (id, factory) => {
@@ -1695,6 +3447,10 @@ function VizijRuntimeProviderInner({
     return () => {
       animationTweensRef.current.clear();
       clipPlaybackRef.current.clear();
+      programPlaybackRef.current.clear();
+      programControllerIdsRef.current.clear();
+      clipOutputValuesRef.current.clear();
+      clipAggregateValuesRef.current.clear();
     };
   }, []);
   useEffect(() => {
@@ -1710,18 +3466,61 @@ function VizijRuntimeProviderInner({
     }, 500);
     return () => window.clearInterval(id);
   }, [reportStatus]);
+  const setGraphBundle = useCallback(
+    (bundle, options) => {
+      const baseAssetBundle = latestEffectiveAssetBundleRef.current;
+      const nextAssetBundle = applyRuntimeGraphBundle(baseAssetBundle, bundle);
+      const plan = resolveRuntimeUpdatePlan(
+        baseAssetBundle,
+        nextAssetBundle,
+        options?.tier ?? updateTierRef.current
+      );
+      pendingPlanRef.current = plan;
+      previousBundleRef.current = nextAssetBundle;
+      latestEffectiveAssetBundleRef.current = nextAssetBundle;
+      suppressNextBundlePlanRef.current = true;
+      setAssetBundleOverride(nextAssetBundle);
+      if (plan.reregisterGraphs) {
+        setGraphUpdateToken((prev) => prev + 1);
+      }
+      if (plan.reloadAssets) {
+        reportStatus((prev) => ({
+          ...prev,
+          loading: true,
+          ready: false
+        }));
+      } else {
+        reportStatus((prev) => ({
+          ...prev,
+          loading: false
+        }));
+      }
+    },
+    [reportStatus]
+  );
   const contextValue = useMemo(
     () => ({
       ...status,
       assetBundle,
       setInput,
+      setGraphBundle,
       setValue: setRendererValue,
       stagePoseNeutral,
       animateValue,
       cancelAnimation,
       registerInputDriver,
       playAnimation,
+      pauseAnimation,
+      seekAnimation,
+      setAnimationLoop,
+      getAnimationState,
       stopAnimation,
+      playProgram,
+      pauseProgram,
+      stopProgram,
+      getProgramState,
+      setAnimationActive,
+      isAnimationActive,
       step,
       advanceAnimations,
       inputConstraints
@@ -1730,13 +3529,24 @@ function VizijRuntimeProviderInner({
       status,
       assetBundle,
       setInput,
+      setGraphBundle,
       setRendererValue,
       stagePoseNeutral,
       animateValue,
       cancelAnimation,
       registerInputDriver,
       playAnimation,
+      pauseAnimation,
+      seekAnimation,
+      setAnimationLoop,
+      getAnimationState,
       stopAnimation,
+      playProgram,
+      pauseProgram,
+      stopProgram,
+      getProgramState,
+      setAnimationActive,
+      isAnimationActive,
       step,
       advanceAnimations,
       inputConstraints
@@ -1782,17 +3592,23 @@ function VizijRuntimeFaceInner({
 }
 var VizijRuntimeFace = memo(VizijRuntimeFaceInner);
 
+// src/hooks/useOptionalVizijRuntime.ts
+import { useContext as useContext3 } from "react";
+function useOptionalVizijRuntime() {
+  return useContext3(VizijRuntimeContext);
+}
+
 // src/hooks/useVizijOutputs.ts
 import {
   useVizijStore
 } from "@vizij/render";
-import { getLookup } from "@vizij/utils";
+import { getLookup as getLookup2 } from "@vizij/utils";
 function useVizijOutputs(paths) {
   const { namespace } = useVizijRuntime();
   return useVizijStore((state) => {
     const result = {};
     paths.forEach((path) => {
-      const lookup = getLookup(namespace, path);
+      const lookup = getLookup2(namespace, path);
       result[path] = state.values.get(lookup);
     });
     return result;
@@ -1804,11 +3620,11 @@ import { useCallback as useCallback2 } from "react";
 import {
   useVizijStore as useVizijStore2
 } from "@vizij/render";
-import { getLookup as getLookup2 } from "@vizij/utils";
+import { getLookup as getLookup3 } from "@vizij/utils";
 function useRigInput(path) {
   const { namespace, setInput } = useVizijRuntime();
   const value = useVizijStore2((state) => {
-    return state.values.get(getLookup2(namespace, path));
+    return state.values.get(getLookup3(namespace, path));
   });
   const setter = useCallback2(
     (next, shape) => {
@@ -1818,9 +3634,422 @@ function useRigInput(path) {
   );
   return [value, setter];
 }
+
+// src/utils/faceControls.ts
+var DEFAULT_GAZE_CONTROL = {
+  min: -1,
+  max: 1,
+  defaultValue: 0
+};
+var DEFAULT_BLINK_CONTROL = {
+  min: 0,
+  max: 1,
+  defaultValue: 0
+};
+var STANDARD_VIZIJ_EYE_PATHS = {
+  leftX: "/standard/vizij/left_eye/pos/x",
+  leftY: "/standard/vizij/left_eye/pos/y",
+  rightX: "/standard/vizij/right_eye/pos/x",
+  rightY: "/standard/vizij/right_eye/pos/y",
+  leftUpper: "/standard/vizij/left_eye_top_eyelid/pos/y",
+  rightUpper: "/standard/vizij/right_eye_top_eyelid/pos/y"
+};
+var LEGACY_STANDARD_EYE_PATHS = {
+  leftX: "/standard/left_eye/pos/x",
+  leftY: "/standard/left_eye/pos/y",
+  rightX: "/standard/right_eye/pos/x",
+  rightY: "/standard/right_eye/pos/y",
+  leftUpper: "/standard/left_eye_top_eyelid/pos/y",
+  rightUpper: "/standard/right_eye_top_eyelid/pos/y"
+};
+var PROPSRIG_EYE_PATHS = {
+  leftX: "/propsrig/l_eye/translation/x",
+  leftY: "/propsrig/l_eye/translation/y",
+  rightX: "/propsrig/r_eye/translation/x",
+  rightY: "/propsrig/r_eye/translation/y"
+};
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function normalizeInputPath(path) {
+  const trimmed = path?.trim() ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  if (trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  const rigMatch = trimmed.match(/^rig\/[^/]+(\/.*)$/);
+  if (rigMatch?.[1]) {
+    return rigMatch[1];
+  }
+  return `/${trimmed}`;
+}
+function buildControlsLookup(assetBundle) {
+  const metadata = assetBundle.rig?.inputMetadata ?? [];
+  const metadataByPath = /* @__PURE__ */ new Map();
+  const pathSet = /* @__PURE__ */ new Set();
+  metadata.forEach((entry) => {
+    const normalized = normalizeInputPath(entry.path);
+    if (!normalized) {
+      return;
+    }
+    pathSet.add(normalized);
+    if (!metadataByPath.has(normalized)) {
+      metadataByPath.set(normalized, entry);
+    }
+  });
+  return { pathSet, metadataByPath };
+}
+function resolveConstraint(absolutePath, relativePath, inputConstraints) {
+  if (!inputConstraints) {
+    return null;
+  }
+  const normalizedRelative = relativePath.replace(/^\//, "");
+  const candidates = [
+    absolutePath,
+    relativePath,
+    normalizedRelative,
+    absolutePath.replace(/^rig\/[^/]+\//, "")
+  ];
+  for (const candidate of candidates) {
+    const constraint = inputConstraints[candidate];
+    if (constraint) {
+      return constraint;
+    }
+  }
+  return null;
+}
+function createControl(faceId, lookup, relativePath, inputConstraints, fallback) {
+  const normalizedRelative = normalizeInputPath(relativePath);
+  if (!normalizedRelative || !lookup.pathSet.has(normalizedRelative)) {
+    return null;
+  }
+  const absolutePath = buildRigInputPath(faceId, normalizedRelative);
+  const metadata = lookup.metadataByPath.get(normalizedRelative);
+  const constraint = resolveConstraint(
+    absolutePath,
+    normalizedRelative,
+    inputConstraints
+  );
+  const min = Number.isFinite(Number(constraint?.min ?? metadata?.range?.min)) ? Number(constraint?.min ?? metadata?.range?.min) : fallback.min;
+  const max = Number.isFinite(Number(constraint?.max ?? metadata?.range?.max)) ? Number(constraint?.max ?? metadata?.range?.max) : fallback.max;
+  const midpoint = min + (max - min) / 2;
+  const defaultValue = Number.isFinite(
+    Number(constraint?.defaultValue ?? metadata?.defaultValue)
+  ) ? Number(constraint?.defaultValue ?? metadata?.defaultValue) : Number.isFinite(midpoint) ? midpoint : fallback.defaultValue;
+  return {
+    path: absolutePath,
+    min,
+    max,
+    defaultValue
+  };
+}
+function hasAll(controls, keys) {
+  return keys.every((key) => Boolean(controls[key]));
+}
+function resolveFaceControls(assetBundle, runtimeFaceId, inputConstraints) {
+  const faceId = assetBundle.faceId ?? assetBundle.pose?.config?.faceId ?? runtimeFaceId ?? "face";
+  const lookup = buildControlsLookup(assetBundle);
+  const standardVizijControls = {
+    leftX: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.leftX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftY: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.leftY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightX: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.rightX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightY: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.rightY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftUpper: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.leftUpper,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightUpper: createControl(
+      faceId,
+      lookup,
+      STANDARD_VIZIJ_EYE_PATHS.rightUpper,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    )
+  };
+  const legacyStandardControls = {
+    leftX: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.leftX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftY: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.leftY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightX: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.rightX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightY: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.rightY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftUpper: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.leftUpper,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightUpper: createControl(
+      faceId,
+      lookup,
+      LEGACY_STANDARD_EYE_PATHS.rightUpper,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    )
+  };
+  const propsrigControls = {
+    leftX: createControl(
+      faceId,
+      lookup,
+      PROPSRIG_EYE_PATHS.leftX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftY: createControl(
+      faceId,
+      lookup,
+      PROPSRIG_EYE_PATHS.leftY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightX: createControl(
+      faceId,
+      lookup,
+      PROPSRIG_EYE_PATHS.rightX,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightY: createControl(
+      faceId,
+      lookup,
+      PROPSRIG_EYE_PATHS.rightY,
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    )
+  };
+  const coupledGazeControls = {
+    leftX: createControl(
+      faceId,
+      lookup,
+      "/gaze/left_right",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    leftY: createControl(
+      faceId,
+      lookup,
+      "/gaze/up_down",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightX: createControl(
+      faceId,
+      lookup,
+      "/gaze/left_right_copy",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ) ?? createControl(
+      faceId,
+      lookup,
+      "/gaze/left_right",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ),
+    rightY: createControl(
+      faceId,
+      lookup,
+      "/gaze/up_down_copy",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    ) ?? createControl(
+      faceId,
+      lookup,
+      "/gaze/up_down",
+      inputConstraints,
+      DEFAULT_GAZE_CONTROL
+    )
+  };
+  const blinkFromLids = createControl(
+    faceId,
+    lookup,
+    "/lids/blink",
+    inputConstraints,
+    DEFAULT_BLINK_CONTROL
+  );
+  const blinkDirect = createControl(
+    faceId,
+    lookup,
+    "/blink",
+    inputConstraints,
+    DEFAULT_BLINK_CONTROL
+  );
+  if (hasAll(standardVizijControls, ["leftX", "leftY", "rightX", "rightY"])) {
+    return {
+      faceId,
+      gazeSource: "standard-vizij",
+      blinkSource: blinkFromLids ? "lids" : blinkDirect ? "blink" : "none",
+      eyes: {
+        leftX: standardVizijControls.leftX,
+        leftY: standardVizijControls.leftY,
+        rightX: standardVizijControls.rightX,
+        rightY: standardVizijControls.rightY
+      },
+      eyelids: {
+        leftUpper: standardVizijControls.leftUpper,
+        rightUpper: standardVizijControls.rightUpper
+      },
+      blink: blinkFromLids ?? blinkDirect
+    };
+  }
+  if (hasAll(legacyStandardControls, ["leftX", "leftY", "rightX", "rightY"])) {
+    return {
+      faceId,
+      gazeSource: "standard",
+      blinkSource: blinkDirect ? "blink" : blinkFromLids ? "lids" : "none",
+      eyes: {
+        leftX: legacyStandardControls.leftX,
+        leftY: legacyStandardControls.leftY,
+        rightX: legacyStandardControls.rightX,
+        rightY: legacyStandardControls.rightY
+      },
+      eyelids: {
+        leftUpper: legacyStandardControls.leftUpper,
+        rightUpper: legacyStandardControls.rightUpper
+      },
+      blink: blinkDirect ?? blinkFromLids
+    };
+  }
+  if (hasAll(propsrigControls, ["leftX", "leftY", "rightX", "rightY"])) {
+    return {
+      faceId,
+      gazeSource: "propsrig",
+      blinkSource: blinkDirect ? "blink" : blinkFromLids ? "lids" : "none",
+      eyes: {
+        leftX: propsrigControls.leftX,
+        leftY: propsrigControls.leftY,
+        rightX: propsrigControls.rightX,
+        rightY: propsrigControls.rightY
+      },
+      eyelids: {
+        leftUpper: null,
+        rightUpper: null
+      },
+      blink: blinkDirect ?? blinkFromLids
+    };
+  }
+  if (hasAll(coupledGazeControls, ["leftX", "leftY", "rightX", "rightY"])) {
+    return {
+      faceId,
+      gazeSource: "coupled-gaze",
+      blinkSource: blinkFromLids ? "lids" : blinkDirect ? "blink" : "none",
+      eyes: {
+        leftX: coupledGazeControls.leftX,
+        leftY: coupledGazeControls.leftY,
+        rightX: coupledGazeControls.rightX,
+        rightY: coupledGazeControls.rightY
+      },
+      eyelids: {
+        leftUpper: null,
+        rightUpper: null
+      },
+      blink: blinkFromLids ?? blinkDirect
+    };
+  }
+  return {
+    faceId,
+    gazeSource: "none",
+    blinkSource: blinkFromLids ? "lids" : blinkDirect ? "blink" : "none",
+    eyes: {
+      leftX: null,
+      leftY: null,
+      rightX: null,
+      rightY: null
+    },
+    eyelids: {
+      leftUpper: null,
+      rightUpper: null
+    },
+    blink: blinkFromLids ?? blinkDirect
+  };
+}
+function mapNormalizedControlValue(control, normalizedValue) {
+  const value = clamp(normalizedValue, -1, 1);
+  if (value === 0) {
+    return control.defaultValue;
+  }
+  if (value > 0) {
+    return control.defaultValue + (control.max - control.defaultValue) * value;
+  }
+  return control.defaultValue + (control.defaultValue - control.min) * value;
+}
+function mapUnitControlValue(control, unitValue) {
+  const value = clamp(unitValue, 0, 1);
+  return control.defaultValue + (control.max - control.defaultValue) * value;
+}
 export {
+  EMOTION_POSE_KEYS,
+  EXPRESSIVE_EMOTION_POSE_KEYS,
+  POSE_WEIGHT_INPUT_PATH_PREFIX,
+  VISEME_POSE_KEYS,
   VizijRuntimeFace,
   VizijRuntimeProvider,
+  buildPoseWeightInputPathSegment,
+  buildPoseWeightPathMap,
+  buildPoseWeightRelativePath,
+  buildRigInputPath,
+  buildSemanticPoseWeightPathMap,
+  filterPosesBySemanticKind,
+  getPoseSemanticKey,
+  mapNormalizedControlValue,
+  mapUnitControlValue,
+  normalizePoseSemanticKey,
+  resolveFaceControls,
+  resolvePoseMembership,
+  resolvePoseSemantics,
+  resolveRuntimeUpdatePlan,
+  useOptionalVizijRuntime,
   useRigInput,
   useVizijOutputs,
   useVizijRuntime