@vizij/runtime-react 0.0.14 → 0.1.0

package/dist/{index.mjs → index.cjs}

@@ -1,27 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  VizijRuntimeFace: () => VizijRuntimeFace,
+  VizijRuntimeProvider: () => VizijRuntimeProvider,
+  useRigInput: () => useRigInput,
+  useVizijOutputs: () => useVizijOutputs,
+  useVizijRuntime: () => useVizijRuntime
+});
+module.exports = __toCommonJS(index_exports);
+
 // src/VizijRuntimeProvider.tsx
-import {
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState
-} from "react";
-import {
-  VizijContext,
-  createVizijStore,
-  loadGLTFWithBundle,
-  loadGLTFFromBlobWithBundle
-} from "@vizij/render";
-import {
-  OrchestratorProvider,
-  useOrchestrator,
-  useOrchFrame
-} from "@vizij/orchestrator-react";
-import { valueAsNumber as valueAsNumber2 } from "@vizij/value-json";
+var import_react2 = require("react");
+var import_render = require("@vizij/render");
+var import_orchestrator_react = require("@vizij/orchestrator-react");
+var import_node_graph_authoring = require("@vizij/node-graph-authoring");
+var import_value_json2 = require("@vizij/value-json");
 
 // src/context.ts
-import { createContext } from "react";
-var VizijRuntimeContext = createContext(null);
+var import_react = require("react");
+var VizijRuntimeContext = (0, import_react.createContext)(null);
 
 // src/utils/graph.ts
 function getNodes(spec) {
@@ -84,15 +100,7 @@ function collectInputPathMap(spec) {
 }
 
 // src/utils/valueConversion.ts
-import {
-  isNormalizedValue,
-  valueAsBool,
-  valueAsColorRgba,
-  valueAsNumber,
-  valueAsText,
-  valueAsTransform,
-  valueAsVector
-} from "@vizij/value-json";
+var import_value_json = require("@vizij/value-json");
 function numericArrayToRaw(arr) {
   const normalised = arr.map((entry) => Number(entry ?? 0));
   switch (normalised.length) {
@@ -144,20 +152,20 @@ function valueJSONToRaw(value) {
     ]);
     return Object.fromEntries(entries);
   }
-  if (!isNormalizedValue(value)) {
+  if (!(0, import_value_json.isNormalizedValue)(value)) {
     return void 0;
   }
   switch (value.type) {
     case "float": {
-      const num = valueAsNumber(value);
+      const num = (0, import_value_json.valueAsNumber)(value);
       return typeof num === "number" ? num : void 0;
     }
     case "bool": {
-      const boolVal = valueAsBool(value);
+      const boolVal = (0, import_value_json.valueAsBool)(value);
       return typeof boolVal === "boolean" ? boolVal : void 0;
     }
     case "text": {
-      const text = valueAsText(value);
+      const text = (0, import_value_json.valueAsText)(value);
       return typeof text === "string" ? text : void 0;
     }
     case "vec2":
@@ -165,11 +173,11 @@ function valueJSONToRaw(value) {
     case "vec4":
     case "quat":
     case "vector": {
-      const vec = valueAsVector(value);
+      const vec = (0, import_value_json.valueAsVector)(value);
       return vec ? numericArrayToRaw(vec) : void 0;
     }
     case "colorrgba": {
-      const color = valueAsColorRgba(value);
+      const color = (0, import_value_json.valueAsColorRgba)(value);
       if (!color) {
         return void 0;
       }
@@ -177,7 +185,7 @@ function valueJSONToRaw(value) {
       return { r, g, b, a };
     }
     case "transform": {
-      const transform = valueAsTransform(value);
+      const transform = (0, import_value_json.valueAsTransform)(value);
       if (!transform) {
         return void 0;
       }
@@ -207,7 +215,10 @@ function valueJSONToRaw(value) {
 }
 
 // src/VizijRuntimeProvider.tsx
-import { jsx } from "react/jsx-runtime";
+var import_jsx_runtime = require("react/jsx-runtime");
+var ACTIVE_GRACE_MS = 250;
+var VISIBLE_IDLE_FPS = 30;
+var HIDDEN_IDLE_FPS = 1;
 var DEFAULT_MERGE = {
   outputs: "add",
   intermediate: "add"
@@ -245,6 +256,166 @@ function normalisePath(path) {
 function normaliseBundleKind(kind) {
   return typeof kind === "string" ? kind.toLowerCase() : "";
 }
+function addConstraintVariant(map, key, constraint) {
+  if (!key) return;
+  if (!map[key]) {
+    map[key] = constraint;
+  }
+}
+function stripRigFacePrefix(path) {
+  const trimmed = path.startsWith("/") ? path.slice(1) : path;
+  const match = /^rig\/[^/]+\/(.+)$/.exec(trimmed);
+  if (match && match[1]) {
+    return match[1];
+  }
+  if (trimmed.startsWith("rig/")) {
+    return trimmed.slice("rig/".length);
+  }
+  return trimmed;
+}
+function extractInputConstraints(spec, extraInputs, namespace) {
+  if (!spec || typeof spec !== "object") {
+    return {};
+  }
+  const inputs = [];
+  if (Array.isArray(extraInputs)) {
+    inputs.push(...extraInputs);
+  }
+  const entries = spec.metadata?.vizij?.inputs;
+  if (Array.isArray(entries)) {
+    entries.forEach((entry) => {
+      if (entry && typeof entry === "object") {
+        inputs.push(entry);
+      }
+    });
+  }
+  if (inputs.length === 0) {
+    return {};
+  }
+  const map = {};
+  inputs.forEach((entry) => {
+    const path = entry.path;
+    if (typeof path !== "string") return;
+    const namespaced = namespaceTypedPath(path, namespace);
+    const stripped = stripRigFacePrefix(path);
+    const strippedNamespaced = stripped ? namespaceTypedPath(stripped, namespace) : stripped;
+    const min = entry.range?.min;
+    const max = entry.range?.max;
+    const defaultValue = entry.defaultValue;
+    const constraint = {
+      ...Number.isFinite(Number(min)) ? { min: Number(min) } : {},
+      ...Number.isFinite(Number(max)) ? { max: Number(max) } : {},
+      ...Number.isFinite(Number(defaultValue)) ? { defaultValue: Number(defaultValue) } : {}
+    };
+    addConstraintVariant(map, namespaced, constraint);
+    addConstraintVariant(map, path, constraint);
+    if (stripped) {
+      addConstraintVariant(map, stripped, constraint);
+    }
+    if (strippedNamespaced) {
+      addConstraintVariant(map, strippedNamespaced, constraint);
+    }
+  });
+  return map;
+}
+function namespaceTypedPath(path, namespace) {
+  const trimmed = typeof path === "string" ? path.trim() : "";
+  if (!trimmed) {
+    return trimmed;
+  }
+  const prefix = `${namespace}/`;
+  if (trimmed.startsWith(prefix)) {
+    return trimmed;
+  }
+  if (trimmed.startsWith("debug/")) {
+    const rest = trimmed.slice("debug/".length);
+    const namespacedRest = namespaceTypedPath(rest, namespace);
+    return namespacedRest.startsWith("debug/") ? namespacedRest : `debug/${namespacedRest}`;
+  }
+  return `${prefix}${trimmed}`;
+}
+function stripNamespace(path, namespace) {
+  const prefix = `${namespace}/`;
+  if (path.startsWith(prefix)) {
+    return path.slice(prefix.length);
+  }
+  const debugPrefix = `debug/${prefix}`;
+  if (path.startsWith(debugPrefix)) {
+    return path.slice(debugPrefix.length);
+  }
+  if (path.startsWith("debug/")) {
+    return path.slice("debug/".length);
+  }
+  return path;
+}
+function namespaceControllerId(id, namespace, kind = "graph") {
+  if (!id) {
+    return void 0;
+  }
+  const trimmed = id.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const prefix = `${namespace}/${kind}/`;
+  if (trimmed.startsWith(prefix)) {
+    return trimmed;
+  }
+  return `${prefix}${trimmed}`;
+}
+function namespaceSubscriptions(subs, namespace) {
+  if (!subs) {
+    return void 0;
+  }
+  const inputs = Array.isArray(subs.inputs) ? subs.inputs.map((path) => namespaceTypedPath(path, namespace)) : void 0;
+  const outputs = Array.isArray(subs.outputs) ? subs.outputs.map((path) => namespaceTypedPath(path, namespace)) : void 0;
+  if (!inputs && !outputs) {
+    return subs;
+  }
+  return {
+    ...subs,
+    ...inputs ? { inputs } : {},
+    ...outputs ? { outputs } : {}
+  };
+}
+function namespaceGraphSpec(spec, namespace) {
+  if (!spec || typeof spec !== "object") {
+    return spec;
+  }
+  const nodes = spec.nodes;
+  if (!Array.isArray(nodes)) {
+    return spec;
+  }
+  let changed = false;
+  const nextNodes = nodes.map((node) => {
+    if (!node || typeof node !== "object") {
+      return node;
+    }
+    const path = node.params?.path;
+    if (typeof path !== "string") {
+      return node;
+    }
+    const namespacedPath = namespaceTypedPath(path, namespace);
+    if (namespacedPath === path) {
+      return node;
+    }
+    changed = true;
+    return {
+      ...node,
+      params: {
+        ...node.params ?? {},
+        path: namespacedPath
+      }
+    };
+  });
+  if (!changed) {
+    return spec;
+  }
+  return {
+    ...spec,
+    nodes: nextNodes
+  };
+}
+var now = () => typeof performance !== "undefined" ? performance.now() : Date.now();
 function pickBundleGraph(bundle, preferredKinds) {
   if (!bundle?.graphs || bundle.graphs.length === 0) {
     return null;
@@ -264,14 +435,91 @@ function pickBundleGraph(bundle, preferredKinds) {
   }
   return null;
 }
+function extractIrGraph(payload) {
+  if (!payload || typeof payload !== "object") {
+    return void 0;
+  }
+  return payload;
+}
 function convertBundleGraph(entry) {
-  if (!entry || !entry.id || !entry.spec) {
+  if (!entry || !entry.id) {
+    return null;
+  }
+  const rawSpec = entry.spec;
+  const inputMetadata = extractVizijInputMetadata(
+    rawSpec
+  );
+  const spec = rawSpec ? stripVizijMetadata(rawSpec) : void 0;
+  const ir = extractIrGraph(entry.ir);
+  if (!spec && !ir) {
     return null;
   }
   return {
     id: entry.id,
-    spec: entry.spec
+    spec,
+    ir: ir ?? null,
+    inputMetadata
+  };
+}
+function resolveGraphSpec(asset, context) {
+  if (asset.spec) {
+    return stripVizijMetadata(asset.spec);
+  }
+  if (asset.ir) {
+    try {
+      const compiled = (0, import_node_graph_authoring.compileIrGraph)(asset.ir, { preferLegacySpec: false });
+      if (compiled.issues && compiled.issues.length > 0) {
+        console.warn(
+          `[vizij-runtime] IR compile for graph "${context}" reported issues`,
+          compiled.issues
+        );
+      }
+      return stripVizijMetadata(compiled.spec);
+    } catch (error) {
+      console.warn(
+        `[vizij-runtime] Failed to compile IR graph "${context}"`,
+        error
+      );
+    }
+  }
+  return null;
+}
+function stripVizijMetadata(spec) {
+  if (!spec || typeof spec !== "object") {
+    return spec;
+  }
+  const cloned = {
+    ...spec,
+    nodes: spec.nodes ? spec.nodes.map((node) => ({ ...node })) : spec.nodes,
+    edges: spec.edges ? spec.edges.map((edge) => ({ ...edge })) : spec.edges
   };
+  if (cloned.metadata && typeof cloned.metadata === "object") {
+    const metadata = { ...cloned.metadata };
+    if ("vizij" in metadata) {
+      delete metadata.vizij;
+    }
+    if (Object.keys(metadata).length === 0) {
+      delete cloned.metadata;
+    } else {
+      cloned.metadata = metadata;
+    }
+  }
+  return cloned;
+}
+function extractVizijInputMetadata(spec) {
+  if (!spec || typeof spec !== "object") {
+    return [];
+  }
+  const inputs = spec.metadata?.vizij?.inputs;
+  if (!Array.isArray(inputs)) {
+    return [];
+  }
+  return inputs.map((entry) => {
+    if (!entry || typeof entry !== "object") {
+      return null;
+    }
+    return entry;
+  }).filter(Boolean);
 }
 function convertBundleAnimations(entries) {
   if (!Array.isArray(entries) || entries.length === 0) {
@@ -495,36 +743,53 @@ function VizijRuntimeProvider({
   autoCreate = true,
   createOptions,
   autostart = false,
+  driveOrchestrator = true,
   mergeStrategy,
   onRegisterControllers,
-  onStatusChange
+  onStatusChange,
+  orchestratorScope = "auto"
 }) {
-  const storeRef = useRef();
+  const storeRef = (0, import_react2.useRef)(null);
   if (!storeRef.current) {
-    storeRef.current = createVizijStore();
+    storeRef.current = (0, import_render.createVizijStore)();
   }
-  return /* @__PURE__ */ jsx(VizijContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ jsx(
-    OrchestratorProvider,
+  const parentOrchestrator = (0, import_react2.useContext)(import_orchestrator_react.OrchestratorContext);
+  const hasParentOrchestrator = Boolean(parentOrchestrator);
+  const shouldProvideOrchestrator = orchestratorScope === "isolated" || !hasParentOrchestrator && orchestratorScope !== "shared";
+  if (orchestratorScope === "shared" && !hasParentOrchestrator) {
+    console.warn(
+      '[vizij-runtime] orchestratorScope="shared" requires an OrchestratorProvider higher in the tree; falling back to an isolated provider.'
+    );
+  }
+  const runtimeTree = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_render.VizijContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    VizijRuntimeProviderInner,
     {
+      assetBundle,
+      namespace: namespaceProp,
+      faceId: faceIdProp,
       autoCreate,
-      createOptions,
       autostart,
-      children: /* @__PURE__ */ jsx(
-        VizijRuntimeProviderInner,
-        {
-          assetBundle,
-          namespace: namespaceProp,
-          faceId: faceIdProp,
-          autoCreate,
-          mergeStrategy,
-          onRegisterControllers,
-          onStatusChange,
-          store: storeRef.current,
-          children
-        }
-      )
+      driveOrchestrator,
+      createOptions,
+      mergeStrategy,
+      onRegisterControllers,
+      onStatusChange,
+      store: storeRef.current,
+      children
     }
   ) });
+  if (!shouldProvideOrchestrator) {
+    return runtimeTree;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_orchestrator_react.OrchestratorProvider,
+    {
+      autoCreate,
+      createOptions,
+      autostart: false,
+      children: runtimeTree
+    }
+  );
 }
 function VizijRuntimeProviderInner({
   assetBundle: initialAssetBundle,
@@ -535,9 +800,12 @@ function VizijRuntimeProviderInner({
   onStatusChange,
   store,
   children,
-  autoCreate
+  autoCreate,
+  autostart,
+  createOptions,
+  driveOrchestrator
 }) {
-  const [extractedBundle, setExtractedBundle] = useState(() => {
+  const [extractedBundle, setExtractedBundle] = (0, import_react2.useState)(() => {
     if (initialAssetBundle.bundle) {
       return initialAssetBundle.bundle;
     }
@@ -546,8 +814,8 @@ function VizijRuntimeProviderInner({
     }
     return null;
   });
-  const [extractedAnimations, setExtractedAnimations] = useState([]);
-  useEffect(() => {
+  const [extractedAnimations, setExtractedAnimations] = (0, import_react2.useState)([]);
+  (0, import_react2.useEffect)(() => {
     if (initialAssetBundle.bundle) {
       setExtractedBundle(initialAssetBundle.bundle);
       return;
@@ -558,7 +826,7 @@ function VizijRuntimeProviderInner({
       setExtractedBundle(null);
     }
   }, [initialAssetBundle]);
-  const assetBundle = useMemo(
+  const assetBundle = (0, import_react2.useMemo)(
     () => mergeAssetBundle(
       initialAssetBundle,
       extractedBundle,
@@ -575,14 +843,14 @@ function VizijRuntimeProviderInner({
     removeGraph,
     removeAnimation,
     listControllers,
-    setInput,
+    setInput: orchestratorSetInput,
     getPathSnapshot,
     step: stepRuntime
-  } = useOrchestrator();
-  const frame = useOrchFrame();
+  } = (0, import_orchestrator_react.useOrchestrator)();
+  const frame = (0, import_orchestrator_react.useOrchFrame)();
   const namespace = namespaceProp ?? assetBundle.namespace ?? "default";
   const faceId = faceIdProp ?? assetBundle.faceId ?? assetBundle.pose?.config?.faceId ?? assetBundle.pose?.config?.faceId ?? void 0;
-  const [status, setStatus] = useState({
+  const [status, setStatus] = (0, import_react2.useState)({
     loading: true,
     ready: false,
     error: null,
@@ -591,19 +859,98 @@ function VizijRuntimeProviderInner({
     faceId,
     rootId: null,
     outputPaths: [],
+    stepHz: void 0,
     controllers: { graphs: [], anims: [] }
   });
-  const errorsRef = useRef([]);
-  const outputPathsRef = useRef(/* @__PURE__ */ new Set());
-  const rigInputMapRef = useRef({});
-  const registeredGraphsRef = useRef([]);
-  const registeredAnimationsRef = useRef([]);
-  const mergedGraphRef = useRef(null);
-  const animationTweensRef = useRef(/* @__PURE__ */ new Map());
-  const clipPlaybackRef = useRef(/* @__PURE__ */ new Map());
-  const rafHandleRef = useRef(null);
-  const lastFrameTimeRef = useRef(null);
-  const reportStatus = useCallback(
+  const errorsRef = (0, import_react2.useRef)([]);
+  const outputPathsRef = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  const baseOutputPathsRef = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  const namespacedOutputPathsRef = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  const namespaceRef = (0, import_react2.useRef)(namespace);
+  const driveOrchestratorRef = (0, import_react2.useRef)(driveOrchestrator);
+  const rigInputMapRef = (0, import_react2.useRef)({});
+  const registeredGraphsRef = (0, import_react2.useRef)([]);
+  const registeredAnimationsRef = (0, import_react2.useRef)([]);
+  const mergedGraphRef = (0, import_react2.useRef)(null);
+  const [inputConstraints, setInputConstraints] = (0, import_react2.useState)({});
+  const avgStepDtRef = (0, import_react2.useRef)(null);
+  const animationTweensRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  const clipPlaybackRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  const stagedInputsRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  const autostartRef = (0, import_react2.useRef)(autostart);
+  const lastActivityTimeRef = (0, import_react2.useRef)(now());
+  const [loopMode, setLoopMode] = (0, import_react2.useState)("stopped");
+  const loopModeRef = (0, import_react2.useRef)("stopped");
+  (0, import_react2.useEffect)(() => {
+    loopModeRef.current = loopMode;
+  }, [loopMode]);
+  const runtimeMountedRef = (0, import_react2.useRef)(true);
+  (0, import_react2.useEffect)(() => {
+    return () => {
+      runtimeMountedRef.current = false;
+    };
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    const rigAsset = assetBundle.rig;
+    if (!rigAsset) {
+      setInputConstraints({});
+      return;
+    }
+    const rigSpec = resolveGraphSpec(
+      rigAsset,
+      `${rigAsset.id ?? "rig"} graph (constraints)`
+    );
+    const constraints = extractInputConstraints(
+      rigSpec,
+      rigAsset.inputMetadata,
+      namespace
+    );
+    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 = (0, import_react2.useCallback)((mode) => {
+    if (!runtimeMountedRef.current) {
+      return;
+    }
+    setLoopMode((prev) => prev === mode ? prev : mode);
+  }, []);
+  const hasActiveAnimations = (0, import_react2.useCallback)(() => {
+    return animationTweensRef.current.size > 0 || clipPlaybackRef.current.size > 0;
+  }, []);
+  const computeDesiredLoopMode = (0, import_react2.useCallback)(() => {
+    const hasAnimations = hasActiveAnimations();
+    const recentlyActive = now() - lastActivityTimeRef.current <= ACTIVE_GRACE_MS;
+    if (autostartRef.current && (hasAnimations || recentlyActive)) {
+      return "active";
+    }
+    if (autostartRef.current) {
+      return "idle-visible";
+    }
+    return "idle-hidden";
+  }, [hasActiveAnimations]);
+  const updateLoopMode = (0, import_react2.useCallback)(() => {
+    requestLoopMode(computeDesiredLoopMode());
+  }, [computeDesiredLoopMode, requestLoopMode]);
+  const markActivity = (0, import_react2.useCallback)(() => {
+    lastActivityTimeRef.current = now();
+    updateLoopMode();
+  }, [updateLoopMode]);
+  const setInput = (0, import_react2.useCallback)(
+    (path, value, shape) => {
+      markActivity();
+      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
+      stagedInputsRef.current.set(namespacedPath, { value, shape });
+    },
+    [markActivity]
+  );
+  const reportStatus = (0, import_react2.useCallback)(
     (updater) => {
       setStatus((prev) => {
         const next = updater(prev);
@@ -613,7 +960,7 @@ function VizijRuntimeProviderInner({
     },
     [onStatusChange]
   );
-  const pushError = useCallback(
+  const pushError = (0, import_react2.useCallback)(
     (error) => {
       errorsRef.current = [...errorsRef.current, error];
       reportStatus((prev) => ({
@@ -625,7 +972,7 @@ function VizijRuntimeProviderInner({
     },
     [reportStatus]
   );
-  const resetErrors = useCallback(() => {
+  const resetErrors = (0, import_react2.useCallback)(() => {
     errorsRef.current = [];
     reportStatus((prev) => ({
       ...prev,
@@ -633,7 +980,11 @@ function VizijRuntimeProviderInner({
       errors: []
     }));
   }, [reportStatus]);
-  const clearControllers = useCallback(() => {
+  (0, import_react2.useEffect)(() => {
+    autostartRef.current = autostart;
+    updateLoopMode();
+  }, [autostart, updateLoopMode]);
+  const clearControllers = (0, import_react2.useCallback)(() => {
     const existing = listControllers();
     existing.graphs.forEach((id) => {
       try {
@@ -662,17 +1013,24 @@ function VizijRuntimeProviderInner({
     registeredGraphsRef.current = [];
     registeredAnimationsRef.current = [];
     mergedGraphRef.current = null;
+    outputPathsRef.current = /* @__PURE__ */ new Set();
+    baseOutputPathsRef.current = /* @__PURE__ */ new Set();
+    namespacedOutputPathsRef.current = /* @__PURE__ */ new Set();
   }, [listControllers, removeAnimation, removeGraph, pushError]);
-  useEffect(() => {
+  (0, import_react2.useEffect)(() => {
+    namespaceRef.current = namespace;
     reportStatus((prev) => ({
       ...prev,
       namespace,
       faceId
     }));
   }, [namespace, faceId, reportStatus]);
+  (0, import_react2.useEffect)(() => {
+    driveOrchestratorRef.current = driveOrchestrator;
+  }, [driveOrchestrator]);
   const glbAsset = initialAssetBundle.glb;
   const baseBundle = initialAssetBundle.bundle ?? null;
-  useEffect(() => {
+  (0, import_react2.useEffect)(() => {
     let cancelled = false;
     resetErrors();
     reportStatus((prev) => ({
@@ -691,7 +1049,7 @@ function VizijRuntimeProviderInner({
         let bundle = baseBundle;
         let gltfAnimations;
         if (glbAsset.kind === "url") {
-          const loaded = await loadGLTFWithBundle(
+          const loaded = await (0, import_render.loadGLTFWithBundle)(
             glbAsset.src,
             [namespace],
             glbAsset.aggressiveImport ?? false,
@@ -702,7 +1060,7 @@ function VizijRuntimeProviderInner({
           bundle = loaded.bundle ?? bundle;
           gltfAnimations = pickExtractedAnimations(loaded);
         } else if (glbAsset.kind === "blob") {
-          const loaded = await loadGLTFFromBlobWithBundle(
+          const loaded = await (0, import_render.loadGLTFFromBlobWithBundle)(
             glbAsset.blob,
             [namespace],
             glbAsset.aggressiveImport ?? false,
@@ -764,9 +1122,9 @@ function VizijRuntimeProviderInner({
     setExtractedBundle,
     setExtractedAnimations
   ]);
-  useEffect(() => {
+  (0, import_react2.useEffect)(() => {
     if (!ready && autoCreate) {
-      createOrchestrator().catch((err) => {
+      createOrchestrator(createOptions).catch((err) => {
         pushError({
           message: "Failed to create orchestrator runtime",
           cause: err,
@@ -775,10 +1133,20 @@ function VizijRuntimeProviderInner({
         });
       });
     }
-  }, [ready, autoCreate, createOrchestrator, pushError]);
-  const registerControllers = useCallback(async () => {
-    const normalize = (spec) => spec;
+  }, [ready, autoCreate, createOptions, createOrchestrator, pushError]);
+  const registerControllers = (0, import_react2.useCallback)(async () => {
     clearControllers();
+    const baseOutputPaths = /* @__PURE__ */ new Set();
+    const namespacedOutputPaths = /* @__PURE__ */ new Set();
+    const recordOutputs = (paths) => {
+      paths.forEach((path) => {
+        const trimmed = path.trim();
+        if (!trimmed) return;
+        const basePath = stripNamespace(trimmed, namespace);
+        baseOutputPaths.add(basePath);
+        namespacedOutputPaths.add(namespaceTypedPath(trimmed, namespace));
+      });
+    };
     const rigAsset = assetBundle.rig;
     if (!rigAsset) {
       pushError({
@@ -788,37 +1156,67 @@ function VizijRuntimeProviderInner({
       });
       return;
     }
-    const rigSpec = normalize(rigAsset.spec);
+    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);
-    outputPathsRef.current = new Set(rigOutputs);
-    const rigConfig = {
-      id: rigAsset.id,
-      spec: rigSpec,
-      subs: rigAsset.subscriptions ?? {
-        inputs: rigInputs,
-        outputs: rigOutputs
-      }
+    recordOutputs(rigOutputs);
+    const rigSubs = rigAsset.subscriptions ?? {
+      inputs: rigInputs,
+      outputs: rigOutputs
     };
-    const graphConfigs = [rigConfig];
-    if (assetBundle.pose?.graph) {
-      const poseSpec = normalize(assetBundle.pose.graph.spec);
-      const poseOutputs = collectOutputPaths(poseSpec);
-      const poseInputs = collectInputPaths(poseSpec);
-      graphConfigs.push({
-        id: assetBundle.pose.graph.id,
-        spec: poseSpec,
-        subs: assetBundle.pose.graph.subscriptions ?? {
+    const graphConfigs = [
+      {
+        id: namespaceControllerId(rigAsset.id, namespace, "graph"),
+        spec: namespaceGraphSpec(rigSpec, namespace),
+        subs: namespaceSubscriptions(rigSubs, namespace)
+      }
+    ];
+    const poseGraphAsset = assetBundle.pose?.graph;
+    if (poseGraphAsset) {
+      const poseSpec = resolveGraphSpec(
+        poseGraphAsset,
+        `${poseGraphAsset.id ?? "pose"} graph`
+      );
+      if (poseSpec) {
+        const poseOutputs = collectOutputPaths(poseSpec);
+        const poseInputs = collectInputPaths(poseSpec);
+        recordOutputs(poseOutputs);
+        const poseSubs = poseGraphAsset.subscriptions ?? {
           inputs: poseInputs,
           outputs: poseOutputs
-        }
-      });
+        };
+        graphConfigs.push({
+          id: namespaceControllerId(poseGraphAsset.id, namespace, "graph"),
+          spec: namespaceGraphSpec(poseSpec, namespace),
+          subs: namespaceSubscriptions(poseSubs, namespace)
+        });
+      } else {
+        console.warn(
+          "[vizij-runtime] Pose graph is missing a usable spec or IR payload; skipping registration."
+        );
+      }
     }
+    outputPathsRef.current = namespacedOutputPaths;
+    baseOutputPathsRef.current = baseOutputPaths;
+    namespacedOutputPathsRef.current = namespacedOutputPaths;
     const graphIds = [];
     try {
       if (graphConfigs.length > 1) {
         const mergedId = registerMergedGraph({
+          id: namespaceControllerId(
+            mergedGraphRef.current ?? `merged-${namespace}`,
+            namespace,
+            "merged"
+          ) ?? void 0,
           graphs: graphConfigs,
           strategy: mergeStrategy ?? DEFAULT_MERGE
         });
@@ -842,8 +1240,9 @@ function VizijRuntimeProviderInner({
     const animationIds = [];
     for (const anim of assetBundle.animations ?? []) {
       try {
+        const controllerId = namespaceControllerId(anim.id, namespace, "animation") ?? anim.id;
         const config = {
-          id: anim.id,
+          id: controllerId,
           setup: {
             animation: anim.clip,
             ...anim.setup ?? {}
@@ -888,6 +1287,7 @@ function VizijRuntimeProviderInner({
     clearControllers,
     listControllers,
     mergeStrategy,
+    namespace,
     onRegisterControllers,
     pushError,
     registerAnimation,
@@ -896,7 +1296,7 @@ function VizijRuntimeProviderInner({
     reportStatus,
     setInput
   ]);
-  useEffect(() => {
+  (0, import_react2.useEffect)(() => {
     if (!ready || status.loading) {
       return;
     }
@@ -909,7 +1309,7 @@ function VizijRuntimeProviderInner({
       });
     });
   }, [ready, status.loading, registerControllers, pushError]);
-  useEffect(() => {
+  (0, import_react2.useEffect)(() => {
     if (!frame) {
       return;
     }
@@ -917,21 +1317,29 @@ function VizijRuntimeProviderInner({
     if (!writes.length) {
       return;
     }
-    const setWorldValue = store.getState().setValue;
+    const setWorldValues = store.getState().setValues;
     const namespaceValue = status.namespace;
+    const batched = [];
+    const namespacedOutputs = namespacedOutputPathsRef.current;
+    const baseOutputs = baseOutputPathsRef.current;
     writes.forEach((write) => {
       const path = normalisePath(write.path);
-      if (!outputPathsRef.current.has(path)) {
+      if (!namespacedOutputs.has(path)) {
         return;
       }
       const raw = valueJSONToRaw(write.value);
       if (raw === void 0) {
         return;
       }
-      setWorldValue(path, namespaceValue, raw);
+      const basePath = stripNamespace(path, namespaceValue);
+      const targetPath = baseOutputs.has(basePath) ? basePath : path;
+      batched.push({ id: targetPath, namespace: namespaceValue, value: raw });
     });
+    if (batched.length > 0) {
+      setWorldValues(batched);
+    }
   }, [frame, status.namespace, store]);
-  const stagePoseNeutral = useCallback(
+  const stagePoseNeutral = (0, import_react2.useCallback)(
     (force = false) => {
       const neutral = assetBundle.pose?.config?.neutralInputs ?? {};
       const rigMap = rigInputMapRef.current;
@@ -963,41 +1371,20 @@ function VizijRuntimeProviderInner({
     },
     [assetBundle.pose?.config?.neutralInputs, setInput]
   );
-  const setRendererValue = useCallback(
+  const setRendererValue = (0, import_react2.useCallback)(
     (id, ns, value) => {
       store.getState().setValue(id, ns, value);
     },
     [store]
   );
-  const cancelAnimation = useCallback((path) => {
+  const cancelAnimation = (0, import_react2.useCallback)((path) => {
     if (animationTweensRef.current.has(path)) {
       const entry = animationTweensRef.current.get(path);
       animationTweensRef.current.delete(path);
       entry?.resolve();
     }
   }, []);
-  const scheduleLoop = useCallback(() => {
-    if (rafHandleRef.current !== null) {
-      return;
-    }
-    const tick = (timestamp) => {
-      if (lastFrameTimeRef.current == null) {
-        lastFrameTimeRef.current = timestamp;
-      }
-      const dt = Math.max(0, (timestamp - lastFrameTimeRef.current) / 1e3);
-      lastFrameTimeRef.current = timestamp;
-      advanceAnimationTweens(dt);
-      advanceClipPlayback(dt);
-      if (animationTweensRef.current.size > 0 || clipPlaybackRef.current.size > 0) {
-        rafHandleRef.current = requestAnimationFrame(tick);
-      } else {
-        rafHandleRef.current = null;
-        lastFrameTimeRef.current = null;
-      }
-    };
-    rafHandleRef.current = requestAnimationFrame(tick);
-  }, []);
-  const advanceAnimationTweens = useCallback(
+  const advanceAnimationTweens = (0, import_react2.useCallback)(
     (dt) => {
       if (animationTweensRef.current.size === 0) {
         return;
@@ -1019,7 +1406,7 @@ function VizijRuntimeProviderInner({
     },
     [setInput]
   );
-  const sampleTrack = useCallback(
+  const sampleTrack = (0, import_react2.useCallback)(
     (track, time) => {
       const keyframes = Array.isArray(track.keyframes) ? track.keyframes : [];
       if (!keyframes.length) {
@@ -1050,7 +1437,7 @@ function VizijRuntimeProviderInner({
     },
     []
   );
-  const advanceClipPlayback = useCallback(
+  const advanceClipPlayback = (0, import_react2.useCallback)(
     (dt) => {
       if (clipPlaybackRef.current.size === 0) {
         return;
@@ -1099,21 +1486,22 @@ function VizijRuntimeProviderInner({
     },
     [assetBundle.animations, sampleTrack, setInput]
   );
-  const animateValue = useCallback(
+  const animateValue = (0, import_react2.useCallback)(
     (path, target, options) => {
       const easing = resolveEasing(options?.easing);
       const duration = Math.max(0, options?.duration ?? DEFAULT_DURATION);
       cancelAnimation(path);
-      const current = getPathSnapshot(path);
-      const fromValue = valueAsNumber2(current);
-      const toValue = valueAsNumber2(target);
+      const namespacedPath = namespaceTypedPath(path, namespaceRef.current);
+      const current = getPathSnapshot(namespacedPath);
+      const fromValue = (0, import_value_json2.valueAsNumber)(current);
+      const toValue = (0, import_value_json2.valueAsNumber)(target);
       if (fromValue == null || toValue == null || duration === 0) {
         setInput(path, target);
         return Promise.resolve();
       }
       return new Promise((resolve) => {
         animationTweensRef.current.set(path, {
-          path,
+          path: namespacedPath,
           from: fromValue,
           to: toValue,
           duration,
@@ -1121,12 +1509,12 @@ function VizijRuntimeProviderInner({
           easing,
           resolve
         });
-        scheduleLoop();
+        markActivity();
       });
     },
-    [cancelAnimation, getPathSnapshot, scheduleLoop, setInput]
+    [cancelAnimation, getPathSnapshot, markActivity, setInput]
   );
-  const playAnimation = useCallback(
+  const playAnimation = (0, import_react2.useCallback)(
     (id, options) => {
       const clip = assetBundle.animations?.find((anim) => anim.id === id);
       if (!clip) {
@@ -1149,12 +1537,12 @@ function VizijRuntimeProviderInner({
           weight,
           resolve
         });
-        scheduleLoop();
+        markActivity();
       });
     },
-    [assetBundle.animations, scheduleLoop]
+    [assetBundle.animations, markActivity]
   );
-  const stopAnimation = useCallback(
+  const stopAnimation = (0, import_react2.useCallback)(
     (id) => {
       const clip = assetBundle.animations?.find((anim) => anim.id === id);
       const state = clipPlaybackRef.current.get(id);
@@ -1173,7 +1561,7 @@ function VizijRuntimeProviderInner({
     },
     [assetBundle.animations, setInput]
   );
-  const registerInputDriver = useCallback(
+  const registerInputDriver = (0, import_react2.useCallback)(
     (id, factory) => {
       const driver = factory({
         setInput,
@@ -1223,32 +1611,111 @@ function VizijRuntimeProviderInner({
     },
     [faceId, namespace, pushError, setInput, setRendererValue]
   );
-  const advanceAnimations = useCallback(
+  const advanceAnimations = (0, import_react2.useCallback)(
     (dt) => {
       advanceAnimationTweens(dt);
       advanceClipPlayback(dt);
     },
     [advanceAnimationTweens, advanceClipPlayback]
   );
-  const step = useCallback(
-    (dt) => {
+  const flushStagedInputs = (0, import_react2.useCallback)(() => {
+    if (stagedInputsRef.current.size === 0) {
+      return;
+    }
+    stagedInputsRef.current.forEach(({ value, shape }, path) => {
+      orchestratorSetInput(path, value, shape);
+    });
+    stagedInputsRef.current.clear();
+  }, [orchestratorSetInput]);
+  const step = (0, import_react2.useCallback)(
+    (dt, opts) => {
+      if (dt > 0 && Number.isFinite(dt)) {
+        const prev = avgStepDtRef.current ?? dt;
+        const alpha = 0.1;
+        avgStepDtRef.current = prev * (1 - alpha) + dt * alpha;
+      }
       advanceAnimations(dt);
-      stepRuntime(dt);
+      flushStagedInputs();
+      if (driveOrchestratorRef.current || opts?.forceRuntime) {
+        stepRuntime(dt);
+      }
     },
-    [advanceAnimations, stepRuntime]
+    [advanceAnimations, flushStagedInputs, stepRuntime]
   );
-  useEffect(() => {
+  (0, import_react2.useEffect)(() => {
+    if (loopMode !== "active") {
+      return;
+    }
+    let rafId = null;
+    let lastTime = null;
+    const tick = (timestamp) => {
+      if (loopModeRef.current !== "active") {
+        return;
+      }
+      if (lastTime == null) {
+        lastTime = timestamp;
+      }
+      const dt = Math.max(0, (timestamp - lastTime) / 1e3);
+      lastTime = timestamp;
+      step(dt || 0);
+      requestLoopMode(computeDesiredLoopMode());
+      rafId = requestAnimationFrame(tick);
+    };
+    rafId = requestAnimationFrame(tick);
     return () => {
-      if (rafHandleRef.current !== null) {
-        cancelAnimationFrame(rafHandleRef.current);
-        rafHandleRef.current = null;
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+      }
+    };
+  }, [loopMode, computeDesiredLoopMode, requestLoopMode, step]);
+  (0, import_react2.useEffect)(() => {
+    if (loopMode !== "idle-visible" && loopMode !== "idle-hidden") {
+      return;
+    }
+    if (typeof window === "undefined") {
+      return;
+    }
+    const fps = loopMode === "idle-visible" ? VISIBLE_IDLE_FPS : HIDDEN_IDLE_FPS;
+    if (fps <= 0) {
+      return;
+    }
+    let lastTime = now();
+    const interval = 1e3 / fps;
+    const tick = () => {
+      if (loopModeRef.current !== "idle-visible" && loopModeRef.current !== "idle-hidden") {
+        return;
       }
-      lastFrameTimeRef.current = null;
+      const current = now();
+      const dt = Math.max(0, (current - lastTime) / 1e3);
+      lastTime = current;
+      step(dt || 0);
+      requestLoopMode(computeDesiredLoopMode());
+    };
+    const intervalId = window.setInterval(tick, interval);
+    return () => {
+      window.clearInterval(intervalId);
+    };
+  }, [loopMode, computeDesiredLoopMode, requestLoopMode, step]);
+  (0, import_react2.useEffect)(() => {
+    return () => {
       animationTweensRef.current.clear();
       clipPlaybackRef.current.clear();
     };
   }, []);
-  const contextValue = useMemo(
+  (0, import_react2.useEffect)(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const id = window.setInterval(() => {
+      const avg = avgStepDtRef.current;
+      const stepHz = avg && Number.isFinite(avg) && avg > 0 ? 1 / avg : void 0;
+      reportStatus(
+        (prev) => prev.stepHz === stepHz ? prev : { ...prev, stepHz }
+      );
+    }, 500);
+    return () => window.clearInterval(id);
+  }, [reportStatus]);
+  const contextValue = (0, import_react2.useMemo)(
     () => ({
       ...status,
       assetBundle,
@@ -1261,7 +1728,8 @@ function VizijRuntimeProviderInner({
       playAnimation,
       stopAnimation,
       step,
-      advanceAnimations
+      advanceAnimations,
+      inputConstraints
     }),
     [
       status,
@@ -1275,20 +1743,21 @@ function VizijRuntimeProviderInner({
       playAnimation,
       stopAnimation,
       step,
-      advanceAnimations
+      advanceAnimations,
+      inputConstraints
     ]
   );
-  return /* @__PURE__ */ jsx(VizijRuntimeContext.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(VizijRuntimeContext.Provider, { value: contextValue, children });
 }
 
 // src/VizijRuntimeFace.tsx
-import { memo } from "react";
-import { Vizij } from "@vizij/render";
+var import_react4 = require("react");
+var import_render2 = require("@vizij/render");
 
 // src/hooks/useVizijRuntime.ts
-import { useContext } from "react";
+var import_react3 = require("react");
 function useVizijRuntime() {
-  const ctx = useContext(VizijRuntimeContext);
+  const ctx = (0, import_react3.useContext)(VizijRuntimeContext);
   if (!ctx) {
     throw new Error(
       "useVizijRuntime must be used within a VizijRuntimeProvider."
@@ -1298,7 +1767,7 @@ function useVizijRuntime() {
 }
 
 // src/VizijRuntimeFace.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
+var import_jsx_runtime2 = require("react/jsx-runtime");
 function VizijRuntimeFaceInner({
   namespaceOverride,
   ...props
@@ -1307,8 +1776,8 @@ function VizijRuntimeFaceInner({
   if (!rootId) {
     return null;
   }
-  return /* @__PURE__ */ jsx2(
-    Vizij,
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    import_render2.Vizij,
     {
       ...props,
       rootId,
@@ -1316,19 +1785,17 @@ function VizijRuntimeFaceInner({
     }
   );
 }
-var VizijRuntimeFace = memo(VizijRuntimeFaceInner);
+var VizijRuntimeFace = (0, import_react4.memo)(VizijRuntimeFaceInner);
 
 // src/hooks/useVizijOutputs.ts
-import {
-  useVizijStore
-} from "@vizij/render";
-import { getLookup } from "@vizij/utils";
+var import_render3 = require("@vizij/render");
+var import_utils = require("@vizij/utils");
 function useVizijOutputs(paths) {
   const { namespace } = useVizijRuntime();
-  return useVizijStore((state) => {
+  return (0, import_render3.useVizijStore)((state) => {
     const result = {};
     paths.forEach((path) => {
-      const lookup = getLookup(namespace, path);
+      const lookup = (0, import_utils.getLookup)(namespace, path);
       result[path] = state.values.get(lookup);
     });
     return result;
@@ -1336,17 +1803,15 @@ function useVizijOutputs(paths) {
 }
 
 // src/hooks/useRigInput.ts
-import { useCallback as useCallback2 } from "react";
-import {
-  useVizijStore as useVizijStore2
-} from "@vizij/render";
-import { getLookup as getLookup2 } from "@vizij/utils";
+var import_react5 = require("react");
+var import_render4 = require("@vizij/render");
+var import_utils2 = require("@vizij/utils");
 function useRigInput(path) {
   const { namespace, setInput } = useVizijRuntime();
-  const value = useVizijStore2((state) => {
-    return state.values.get(getLookup2(namespace, path));
+  const value = (0, import_render4.useVizijStore)((state) => {
+    return state.values.get((0, import_utils2.getLookup)(namespace, path));
   });
-  const setter = useCallback2(
+  const setter = (0, import_react5.useCallback)(
     (next, shape) => {
       setInput(path, next, shape);
     },
@@ -1354,10 +1819,11 @@ function useRigInput(path) {
   );
   return [value, setter];
 }
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   VizijRuntimeFace,
   VizijRuntimeProvider,
   useRigInput,
   useVizijOutputs,
   useVizijRuntime
-};
+});