@vizij/orchestrator-react 0.0.1

package/dist/index.cjs

@@ -0,0 +1,550 @@
+"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, {
+  OrchestratorProvider: () => OrchestratorProvider,
+  OrchestratorRuntime: () => import_orchestrator_wasm3.Orchestrator,
+  createOrchestratorRuntime: () => import_orchestrator_wasm3.createOrchestrator,
+  initOrchestratorWasm: () => import_orchestrator_wasm3.init,
+  listOrchestrationFixtures: () => import_orchestrator_wasm2.listOrchestrationFixtures,
+  loadOrchestrationBundle: () => import_orchestrator_wasm2.loadOrchestrationBundle,
+  loadOrchestrationDescriptor: () => import_orchestrator_wasm2.loadOrchestrationDescriptor,
+  loadOrchestrationJson: () => import_orchestrator_wasm2.loadOrchestrationJson,
+  samples: () => samples,
+  useOrchFrame: () => useOrchFrame,
+  useOrchTarget: () => useOrchTarget,
+  useOrchestrator: () => useOrchestrator,
+  valueAsBool: () => valueAsBool,
+  valueAsNumber: () => valueAsNumber,
+  valueAsVec3: () => valueAsVec3
+});
+module.exports = __toCommonJS(index_exports);
+var import_orchestrator_wasm2 = require("@vizij/orchestrator-wasm");
+
+// src/OrchestratorProvider.tsx
+var import_react2 = require("react");
+var import_orchestrator_wasm = require("@vizij/orchestrator-wasm");
+
+// src/context.ts
+var import_react = require("react");
+var OrchestratorContext = (0, import_react.createContext)(
+  null
+);
+
+// src/OrchestratorProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function normalizeInitInput(input) {
+  if (input == null) {
+    return void 0;
+  }
+  if (typeof input === "string") {
+    return input;
+  }
+  if (typeof Uint8Array !== "undefined" && input instanceof Uint8Array) {
+    return input;
+  }
+  if (typeof URL !== "undefined" && input instanceof URL) {
+    return input;
+  }
+  if (typeof input === "object" && "url" in input && typeof input.url === "string") {
+    return input.url;
+  }
+  return void 0;
+}
+function normalizeTypedPath(path) {
+  if (typeof path !== "string") {
+    throw new Error("Typed paths must be provided as strings.");
+  }
+  const trimmed = path.trim();
+  if (trimmed.length === 0) {
+    throw new Error("Typed paths must not be empty.");
+  }
+  if (/\s/.test(trimmed)) {
+    throw new Error(
+      "Typed paths may not contain whitespace. Use '/' to separate namespace segments."
+    );
+  }
+  return trimmed;
+}
+var noopUnsubscribe = () => {
+};
+function OrchestratorProvider({
+  children,
+  initInput,
+  autoCreate = true,
+  createOptions,
+  autostart = false
+}) {
+  const mountedRef = (0, import_react2.useRef)(true);
+  (0, import_react2.useEffect)(
+    () => () => {
+      mountedRef.current = false;
+    },
+    []
+  );
+  const initPromiseRef = (0, import_react2.useRef)(null);
+  const orchestratorRef = (0, import_react2.useRef)(null);
+  const createPromiseRef = (0, import_react2.useRef)(null);
+  const latestFrameRef = (0, import_react2.useRef)(null);
+  const pathCacheRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  const pathSubscribersRef = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
+  const frameSubscribersRef = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  const [ready, setReady] = (0, import_react2.useState)(false);
+  const [initError, setInitError] = (0, import_react2.useState)(null);
+  const ensureInit = (0, import_react2.useCallback)(() => {
+    if (!initPromiseRef.current) {
+      const resolved = normalizeInitInput(initInput);
+      initPromiseRef.current = (0, import_orchestrator_wasm.init)(resolved).catch((err) => {
+        setInitError(err instanceof Error ? err : new Error(String(err)));
+        throw err;
+      });
+    }
+    return initPromiseRef.current;
+  }, [initInput]);
+  const applyFrame = (0, import_react2.useCallback)((frame) => {
+    latestFrameRef.current = frame;
+    if (frame) {
+      const cache = pathCacheRef.current;
+      const subscribers = pathSubscribersRef.current;
+      for (const write of frame.merged_writes) {
+        let pathKey = write.path;
+        try {
+          pathKey = normalizeTypedPath(write.path);
+        } catch (err) {
+          console.warn(
+            "@vizij/orchestrator-react: received write with invalid path",
+            write.path,
+            err
+          );
+        }
+        cache.set(pathKey, write.value);
+        const listeners = subscribers.get(pathKey);
+        if (listeners) {
+          listeners.forEach((listener) => listener());
+        }
+      }
+    }
+    frameSubscribersRef.current.forEach((listener) => listener());
+  }, []);
+  const ensureOrchestrator = (0, import_react2.useCallback)(
+    async (opts) => {
+      if (orchestratorRef.current) {
+        return orchestratorRef.current;
+      }
+      if (!createPromiseRef.current) {
+        createPromiseRef.current = (async () => {
+          await ensureInit();
+          const instance = await (0, import_orchestrator_wasm.createOrchestrator)(
+            opts ?? createOptions ?? void 0
+          );
+          orchestratorRef.current = instance;
+          if (mountedRef.current) {
+            setReady(true);
+          }
+          return instance;
+        })();
+      }
+      return createPromiseRef.current;
+    },
+    [createOptions, ensureInit]
+  );
+  const requireOrchestrator = (0, import_react2.useCallback)(() => {
+    const instance = orchestratorRef.current;
+    if (!instance) {
+      throw new Error(
+        "Orchestrator not created yet. Call createOrchestrator() first."
+      );
+    }
+    return instance;
+  }, []);
+  const stepRuntime = (0, import_react2.useCallback)(
+    (dt) => {
+      if (!Number.isFinite(dt)) {
+        throw new Error("step(dt) requires a finite number of seconds.");
+      }
+      const instance = orchestratorRef.current;
+      if (!instance) {
+        return null;
+      }
+      const frame = instance.step(dt);
+      if (frame) {
+        applyFrame(frame);
+        return frame;
+      }
+      return null;
+    },
+    [applyFrame]
+  );
+  const createOrchestratorFn = (0, import_react2.useCallback)(
+    async (opts) => {
+      await ensureOrchestrator(opts);
+    },
+    [ensureOrchestrator]
+  );
+  const registerGraph = (0, import_react2.useCallback)(
+    (cfg) => {
+      const instance = requireOrchestrator();
+      return instance.registerGraph(cfg);
+    },
+    [requireOrchestrator]
+  );
+  const registerMergedGraph = (0, import_react2.useCallback)(
+    (cfg) => {
+      const instance = requireOrchestrator();
+      return instance.registerMergedGraph(cfg);
+    },
+    [requireOrchestrator]
+  );
+  const registerAnimation = (0, import_react2.useCallback)(
+    (cfg) => {
+      const instance = requireOrchestrator();
+      return instance.registerAnimation(cfg);
+    },
+    [requireOrchestrator]
+  );
+  const prebind = (0, import_react2.useCallback)(
+    (resolver) => {
+      const instance = requireOrchestrator();
+      instance.prebind(resolver);
+    },
+    [requireOrchestrator]
+  );
+  const setInput = (0, import_react2.useCallback)(
+    (path, value, shape) => {
+      const normalizedPath = normalizeTypedPath(path);
+      const instance = requireOrchestrator();
+      instance.setInput(normalizedPath, value, shape);
+      pathCacheRef.current.set(normalizedPath, value);
+      const listeners = pathSubscribersRef.current.get(normalizedPath);
+      if (listeners) {
+        listeners.forEach((listener) => {
+          try {
+            listener();
+          } catch (err) {
+            console.error(
+              "@vizij/orchestrator-react: setInput listener error",
+              err
+            );
+          }
+        });
+      }
+    },
+    [requireOrchestrator]
+  );
+  const removeInput = (0, import_react2.useCallback)(
+    (path) => {
+      const normalizedPath = normalizeTypedPath(path);
+      const instance = requireOrchestrator();
+      const removed = instance.removeInput(normalizedPath);
+      if (removed) {
+        pathCacheRef.current.delete(normalizedPath);
+        const listeners = pathSubscribersRef.current.get(normalizedPath);
+        if (listeners) {
+          listeners.forEach((listener) => listener());
+        }
+      }
+      return removed;
+    },
+    [requireOrchestrator]
+  );
+  const listControllers = (0, import_react2.useCallback)(() => {
+    const instance = orchestratorRef.current;
+    if (!instance) {
+      return { graphs: [], anims: [] };
+    }
+    const result = instance.listControllers();
+    const graphs = Array.isArray(result?.graphs) ? result?.graphs : [];
+    const anims = Array.isArray(result?.anims) ? result?.anims : [];
+    return { graphs, anims };
+  }, []);
+  const removeGraph = (0, import_react2.useCallback)(
+    (id) => {
+      const instance = requireOrchestrator();
+      return instance.removeGraph(id);
+    },
+    [requireOrchestrator]
+  );
+  const removeAnimation = (0, import_react2.useCallback)(
+    (id) => {
+      const instance = requireOrchestrator();
+      return instance.removeAnimation(id);
+    },
+    [requireOrchestrator]
+  );
+  const normalizeGraphSpec = (0, import_react2.useCallback)(
+    async (spec) => {
+      const instance = await ensureOrchestrator();
+      if (typeof instance.normalizeGraphSpec !== "function") {
+        throw new Error(
+          "@vizij/orchestrator-wasm does not expose normalizeGraphSpec(). Update to a compatible version."
+        );
+      }
+      return await instance.normalizeGraphSpec(spec);
+    },
+    [ensureOrchestrator]
+  );
+  const abiVersion = (0, import_react2.useCallback)(async () => {
+    await ensureInit();
+    return (0, import_orchestrator_wasm.abi_version)();
+  }, [ensureInit]);
+  const getLatestFrame = (0, import_react2.useCallback)(() => latestFrameRef.current, []);
+  const getFrameSnapshot = (0, import_react2.useCallback)(() => latestFrameRef.current, []);
+  const subscribeToFrame = (0, import_react2.useCallback)((cb) => {
+    const listeners = frameSubscribersRef.current;
+    listeners.add(cb);
+    return () => {
+      listeners.delete(cb);
+    };
+  }, []);
+  const getPathSnapshot = (0, import_react2.useCallback)((path) => {
+    try {
+      const normalizedPath = normalizeTypedPath(path);
+      return pathCacheRef.current.get(normalizedPath);
+    } catch {
+      return void 0;
+    }
+  }, []);
+  const subscribeToPath = (0, import_react2.useCallback)((path, cb) => {
+    if (!path) {
+      return noopUnsubscribe;
+    }
+    let normalizedPath;
+    try {
+      normalizedPath = normalizeTypedPath(path);
+    } catch (err) {
+      console.error(
+        "@vizij/orchestrator-react: subscribeToPath received invalid path",
+        path,
+        err
+      );
+      return noopUnsubscribe;
+    }
+    let listeners = pathSubscribersRef.current.get(normalizedPath);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      pathSubscribersRef.current.set(normalizedPath, listeners);
+    }
+    listeners.add(cb);
+    return () => {
+      const current = pathSubscribersRef.current.get(normalizedPath);
+      if (!current) return;
+      current.delete(cb);
+      if (current.size === 0) {
+        pathSubscribersRef.current.delete(normalizedPath);
+      }
+    };
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    let cancelled = false;
+    ensureInit().catch((err) => {
+      if (!cancelled) {
+        console.error("@vizij/orchestrator-react: failed to init wasm", err);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [ensureInit]);
+  (0, import_react2.useEffect)(() => {
+    if (!autoCreate) {
+      return;
+    }
+    let cancelled = false;
+    ensureOrchestrator().catch((err) => {
+      if (!cancelled) {
+        console.error(
+          "@vizij/orchestrator-react: failed to create orchestrator",
+          err
+        );
+      }
+    }).finally(() => {
+      if (!cancelled && mountedRef.current && autoCreate && orchestratorRef.current) {
+        setReady(true);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [autoCreate, ensureOrchestrator]);
+  (0, import_react2.useEffect)(() => {
+    if (!autostart || !ready) {
+      return;
+    }
+    const globalObj = typeof globalThis !== "undefined" ? globalThis : {};
+    const request = globalObj.requestAnimationFrame?.bind(globalObj);
+    const cancel = globalObj.cancelAnimationFrame?.bind(globalObj);
+    if (!request || !cancel) {
+      console.warn(
+        "@vizij/orchestrator-react: autostart is enabled but requestAnimationFrame is unavailable."
+      );
+      return;
+    }
+    let rafId = null;
+    let lastTs = 0;
+    const loop = (timestamp) => {
+      if (!mountedRef.current) {
+        return;
+      }
+      if (lastTs === 0) {
+        lastTs = timestamp;
+      }
+      const dt = Math.max(0, (timestamp - lastTs) / 1e3);
+      lastTs = timestamp;
+      stepRuntime(dt || 0);
+      rafId = request(loop);
+    };
+    rafId = request(loop);
+    return () => {
+      if (rafId !== null) {
+        cancel(rafId);
+      }
+    };
+  }, [autostart, ready, stepRuntime]);
+  (0, import_react2.useEffect)(() => {
+    if (initError) {
+      console.error("@vizij/orchestrator-react: init error", initError);
+    }
+  }, [initError]);
+  const contextValue = (0, import_react2.useMemo)(
+    () => ({
+      ready,
+      createOrchestrator: createOrchestratorFn,
+      registerGraph,
+      registerMergedGraph,
+      registerAnimation,
+      prebind,
+      setInput,
+      removeInput,
+      step: stepRuntime,
+      listControllers,
+      removeGraph,
+      removeAnimation,
+      getLatestFrame,
+      subscribeToPath,
+      getPathSnapshot,
+      subscribeToFrame,
+      getFrameSnapshot,
+      normalizeGraphSpec,
+      abiVersion
+    }),
+    [
+      ready,
+      createOrchestratorFn,
+      registerGraph,
+      registerMergedGraph,
+      registerAnimation,
+      prebind,
+      setInput,
+      removeInput,
+      stepRuntime,
+      listControllers,
+      removeGraph,
+      removeAnimation,
+      getLatestFrame,
+      subscribeToPath,
+      getPathSnapshot,
+      subscribeToFrame,
+      getFrameSnapshot,
+      normalizeGraphSpec,
+      abiVersion
+    ]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(OrchestratorContext.Provider, { value: contextValue, children });
+}
+
+// src/hooks/useOrchestrator.ts
+var import_react3 = require("react");
+function useOrchestrator() {
+  const ctx = (0, import_react3.useContext)(OrchestratorContext);
+  if (!ctx) {
+    throw new Error(
+      "useOrchestrator must be used within an OrchestratorProvider."
+    );
+  }
+  return ctx;
+}
+
+// src/hooks/useOrchTarget.ts
+var import_react4 = require("react");
+function useOrchTarget(path) {
+  const ctx = useOrchestrator();
+  return (0, import_react4.useSyncExternalStore)(
+    (cb) => {
+      if (!path) {
+        return () => {
+        };
+      }
+      return ctx.subscribeToPath(path, cb);
+    },
+    () => path ? ctx.getPathSnapshot(path) : void 0,
+    () => path ? ctx.getPathSnapshot(path) : void 0
+  );
+}
+
+// src/hooks/useOrchFrame.ts
+var import_react5 = require("react");
+function useOrchFrame() {
+  const ctx = useOrchestrator();
+  return (0, import_react5.useSyncExternalStore)(
+    (cb) => ctx.subscribeToFrame(cb),
+    () => ctx.getFrameSnapshot(),
+    () => ctx.getFrameSnapshot()
+  );
+}
+
+// src/valueHelpers.ts
+var import_value_json = require("@vizij/value-json");
+function valueAsNumber(value) {
+  return (0, import_value_json.valueAsNumber)(value);
+}
+function valueAsVec3(value) {
+  return (0, import_value_json.valueAsVec3)(value);
+}
+function valueAsBool(value) {
+  return (0, import_value_json.valueAsBool)(value);
+}
+
+// src/index.ts
+var import_orchestrator_wasm3 = require("@vizij/orchestrator-wasm");
+var samples = {
+  list: import_orchestrator_wasm2.listOrchestrationFixtures,
+  load: import_orchestrator_wasm2.loadOrchestrationDescriptor,
+  loadJson: import_orchestrator_wasm2.loadOrchestrationJson,
+  loadBundle: import_orchestrator_wasm2.loadOrchestrationBundle
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OrchestratorProvider,
+  OrchestratorRuntime,
+  createOrchestratorRuntime,
+  initOrchestratorWasm,
+  listOrchestrationFixtures,
+  loadOrchestrationBundle,
+  loadOrchestrationDescriptor,
+  loadOrchestrationJson,
+  samples,
+  useOrchFrame,
+  useOrchTarget,
+  useOrchestrator,
+  valueAsBool,
+  valueAsNumber,
+  valueAsVec3
+});

package/dist/index.d.cts

@@ -0,0 +1,113 @@
+import { InitInput as InitInput$1, GraphRegistrationInput as GraphRegistrationInput$1, MergedGraphRegistrationConfig as MergedGraphRegistrationConfig$1, MergeStrategyOptions as MergeStrategyOptions$1, MergeConflictStrategy as MergeConflictStrategy$1, AnimationRegistrationConfig as AnimationRegistrationConfig$1, Value, Shape, OrchestratorFrame as OrchestratorFrame$1, WriteOpJSON, ConflictLog, GraphRegistrationConfig as GraphRegistrationConfig$1, GraphSubscriptions as GraphSubscriptions$1, AnimationSetup as AnimationSetup$1, listOrchestrationFixtures, loadOrchestrationDescriptor, loadOrchestrationJson, loadOrchestrationBundle } from '@vizij/orchestrator-wasm';
+export { Orchestrator as OrchestratorRuntime, AnimationRegistrationConfig as WasmAnimationRegistration, AnimationSetup as WasmAnimationSetup, ConflictLog as WasmConflictLog, GraphRegistrationInput as WasmGraphRegistration, GraphRegistrationConfig as WasmGraphRegistrationConfig, GraphSubscriptions as WasmGraphSubscriptions, MergeConflictStrategy as WasmMergeConflictStrategy, MergeStrategyOptions as WasmMergeStrategyOptions, MergedGraphRegistrationConfig as WasmMergedGraphRegistrationConfig, OrchestratorFrame as WasmOrchestratorFrame, Shape as WasmShape, Value as WasmValue, createOrchestrator as createOrchestratorRuntime, init as initOrchestratorWasm, listOrchestrationFixtures, loadOrchestrationBundle, loadOrchestrationDescriptor, loadOrchestrationJson } from '@vizij/orchestrator-wasm';
+import React from 'react';
+
+/**
+ * Shared type definitions for the orchestrator React integration.
+ * These mirror the public wasm surface while layering on React-specific details.
+ */
+
+/** Values emitted by the orchestrator writes leverage the wasm union. */
+type ValueJSON = Value;
+/** Optional shape metadata describing the serialized value structure. */
+type ShapeJSON = Shape;
+/** Individual write units emitted from the orchestrator frame merge. */
+type WriteOp = WriteOpJSON & {
+    player?: number | string;
+};
+type OrchestratorTimings = OrchestratorFrame$1["timings_ms"] & {
+    animations_ms?: number;
+    graphs_ms?: number;
+};
+type OrchestratorFrame = Omit<OrchestratorFrame$1, "merged_writes"> & {
+    merged_writes: WriteOp[];
+};
+type OrchestratorConflict = ConflictLog;
+type InitInput = InitInput$1 | {
+    url?: string;
+};
+type PrebindResolver = (path: string) => string | number | null | undefined;
+type CreateOrchOptions = {
+    schedule?: "SinglePass" | "TwoPass" | "RateDecoupled";
+};
+type ControllerId = string;
+type GraphRegistrationInput = GraphRegistrationInput$1;
+type GraphRegistrationConfig = GraphRegistrationConfig$1;
+type GraphSubscriptions = GraphSubscriptions$1;
+/**
+ * Extended merge conflict strategies recognised by the wasm bridge.
+ * Older builds only exposed "error" | "namespace" | "blend", so we
+ * widen the union with the newer additive and weighted blend aliases.
+ */
+type MergeConflictStrategy = MergeConflictStrategy$1 | "blend_equal" | "blend_equal_weights" | "add" | "sum" | "blend-sum" | "additive" | "default-blend" | "blend-default" | "blend-weights" | "weights";
+type MergeStrategyOptions = Omit<MergeStrategyOptions$1, "outputs" | "intermediate"> & {
+    outputs?: MergeConflictStrategy;
+    intermediate?: MergeConflictStrategy;
+};
+type MergedGraphRegistrationConfig = Omit<MergedGraphRegistrationConfig$1, "strategy"> & {
+    strategy?: MergeStrategyOptions;
+};
+type AnimationRegistrationConfig = AnimationRegistrationConfig$1;
+type AnimationSetup = AnimationSetup$1;
+type OrchestratorReactCtx = {
+    ready: boolean;
+    createOrchestrator: (opts?: CreateOrchOptions) => Promise<void>;
+    registerGraph: (cfg: GraphRegistrationInput) => ControllerId;
+    registerMergedGraph: (cfg: MergedGraphRegistrationConfig) => ControllerId;
+    registerAnimation: (cfg: AnimationRegistrationConfig) => ControllerId;
+    prebind?: (resolver: PrebindResolver) => void;
+    setInput: (path: string, value: ValueJSON, shape?: ShapeJSON) => void;
+    removeInput: (path: string) => boolean;
+    step: (dt: number) => OrchestratorFrame | null;
+    listControllers: () => {
+        graphs: ControllerId[];
+        anims: ControllerId[];
+    };
+    removeGraph: (id: ControllerId) => boolean;
+    removeAnimation: (id: ControllerId) => boolean;
+    getLatestFrame: () => OrchestratorFrame | null;
+    subscribeToPath: (path: string, cb: () => void) => () => void;
+    getPathSnapshot: (path: string) => ValueJSON | undefined;
+    subscribeToFrame: (cb: () => void) => () => void;
+    getFrameSnapshot: () => OrchestratorFrame | null;
+    normalizeGraphSpec?: (spec: object | string) => Promise<object>;
+    abiVersion?: () => Promise<number>;
+};
+
+type OrchestratorProviderProps = {
+    children: React.ReactNode;
+    /** Optional init() input forwarded to the wasm layer. */
+    initInput?: InitInput;
+    /** Automatically create a runtime orchestration instance on mount. Defaults to true. */
+    autoCreate?: boolean;
+    /** Options passed to the wasm createOrchestrator helper when auto-creating. */
+    createOptions?: CreateOrchOptions;
+    /**
+     * Start a requestAnimationFrame loop once ready. Defaults to false so tests and
+     * demos can opt-in to manual stepping.
+     */
+    autostart?: boolean;
+};
+declare function OrchestratorProvider({ children, initInput, autoCreate, createOptions, autostart, }: OrchestratorProviderProps): JSX.Element;
+
+declare function useOrchestrator(): OrchestratorReactCtx;
+
+declare function useOrchTarget(path?: string | null): ValueJSON | undefined;
+
+declare function useOrchFrame(): OrchestratorFrame | null;
+
+declare function valueAsNumber(value: ValueJSON | undefined): number | undefined;
+declare function valueAsVec3(value: ValueJSON | undefined): [number, number, number] | undefined;
+declare function valueAsBool(value: ValueJSON | undefined): boolean | undefined;
+
+/**
+ * Standardised access to embedded orchestration samples for quick-start demos and tests.
+ */
+declare const samples: {
+    readonly list: typeof listOrchestrationFixtures;
+    readonly load: typeof loadOrchestrationDescriptor;
+    readonly loadJson: typeof loadOrchestrationJson;
+    readonly loadBundle: typeof loadOrchestrationBundle;
+};
+
+export { type AnimationRegistrationConfig, type AnimationSetup, type ControllerId, type CreateOrchOptions, type GraphRegistrationConfig, type GraphRegistrationInput, type GraphSubscriptions, type InitInput, type MergeConflictStrategy, type MergeStrategyOptions, type MergedGraphRegistrationConfig, type OrchestratorConflict, type OrchestratorFrame, OrchestratorProvider, type OrchestratorProviderProps, type OrchestratorReactCtx, type OrchestratorTimings, type PrebindResolver, type ShapeJSON, type ValueJSON, type WriteOp, samples, useOrchFrame, useOrchTarget, useOrchestrator, valueAsBool, valueAsNumber, valueAsVec3 };