@vizij/orchestrator-react 0.0.1

package/dist/index.d.ts

@@ -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 };

package/dist/index.js

@@ -0,0 +1,534 @@
+// src/index.ts
+import {
+  listOrchestrationFixtures,
+  loadOrchestrationBundle,
+  loadOrchestrationDescriptor,
+  loadOrchestrationJson
+} from "@vizij/orchestrator-wasm";
+
+// src/OrchestratorProvider.tsx
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import {
+  init as initOrchestratorWasm,
+  createOrchestrator as createOrchestratorWasm,
+  abi_version as orchestratorAbiVersion
+} from "@vizij/orchestrator-wasm";
+
+// src/context.ts
+import { createContext } from "react";
+var OrchestratorContext = createContext(
+  null
+);
+
+// src/OrchestratorProvider.tsx
+import { jsx } from "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 = useRef(true);
+  useEffect(
+    () => () => {
+      mountedRef.current = false;
+    },
+    []
+  );
+  const initPromiseRef = useRef(null);
+  const orchestratorRef = useRef(null);
+  const createPromiseRef = useRef(null);
+  const latestFrameRef = useRef(null);
+  const pathCacheRef = useRef(/* @__PURE__ */ new Map());
+  const pathSubscribersRef = useRef(/* @__PURE__ */ new Map());
+  const frameSubscribersRef = useRef(/* @__PURE__ */ new Set());
+  const [ready, setReady] = useState(false);
+  const [initError, setInitError] = useState(null);
+  const ensureInit = useCallback(() => {
+    if (!initPromiseRef.current) {
+      const resolved = normalizeInitInput(initInput);
+      initPromiseRef.current = initOrchestratorWasm(resolved).catch((err) => {
+        setInitError(err instanceof Error ? err : new Error(String(err)));
+        throw err;
+      });
+    }
+    return initPromiseRef.current;
+  }, [initInput]);
+  const applyFrame = 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 = useCallback(
+    async (opts) => {
+      if (orchestratorRef.current) {
+        return orchestratorRef.current;
+      }
+      if (!createPromiseRef.current) {
+        createPromiseRef.current = (async () => {
+          await ensureInit();
+          const instance = await createOrchestratorWasm(
+            opts ?? createOptions ?? void 0
+          );
+          orchestratorRef.current = instance;
+          if (mountedRef.current) {
+            setReady(true);
+          }
+          return instance;
+        })();
+      }
+      return createPromiseRef.current;
+    },
+    [createOptions, ensureInit]
+  );
+  const requireOrchestrator = useCallback(() => {
+    const instance = orchestratorRef.current;
+    if (!instance) {
+      throw new Error(
+        "Orchestrator not created yet. Call createOrchestrator() first."
+      );
+    }
+    return instance;
+  }, []);
+  const stepRuntime = 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 = useCallback(
+    async (opts) => {
+      await ensureOrchestrator(opts);
+    },
+    [ensureOrchestrator]
+  );
+  const registerGraph = useCallback(
+    (cfg) => {
+      const instance = requireOrchestrator();
+      return instance.registerGraph(cfg);
+    },
+    [requireOrchestrator]
+  );
+  const registerMergedGraph = useCallback(
+    (cfg) => {
+      const instance = requireOrchestrator();
+      return instance.registerMergedGraph(cfg);
+    },
+    [requireOrchestrator]
+  );
+  const registerAnimation = useCallback(
+    (cfg) => {
+      const instance = requireOrchestrator();
+      return instance.registerAnimation(cfg);
+    },
+    [requireOrchestrator]
+  );
+  const prebind = useCallback(
+    (resolver) => {
+      const instance = requireOrchestrator();
+      instance.prebind(resolver);
+    },
+    [requireOrchestrator]
+  );
+  const setInput = 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 = 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 = 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 = useCallback(
+    (id) => {
+      const instance = requireOrchestrator();
+      return instance.removeGraph(id);
+    },
+    [requireOrchestrator]
+  );
+  const removeAnimation = useCallback(
+    (id) => {
+      const instance = requireOrchestrator();
+      return instance.removeAnimation(id);
+    },
+    [requireOrchestrator]
+  );
+  const normalizeGraphSpec = 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 = useCallback(async () => {
+    await ensureInit();
+    return orchestratorAbiVersion();
+  }, [ensureInit]);
+  const getLatestFrame = useCallback(() => latestFrameRef.current, []);
+  const getFrameSnapshot = useCallback(() => latestFrameRef.current, []);
+  const subscribeToFrame = useCallback((cb) => {
+    const listeners = frameSubscribersRef.current;
+    listeners.add(cb);
+    return () => {
+      listeners.delete(cb);
+    };
+  }, []);
+  const getPathSnapshot = useCallback((path) => {
+    try {
+      const normalizedPath = normalizeTypedPath(path);
+      return pathCacheRef.current.get(normalizedPath);
+    } catch {
+      return void 0;
+    }
+  }, []);
+  const subscribeToPath = 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);
+      }
+    };
+  }, []);
+  useEffect(() => {
+    let cancelled = false;
+    ensureInit().catch((err) => {
+      if (!cancelled) {
+        console.error("@vizij/orchestrator-react: failed to init wasm", err);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [ensureInit]);
+  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]);
+  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]);
+  useEffect(() => {
+    if (initError) {
+      console.error("@vizij/orchestrator-react: init error", initError);
+    }
+  }, [initError]);
+  const contextValue = 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__ */ jsx(OrchestratorContext.Provider, { value: contextValue, children });
+}
+
+// src/hooks/useOrchestrator.ts
+import { useContext } from "react";
+function useOrchestrator() {
+  const ctx = useContext(OrchestratorContext);
+  if (!ctx) {
+    throw new Error(
+      "useOrchestrator must be used within an OrchestratorProvider."
+    );
+  }
+  return ctx;
+}
+
+// src/hooks/useOrchTarget.ts
+import { useSyncExternalStore } from "react";
+function useOrchTarget(path) {
+  const ctx = useOrchestrator();
+  return 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
+import { useSyncExternalStore as useSyncExternalStore2 } from "react";
+function useOrchFrame() {
+  const ctx = useOrchestrator();
+  return useSyncExternalStore2(
+    (cb) => ctx.subscribeToFrame(cb),
+    () => ctx.getFrameSnapshot(),
+    () => ctx.getFrameSnapshot()
+  );
+}
+
+// src/valueHelpers.ts
+import {
+  valueAsNumber as sharedValueAsNumber,
+  valueAsVec3 as sharedValueAsVec3,
+  valueAsBool as sharedValueAsBool
+} from "@vizij/value-json";
+function valueAsNumber(value) {
+  return sharedValueAsNumber(value);
+}
+function valueAsVec3(value) {
+  return sharedValueAsVec3(value);
+}
+function valueAsBool(value) {
+  return sharedValueAsBool(value);
+}
+
+// src/index.ts
+import {
+  init,
+  createOrchestrator,
+  Orchestrator
+} from "@vizij/orchestrator-wasm";
+var samples = {
+  list: listOrchestrationFixtures,
+  load: loadOrchestrationDescriptor,
+  loadJson: loadOrchestrationJson,
+  loadBundle: loadOrchestrationBundle
+};
+export {
+  OrchestratorProvider,
+  Orchestrator as OrchestratorRuntime,
+  createOrchestrator as createOrchestratorRuntime,
+  init as initOrchestratorWasm,
+  listOrchestrationFixtures,
+  loadOrchestrationBundle,
+  loadOrchestrationDescriptor,
+  loadOrchestrationJson,
+  samples,
+  useOrchFrame,
+  useOrchTarget,
+  useOrchestrator,
+  valueAsBool,
+  valueAsNumber,
+  valueAsVec3
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@vizij/orchestrator-react",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vizij-ai/vizij-web",
+    "directory": "packages/@vizij/orchestrator-react"
+  },
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch --external react,@vizij/orchestrator-wasm,@vizij/value-json",
+    "build": "tsup src/index.ts --format esm,cjs --dts --external react,@vizij/orchestrator-wasm,@vizij/value-json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "pnpm --filter \"$npm_package_name\" exec eslint --ext .js,.jsx,.ts,.tsx -- .",
+    "lint:fix": "pnpm --filter \"$npm_package_name\" exec eslint --ext .js,.jsx,.ts,.tsx --fix -- .",
+    "prettier:check": "prettier --check .",
+    "prettier:write": "prettier --write .",
+    "test": "vitest --run --passWithNoTests",
+    "clean": "rm -rf dist coverage tsconfig.tsbuildinfo",
+    "reset": "rm -rf node_modules",
+    "reset:hard": "pnpm run reset && rm -f pnpm-lock.yaml package-lock.json yarn.lock",
+    "prepack": "pnpm run build && pnpm run test && pnpm run typecheck"
+  },
+  "dependencies": {
+    "@vizij/orchestrator-wasm": "^0.2.3",
+    "@vizij/value-json": "^0.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^14.3.1",
+    "@types/react": "^18.2.0",
+    "jsdom": "^24.1.3",
+    "typescript": "^5.5.0",
+    "vitest": "^3.2.4",
+    "prettier": "^3.4.2",
+    "react-dom": "^18.2.0",
+    "tsup": "^8.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}