@vizij/animation-react 0.0.1

package/dist/index.cjs

@@ -0,0 +1,919 @@
+"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, {
+  AnimationProvider: () => AnimationProvider,
+  listAnimationFixtures: () => import_animation_wasm2.listAnimationFixtures,
+  loadAnimationFixture: () => import_animation_wasm2.loadAnimationFixture,
+  loadAnimationJson: () => import_animation_wasm2.loadAnimationJson,
+  resolveAnimationPath: () => import_animation_wasm2.resolveAnimationPath,
+  samples: () => samples,
+  useAnimDerivative: () => useAnimDerivative,
+  useAnimTarget: () => useAnimTarget,
+  useAnimation: () => useAnimation,
+  valueAsNumber: () => valueAsNumber,
+  valueAsNumericArray: () => valueAsNumericArray,
+  valueAsTransform: () => valueAsTransform
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/AnimationProvider.tsx
+var import_react2 = require("react");
+var import_animation_wasm = require("@vizij/animation-wasm");
+
+// src/context.ts
+var import_react = require("react");
+var AnimationContext = (0, import_react.createContext)(
+  null
+);
+
+// src/store.ts
+var noop = () => {
+};
+var makeSubKey = (playerId, key) => `${playerId}|${key}`;
+function addSubscriber(map, key, cb) {
+  let set = map.get(key);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    map.set(key, set);
+  }
+  set.add(cb);
+  return () => {
+    const current = map.get(key);
+    if (!current) return;
+    current.delete(cb);
+    if (current.size === 0) {
+      map.delete(key);
+    }
+  };
+}
+function notify(map, key) {
+  const subs = map.get(key);
+  if (!subs || subs.size === 0) return;
+  [...subs].forEach((cb) => {
+    try {
+      cb();
+    } catch (err) {
+      console.error("Animation store subscriber error", err);
+    }
+  });
+}
+function createAnimationStore() {
+  let values = {};
+  let derivatives = {};
+  let valuesByPlayer = {};
+  let derivativesByPlayer = {};
+  const keySubscribers = /* @__PURE__ */ new Map();
+  const derivativeKeySubscribers = /* @__PURE__ */ new Map();
+  const playerKeySubscribers = /* @__PURE__ */ new Map();
+  const playerDerivativeSubscribers = /* @__PURE__ */ new Map();
+  return {
+    reset() {
+      values = {};
+      derivatives = {};
+      valuesByPlayer = {};
+      derivativesByPlayer = {};
+    },
+    applyOutputs(out) {
+      if (!out || !Array.isArray(out.changes) || out.changes.length === 0) {
+        return;
+      }
+      const keyChanges = /* @__PURE__ */ new Set();
+      const derivativeKeyChanges = /* @__PURE__ */ new Set();
+      const playerKeyChanges = [];
+      const playerDerivativeChanges = [];
+      for (const change of out.changes) {
+        const key = change.key;
+        const value = change.value ?? void 0;
+        const playerId = change.player ?? void 0;
+        if (value == null) {
+          delete values[key];
+        } else {
+          values[key] = value;
+        }
+        if (typeof playerId !== "undefined") {
+          if (!valuesByPlayer[playerId]) valuesByPlayer[playerId] = {};
+          if (value == null) {
+            delete valuesByPlayer[playerId][key];
+          } else {
+            valuesByPlayer[playerId][key] = value;
+          }
+        }
+        if (typeof change.derivative !== "undefined") {
+          const derivative = change.derivative ?? void 0;
+          if (derivative == null) {
+            delete derivatives[key];
+          } else {
+            derivatives[key] = derivative;
+          }
+          if (typeof playerId !== "undefined") {
+            if (!derivativesByPlayer[playerId]) {
+              derivativesByPlayer[playerId] = {};
+            }
+            if (derivative == null) {
+              delete derivativesByPlayer[playerId][key];
+            } else {
+              derivativesByPlayer[playerId][key] = derivative;
+            }
+          }
+          derivativeKeyChanges.add(key);
+          playerDerivativeChanges.push({ playerId, key });
+        }
+        keyChanges.add(key);
+        playerKeyChanges.push({ playerId, key });
+      }
+      keyChanges.forEach((key) => notify(keySubscribers, key));
+      derivativeKeyChanges.forEach(
+        (key) => notify(derivativeKeySubscribers, key)
+      );
+      playerKeyChanges.forEach(
+        ({ playerId, key }) => notify(playerKeySubscribers, makeSubKey(playerId, key))
+      );
+      playerDerivativeChanges.forEach(
+        ({ playerId, key }) => notify(playerDerivativeSubscribers, makeSubKey(playerId, key))
+      );
+    },
+    subscribeToKey(key, cb) {
+      if (!key) return noop;
+      return addSubscriber(keySubscribers, key, cb);
+    },
+    getKeySnapshot(key) {
+      return values[key];
+    },
+    subscribeToDerivativeKey(key, cb) {
+      if (!key) return noop;
+      return addSubscriber(derivativeKeySubscribers, key, cb);
+    },
+    getKeyDerivativeSnapshot(key) {
+      return derivatives[key];
+    },
+    subscribeToPlayerKey(playerId, key, cb) {
+      if (typeof playerId === "undefined" || !key) return noop;
+      return addSubscriber(playerKeySubscribers, makeSubKey(playerId, key), cb);
+    },
+    getPlayerKeySnapshot(playerId, key) {
+      return valuesByPlayer[playerId]?.[key];
+    },
+    subscribeToPlayerDerivative(playerId, key, cb) {
+      if (typeof playerId === "undefined" || !key) return noop;
+      return addSubscriber(
+        playerDerivativeSubscribers,
+        makeSubKey(playerId, key),
+        cb
+      );
+    },
+    getPlayerDerivativeSnapshot(playerId, key) {
+      return derivativesByPlayer[playerId]?.[key];
+    },
+    getValuesByPlayer() {
+      const snapshot = {};
+      for (const [pid, mapping] of Object.entries(valuesByPlayer)) {
+        snapshot[Number(pid)] = { ...mapping };
+      }
+      return snapshot;
+    },
+    getDerivativesByPlayer() {
+      const snapshot = {};
+      for (const [pid, mapping] of Object.entries(derivativesByPlayer)) {
+        snapshot[Number(pid)] = { ...mapping };
+      }
+      return snapshot;
+    }
+  };
+}
+
+// src/AnimationProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var DEFAULT_PLAYER_NAME = "default";
+var DEFAULT_INSTANCE_CFG = {
+  weight: 1,
+  time_scale: 1,
+  start_offset: 0,
+  enabled: true
+};
+function normalizeAnimations(animations) {
+  return Array.isArray(animations) ? animations : [animations];
+}
+function AnimationProvider({
+  children,
+  animations,
+  instances,
+  prebind,
+  autostart = true,
+  updateHz,
+  engineConfig,
+  onOutputs
+}) {
+  const engineRef = (0, import_react2.useRef)(null);
+  const storeRef = (0, import_react2.useRef)(createAnimationStore());
+  const rafRef = (0, import_react2.useRef)(null);
+  const lastTimeRef = (0, import_react2.useRef)(0);
+  const lastNotifyRef = (0, import_react2.useRef)(0);
+  const onOutputsRef = (0, import_react2.useRef)(onOutputs);
+  const animsCacheRef = (0, import_react2.useRef)(null);
+  const animIdsRef = (0, import_react2.useRef)([]);
+  const instancesRef = (0, import_react2.useRef)({});
+  (0, import_react2.useEffect)(() => {
+    onOutputsRef.current = onOutputs;
+  }, [onOutputs]);
+  const animKey = (0, import_react2.useMemo)(() => {
+    try {
+      return JSON.stringify(
+        Array.isArray(animations) ? animations : [animations]
+      );
+    } catch {
+      return String(Math.random());
+    }
+  }, [animations]);
+  const instKey = (0, import_react2.useMemo)(() => {
+    try {
+      return JSON.stringify(instances ?? []);
+    } catch {
+      return String(Math.random());
+    }
+  }, [instances]);
+  const [ready, setReady] = (0, import_react2.useState)(false);
+  const [players, setPlayers] = (0, import_react2.useState)({});
+  const applyOutputs = (0, import_react2.useCallback)(
+    (out) => {
+      storeRef.current.applyOutputs(out);
+      if (!out) return;
+      try {
+        onOutputsRef.current?.(out);
+      } catch (err) {
+        console.error("Animation onOutputs callback error", err);
+      }
+    },
+    []
+  );
+  const refreshPlayersAndInstances = (0, import_react2.useCallback)((eng) => {
+    try {
+      const playersInfo = eng.listPlayers();
+      const nextPlayers = {};
+      const nextInstances = {};
+      for (const info of playersInfo) {
+        const playerId = info.id;
+        nextPlayers[info.name] = playerId;
+        try {
+          const instInfos = eng.listInstances(
+            playerId
+          );
+          nextInstances[info.name] = instInfos.map(
+            (inst) => inst.id
+          );
+        } catch {
+          nextInstances[info.name] = [];
+        }
+      }
+      setPlayers(nextPlayers);
+      instancesRef.current = nextInstances;
+    } catch (err) {
+      console.warn("Animation refreshPlayersAndInstances failed", err);
+    }
+  }, []);
+  const resolveAnimId = (0, import_react2.useCallback)(
+    (animIndexOrId) => {
+      if (Number.isInteger(animIndexOrId) && animIndexOrId >= 0) {
+        const byIndex = animIdsRef.current[animIndexOrId];
+        if (typeof byIndex !== "undefined") {
+          return byIndex;
+        }
+      }
+      if (typeof animIndexOrId === "number") {
+        return animIndexOrId;
+      }
+      return void 0;
+    },
+    []
+  );
+  const loadAnimationsAndInstances = (0, import_react2.useCallback)(
+    (eng, animList, instSpecs) => {
+      const serialized = JSON.stringify(animList);
+      if (!animsCacheRef.current || animsCacheRef.current.json !== serialized) {
+        const ids = [];
+        for (const anim of animList) {
+          const id = eng.loadAnimation(anim, { format: "stored" });
+          ids.push(id);
+        }
+        animIdsRef.current = ids;
+        animsCacheRef.current = { json: serialized, count: animList.length };
+      }
+      instancesRef.current = {};
+      if (instSpecs && instSpecs.length > 0) {
+        for (const spec of instSpecs) {
+          const playerId = eng.createPlayer(spec.playerName);
+          const animIndex = spec.animIndex ?? 0;
+          const animId = animIdsRef.current[animIndex] ?? animIdsRef.current[0] ?? 0;
+          const cfgFinal = {
+            ...DEFAULT_INSTANCE_CFG,
+            ...spec.cfg
+          };
+          const instId = eng.addInstance(
+            playerId,
+            animId,
+            cfgFinal
+          );
+          if (!instancesRef.current[spec.playerName]) {
+            instancesRef.current[spec.playerName] = [];
+          }
+          instancesRef.current[spec.playerName].push(instId);
+        }
+      } else {
+        const playerId = eng.createPlayer(DEFAULT_PLAYER_NAME);
+        const animId = animIdsRef.current[0] ?? 0;
+        const instId = eng.addInstance(
+          playerId,
+          animId,
+          { ...DEFAULT_INSTANCE_CFG }
+        );
+        instancesRef.current[DEFAULT_PLAYER_NAME] = [instId];
+      }
+    },
+    []
+  );
+  (0, import_react2.useEffect)(() => {
+    let cancelled = false;
+    (async () => {
+      try {
+        await (0, import_animation_wasm.init)();
+      } catch (err) {
+        console.error("Failed to init @vizij/animation-wasm", err);
+        return;
+      }
+      if (cancelled) return;
+      const store = storeRef.current;
+      store.reset();
+      animsCacheRef.current = null;
+      animIdsRef.current = [];
+      instancesRef.current = {};
+      lastTimeRef.current = 0;
+      lastNotifyRef.current = 0;
+      const engine = new import_animation_wasm.Engine(engineConfig);
+      engineRef.current = engine;
+      if (prebind) {
+        try {
+          engine.prebind(prebind);
+        } catch (err) {
+          console.error("Animation prebind failed", err);
+        }
+      }
+      const list = normalizeAnimations(animations);
+      loadAnimationsAndInstances(engine, list, instances);
+      if (autostart) {
+        applyOutputs(engine.updateValuesAndDerivatives(0));
+      }
+      refreshPlayersAndInstances(engine);
+      setReady(true);
+      if (!autostart) return;
+      const loop = (time) => {
+        if (cancelled) return;
+        const eng = engineRef.current;
+        if (!eng) return;
+        const last = lastTimeRef.current || time;
+        const dt = (time - last) / 1e3;
+        lastTimeRef.current = time;
+        const now = performance.now();
+        const interval = updateHz && updateHz > 0 ? 1e3 / updateHz : 0;
+        if (!interval || now - lastNotifyRef.current >= interval) {
+          const out = eng.updateValuesAndDerivatives(dt);
+          applyOutputs(out);
+          lastNotifyRef.current = now;
+        } else {
+          eng.updateValues(dt);
+        }
+        rafRef.current = requestAnimationFrame(loop);
+      };
+      rafRef.current = requestAnimationFrame(loop);
+    })();
+    return () => {
+      cancelled = true;
+      if (rafRef.current) {
+        cancelAnimationFrame(rafRef.current);
+      }
+      rafRef.current = null;
+      engineRef.current = null;
+    };
+  }, [autostart, updateHz, prebind, engineConfig, animKey, instKey]);
+  const resolvePlayerId = (0, import_react2.useCallback)(
+    (player) => {
+      if (typeof player === "number") return player;
+      return players[player];
+    },
+    [players]
+  );
+  const step = (0, import_react2.useCallback)(
+    (dt, inputs) => {
+      const eng = engineRef.current;
+      if (!eng) return;
+      applyOutputs(eng.updateValuesAndDerivatives(dt, inputs));
+    },
+    [applyOutputs]
+  );
+  const reload = (0, import_react2.useCallback)(
+    (animPayload, instSpecs) => {
+      const eng = engineRef.current;
+      if (!eng) return;
+      try {
+        const playersInfo = eng.listPlayers();
+        for (const playerInfo of playersInfo) {
+          const playerId = playerInfo.id;
+          try {
+            const instInfos = eng.listInstances(
+              playerId
+            );
+            for (const inst of instInfos) {
+              try {
+                eng.removeInstance(playerId, inst.id);
+              } catch (err) {
+                console.warn("Failed to remove instance during reload", err);
+              }
+            }
+          } catch (err) {
+            console.warn("Failed to enumerate instances during reload", err);
+          }
+          try {
+            eng.removePlayer(playerId);
+          } catch (err) {
+            console.warn("Failed to remove player during reload", err);
+          }
+        }
+      } catch (err) {
+        console.warn("Engine state cleanup failed before reload", err);
+      }
+      if (animIdsRef.current.length > 0) {
+        for (const animId of animIdsRef.current) {
+          try {
+            eng.unloadAnimation(animId);
+          } catch (err) {
+            console.warn("Failed to unload animation during reload", err);
+          }
+        }
+      }
+      storeRef.current.reset();
+      animsCacheRef.current = null;
+      animIdsRef.current = [];
+      instancesRef.current = {};
+      setPlayers({});
+      const list = normalizeAnimations(animPayload);
+      loadAnimationsAndInstances(eng, list, instSpecs);
+      applyOutputs(eng.updateValuesAndDerivatives(0));
+      refreshPlayersAndInstances(eng);
+    },
+    [applyOutputs, loadAnimationsAndInstances, refreshPlayersAndInstances]
+  );
+  const addPlayer = (0, import_react2.useCallback)(
+    (name) => {
+      const eng = engineRef.current;
+      if (!eng) return -1;
+      if (typeof players[name] !== "undefined") return players[name];
+      const playerId = eng.createPlayer(name);
+      setPlayers((prev) => ({ ...prev, [name]: playerId }));
+      if (!instancesRef.current[name]) instancesRef.current[name] = [];
+      return playerId;
+    },
+    [players]
+  );
+  const addAnimations = (0, import_react2.useCallback)(
+    (anims) => {
+      const eng = engineRef.current;
+      if (!eng) return [];
+      const list = normalizeAnimations(anims);
+      const newIds = [];
+      for (const anim of list) {
+        const id = eng.loadAnimation(anim, { format: "stored" });
+        animIdsRef.current.push(id);
+        newIds.push(id);
+      }
+      try {
+        const prev = animsCacheRef.current ? JSON.parse(animsCacheRef.current.json) : [];
+        const merged = [...prev, ...list];
+        animsCacheRef.current = {
+          json: JSON.stringify(merged),
+          count: merged.length
+        };
+      } catch {
+      }
+      applyOutputs(eng.updateValuesAndDerivatives(0));
+      refreshPlayersAndInstances(eng);
+      return newIds;
+    },
+    [applyOutputs, refreshPlayersAndInstances]
+  );
+  const addInstances = (0, import_react2.useCallback)(
+    (specs) => {
+      const eng = engineRef.current;
+      if (!eng || !specs || specs.length === 0) return [];
+      const results = [];
+      const nextPlayers = { ...players };
+      for (const spec of specs) {
+        let playerId = nextPlayers[spec.playerName];
+        if (typeof playerId === "undefined") {
+          playerId = eng.createPlayer(spec.playerName);
+          nextPlayers[spec.playerName] = playerId;
+          if (!instancesRef.current[spec.playerName]) {
+            instancesRef.current[spec.playerName] = [];
+          }
+        }
+        const idx = spec.animIndexOrId;
+        const animId = idx >= 0 && idx < animIdsRef.current.length ? animIdsRef.current[idx] : idx;
+        const cfgFinal = {
+          ...DEFAULT_INSTANCE_CFG,
+          ...spec.cfg
+        };
+        const instId = eng.addInstance(
+          playerId,
+          animId,
+          cfgFinal
+        );
+        instancesRef.current[spec.playerName].push(instId);
+        results.push({ playerName: spec.playerName, instId });
+      }
+      setPlayers(nextPlayers);
+      applyOutputs(eng.updateValuesAndDerivatives(0));
+      refreshPlayersAndInstances(eng);
+      return results;
+    },
+    [applyOutputs, players, refreshPlayersAndInstances]
+  );
+  const getInstances = (0, import_react2.useCallback)((playerName) => {
+    return instancesRef.current[playerName]?.slice() ?? [];
+  }, []);
+  const updateInstances = (0, import_react2.useCallback)(
+    (updates) => {
+      const eng = engineRef.current;
+      if (!eng || !updates || updates.length === 0) return;
+      applyOutputs(
+        eng.updateValuesAndDerivatives(0, { instance_updates: updates })
+      );
+    },
+    [applyOutputs]
+  );
+  const bakeAnimation = (0, import_react2.useCallback)(
+    (animIndexOrId, cfg) => {
+      const eng = engineRef.current;
+      if (!eng) return null;
+      const animId = resolveAnimId(animIndexOrId);
+      if (typeof animId === "undefined") return null;
+      try {
+        return eng.bakeAnimation(animId, cfg);
+      } catch (err) {
+        console.error("Animation bakeAnimation failed", err);
+        return null;
+      }
+    },
+    [resolveAnimId]
+  );
+  const bakeAnimationWithDerivatives = (0, import_react2.useCallback)(
+    (animIndexOrId, cfg) => {
+      const eng = engineRef.current;
+      if (!eng) return null;
+      const animId = resolveAnimId(animIndexOrId);
+      if (typeof animId === "undefined") return null;
+      try {
+        return eng.bakeAnimationWithDerivatives(animId, cfg);
+      } catch (err) {
+        console.error("Animation bakeAnimationWithDerivatives failed", err);
+        return null;
+      }
+    },
+    [resolveAnimId]
+  );
+  const subscribeToKey = (0, import_react2.useCallback)((key, cb) => {
+    return storeRef.current.subscribeToKey(key, cb);
+  }, []);
+  const getKeySnapshot = (0, import_react2.useCallback)((key) => {
+    return storeRef.current.getKeySnapshot(key);
+  }, []);
+  const subscribeToDerivativeKey = (0, import_react2.useCallback)(
+    (key, cb) => {
+      return storeRef.current.subscribeToDerivativeKey(key, cb);
+    },
+    []
+  );
+  const getKeyDerivativeSnapshot = (0, import_react2.useCallback)((key) => {
+    return storeRef.current.getKeyDerivativeSnapshot(key);
+  }, []);
+  const subscribeToPlayerKey = (0, import_react2.useCallback)(
+    (player, key, cb) => {
+      const playerId = resolvePlayerId(player);
+      if (typeof playerId === "undefined") return () => {
+      };
+      return storeRef.current.subscribeToPlayerKey(playerId, key, cb);
+    },
+    [resolvePlayerId]
+  );
+  const getPlayerKeySnapshot = (0, import_react2.useCallback)(
+    (player, key) => {
+      const playerId = resolvePlayerId(player);
+      if (typeof playerId === "undefined") return void 0;
+      return storeRef.current.getPlayerKeySnapshot(playerId, key);
+    },
+    [resolvePlayerId]
+  );
+  const subscribeToPlayerDerivative = (0, import_react2.useCallback)(
+    (player, key, cb) => {
+      const playerId = resolvePlayerId(player);
+      if (typeof playerId === "undefined") return () => {
+      };
+      return storeRef.current.subscribeToPlayerDerivative(playerId, key, cb);
+    },
+    [resolvePlayerId]
+  );
+  const getPlayerDerivativeSnapshot = (0, import_react2.useCallback)(
+    (player, key) => {
+      const playerId = resolvePlayerId(player);
+      if (typeof playerId === "undefined") return void 0;
+      return storeRef.current.getPlayerDerivativeSnapshot(playerId, key);
+    },
+    [resolvePlayerId]
+  );
+  const getLatestValuesByPlayer = (0, import_react2.useCallback)(() => {
+    const snapshot = storeRef.current.getValuesByPlayer();
+    const result = {};
+    const nameById = Object.fromEntries(
+      Object.entries(players).map(([name, id]) => [String(id), name])
+    );
+    for (const [idStr, valuesForPlayer] of Object.entries(snapshot)) {
+      const canonicalName = nameById[idStr] ?? idStr;
+      result[canonicalName] = { ...valuesForPlayer };
+    }
+    return result;
+  }, [players]);
+  const getLatestDerivativesByPlayer = (0, import_react2.useCallback)(() => {
+    const snapshot = storeRef.current.getDerivativesByPlayer();
+    const result = {};
+    const nameById = Object.fromEntries(
+      Object.entries(players).map(([name, id]) => [String(id), name])
+    );
+    for (const [idStr, valuesForPlayer] of Object.entries(snapshot)) {
+      const canonicalName = nameById[idStr] ?? idStr;
+      result[canonicalName] = { ...valuesForPlayer };
+    }
+    return result;
+  }, [players]);
+  const listAnimations = (0, import_react2.useCallback)(() => {
+    const eng = engineRef.current;
+    if (!eng) return [];
+    try {
+      return eng.listAnimations();
+    } catch {
+      return [];
+    }
+  }, []);
+  const listPlayers = (0, import_react2.useCallback)(() => {
+    const eng = engineRef.current;
+    if (!eng) return [];
+    try {
+      return eng.listPlayers();
+    } catch {
+      return [];
+    }
+  }, []);
+  const listInstances = (0, import_react2.useCallback)(
+    (player) => {
+      const eng = engineRef.current;
+      if (!eng) return [];
+      const playerId = resolvePlayerId(player);
+      if (typeof playerId === "undefined") return [];
+      try {
+        return eng.listInstances(playerId);
+      } catch {
+        return [];
+      }
+    },
+    [resolvePlayerId]
+  );
+  const listPlayerKeys = (0, import_react2.useCallback)(
+    (player) => {
+      const eng = engineRef.current;
+      if (!eng) return [];
+      const playerId = resolvePlayerId(player);
+      if (typeof playerId === "undefined") return [];
+      try {
+        return eng.listPlayerKeys(playerId);
+      } catch {
+        return [];
+      }
+    },
+    [resolvePlayerId]
+  );
+  const removePlayer = (0, import_react2.useCallback)(
+    (player) => {
+      const eng = engineRef.current;
+      if (!eng) return false;
+      const playerId = resolvePlayerId(player);
+      if (typeof playerId === "undefined") return false;
+      const ok = eng.removePlayer(playerId);
+      applyOutputs(eng.updateValuesAndDerivatives(0));
+      refreshPlayersAndInstances(eng);
+      return ok;
+    },
+    [applyOutputs, refreshPlayersAndInstances, resolvePlayerId]
+  );
+  const removeInstances = (0, import_react2.useCallback)(
+    (specs) => {
+      const eng = engineRef.current;
+      if (!eng || specs.length === 0) return [];
+      const removed = [];
+      for (const spec of specs) {
+        const playerId = resolvePlayerId(spec.playerName);
+        if (typeof playerId === "undefined") continue;
+        try {
+          const ok = eng.removeInstance(playerId, spec.instId);
+          if (ok) removed.push(spec);
+        } catch (err) {
+          console.warn("Failed to remove instance", err);
+        }
+      }
+      applyOutputs(eng.updateValuesAndDerivatives(0));
+      refreshPlayersAndInstances(eng);
+      return removed;
+    },
+    [applyOutputs, refreshPlayersAndInstances, resolvePlayerId]
+  );
+  const unloadAnimations = (0, import_react2.useCallback)(
+    (animIds) => {
+      const eng = engineRef.current;
+      if (!eng || animIds.length === 0) return [];
+      const removed = [];
+      for (const animId of animIds) {
+        const ok = eng.unloadAnimation(animId);
+        if (ok) removed.push(animId);
+      }
+      if (removed.length > 0) {
+        animIdsRef.current = animIdsRef.current.filter(
+          (id) => !removed.includes(id)
+        );
+      }
+      applyOutputs(eng.updateValuesAndDerivatives(0));
+      refreshPlayersAndInstances(eng);
+      return removed;
+    },
+    [applyOutputs, refreshPlayersAndInstances]
+  );
+  const contextValue = (0, import_react2.useMemo)(
+    () => ({
+      ready,
+      subscribeToKey,
+      getKeySnapshot,
+      subscribeToDerivativeKey,
+      getKeyDerivativeSnapshot,
+      subscribeToPlayerKey,
+      getPlayerKeySnapshot,
+      subscribeToPlayerDerivative,
+      getPlayerDerivativeSnapshot,
+      getLatestValuesByPlayer,
+      getLatestDerivativesByPlayer,
+      step,
+      reload,
+      addAnimations,
+      addPlayer,
+      addInstances,
+      getInstances,
+      updateInstances,
+      listAnimations,
+      listPlayers,
+      listInstances,
+      listPlayerKeys,
+      removePlayer,
+      removeInstances,
+      unloadAnimations,
+      bakeAnimation,
+      bakeAnimationWithDerivatives,
+      players
+    }),
+    [
+      ready,
+      subscribeToKey,
+      getKeySnapshot,
+      subscribeToDerivativeKey,
+      getKeyDerivativeSnapshot,
+      subscribeToPlayerKey,
+      getPlayerKeySnapshot,
+      subscribeToPlayerDerivative,
+      getPlayerDerivativeSnapshot,
+      getLatestValuesByPlayer,
+      getLatestDerivativesByPlayer,
+      step,
+      reload,
+      addAnimations,
+      addPlayer,
+      addInstances,
+      getInstances,
+      updateInstances,
+      listAnimations,
+      listPlayers,
+      listInstances,
+      listPlayerKeys,
+      removePlayer,
+      removeInstances,
+      unloadAnimations,
+      bakeAnimation,
+      bakeAnimationWithDerivatives,
+      players
+    ]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AnimationContext.Provider, { value: contextValue, children });
+}
+
+// src/hooks/useAnimation.ts
+var import_react3 = require("react");
+function useAnimation() {
+  const ctx = (0, import_react3.useContext)(AnimationContext);
+  if (!ctx) {
+    throw new Error("useAnimation must be used within AnimationProvider");
+  }
+  return ctx;
+}
+
+// src/hooks/useAnimTarget.ts
+var import_react4 = require("react");
+function useAnimTarget(key) {
+  const { subscribeToKey, getKeySnapshot } = useAnimation();
+  const subscribe = (0, import_react4.useCallback)(
+    (cb) => {
+      if (!key) return () => {
+      };
+      return subscribeToKey(key, cb);
+    },
+    [subscribeToKey, key]
+  );
+  const getSnapshot = (0, import_react4.useCallback)(
+    () => key ? getKeySnapshot(key) : void 0,
+    [getKeySnapshot, key]
+  );
+  return (0, import_react4.useSyncExternalStore)(subscribe, getSnapshot, () => void 0);
+}
+
+// src/hooks/useAnimDerivative.ts
+var import_react5 = require("react");
+function useAnimDerivative(key) {
+  const { subscribeToDerivativeKey, getKeyDerivativeSnapshot } = useAnimation();
+  const subscribe = (0, import_react5.useCallback)(
+    (cb) => {
+      if (!key) return () => {
+      };
+      return subscribeToDerivativeKey(key, cb);
+    },
+    [subscribeToDerivativeKey, key]
+  );
+  const getSnapshot = (0, import_react5.useCallback)(
+    () => key ? getKeyDerivativeSnapshot(key) : void 0,
+    [getKeyDerivativeSnapshot, key]
+  );
+  return (0, import_react5.useSyncExternalStore)(subscribe, getSnapshot, () => void 0);
+}
+
+// src/valueHelpers.ts
+var import_value_json = require("@vizij/value-json");
+function valueAsNumber(v) {
+  return (0, import_value_json.valueAsNumber)(v);
+}
+function valueAsNumericArray(v, fallback = 0) {
+  return (0, import_value_json.valueAsNumericArray)(v, fallback);
+}
+function valueAsTransform(v) {
+  return (0, import_value_json.valueAsTransform)(v);
+}
+
+// src/samples.ts
+var import_animation_wasm2 = require("@vizij/animation-wasm");
+var samples = {
+  list: import_animation_wasm2.listAnimationFixtures,
+  load: import_animation_wasm2.loadAnimationFixture,
+  loadJson: import_animation_wasm2.loadAnimationJson,
+  resolvePath: import_animation_wasm2.resolveAnimationPath
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnimationProvider,
+  listAnimationFixtures,
+  loadAnimationFixture,
+  loadAnimationJson,
+  resolveAnimationPath,
+  samples,
+  useAnimDerivative,
+  useAnimTarget,
+  useAnimation,
+  valueAsNumber,
+  valueAsNumericArray,
+  valueAsTransform
+});