@doki-land/live2d 0.0.22 → 0.0.24

package/dist/index.js

@@ -20,6 +20,67 @@ import {
   serializeCpuProgram
 } from "@doki-land/live2d-renderer";
 
+// src/expression/apply-expression.ts
+function blendValue(current, target, mode, weight) {
+  if (weight <= 0) return current;
+  if (weight >= 1) {
+    if (mode === "Add") return current + target;
+    if (mode === "Multiply") return current * target;
+    return target;
+  }
+  const full = mode === "Add" ? current + target : mode === "Multiply" ? current * target : target;
+  return current + (full - current) * weight;
+}
+function applyExpression3Clip(clip, weight, bindings, setParameter) {
+  if (weight <= 0) return;
+  for (const p of clip.parameters) {
+    const binding = bindings.get(p.id);
+    if (!binding) continue;
+    setParameter(p.id, blendValue(binding.value, p.value, p.blend, weight));
+  }
+}
+
+// src/expression/parse-expression3.ts
+var BLENDS = /* @__PURE__ */ new Set(["Add", "Multiply", "Override"]);
+function parseBlend(raw) {
+  if (typeof raw !== "string") return "Add";
+  if (raw === "Overwrite" || raw === "Override") return "Override";
+  if (BLENDS.has(raw)) {
+    return raw;
+  }
+  return "Add";
+}
+function parseExpression3(json) {
+  if (!json || typeof json !== "object") {
+    throw new Error("@doki-land/live2d: exp3.json root must be an object");
+  }
+  const root = json;
+  const version = Number(root.Version ?? 3);
+  const paramsRaw = root.Parameters;
+  if (!Array.isArray(paramsRaw)) {
+    throw new Error("@doki-land/live2d: exp3.json missing Parameters");
+  }
+  const parameters = paramsRaw.map((item, index) => {
+    if (!item || typeof item !== "object") {
+      throw new Error(`@doki-land/live2d: Parameters[${index}] invalid`);
+    }
+    const p = item;
+    const id = p.Id;
+    const value = p.Value;
+    if (typeof id !== "string" || typeof value !== "number") {
+      throw new Error(
+        `@doki-land/live2d: Parameters[${index}] needs Id/Value`
+      );
+    }
+    return {
+      id,
+      value,
+      blend: parseBlend(p.Blend)
+    };
+  });
+  return { version, parameters };
+}
+
 // src/facade/create-live2d.ts
 import {
   createMoc2Backend as createMoc2Backend2,
@@ -512,6 +573,116 @@ function optionalNum(v) {
   return typeof v === "number" && Number.isFinite(v) ? v : void 0;
 }
 
+// src/physics/apply-physics3.ts
+function applyPhysics3(clip, _deltaTimeSeconds, bindings, setParameter) {
+  for (const id of clip.outputParameterIds) {
+    const binding = bindings.get(id);
+    if (!binding) continue;
+    setParameter(id, binding.value);
+  }
+}
+
+// src/physics/parse-physics3.ts
+function parsePhysics3(json) {
+  if (!json || typeof json !== "object") {
+    throw new Error(
+      "@doki-land/live2d: physics3 json root must be an object"
+    );
+  }
+  const root = json;
+  const settingsRaw = root.PhysicsSettings;
+  if (settingsRaw === void 0 || settingsRaw === null) {
+    return { settings: [], outputParameterIds: [] };
+  }
+  if (!Array.isArray(settingsRaw)) {
+    throw new Error("@doki-land/live2d: PhysicsSettings must be an array");
+  }
+  const settings = [];
+  const outputParameterIds = [];
+  for (let si = 0; si < settingsRaw.length; si++) {
+    const entry = settingsRaw[si];
+    if (!entry || typeof entry !== "object") {
+      throw new Error(
+        `@doki-land/live2d: PhysicsSettings[${si}] must be an object`
+      );
+    }
+    const rec = entry;
+    const id = typeof rec.Id === "string" ? rec.Id : `PhysicsSetting${si}`;
+    const outputsRaw = rec.Output;
+    const outputs = [];
+    if (Array.isArray(outputsRaw)) {
+      for (let oi = 0; oi < outputsRaw.length; oi++) {
+        const out = outputsRaw[oi];
+        if (!out || typeof out !== "object") continue;
+        const dest = out.Destination;
+        if (!dest || typeof dest !== "object") continue;
+        const destId = dest.Id;
+        if (typeof destId !== "string" || !destId) continue;
+        outputs.push({ destinationId: destId });
+        outputParameterIds.push(destId);
+      }
+    }
+    settings.push({ id, outputs });
+  }
+  return { settings, outputParameterIds };
+}
+
+// src/pose/apply-pose3.ts
+function applyPose3Activation(clip, activatedPartId, setPartOpacity) {
+  for (const group of clip.groups) {
+    if (!group.includes(activatedPartId)) continue;
+    for (const partId of group) {
+      setPartOpacity(partId, partId === activatedPartId ? 1 : 0);
+    }
+    return;
+  }
+}
+
+// src/pose/parse-pose3.ts
+function parsePose3(json) {
+  if (!json || typeof json !== "object") {
+    throw new Error("@doki-land/live2d: pose json root must be an object");
+  }
+  const root = json;
+  const groupsRaw = root.Groups;
+  if (!Array.isArray(groupsRaw)) {
+    throw new Error("@doki-land/live2d: pose json missing Groups");
+  }
+  const groups = groupsRaw.map((group, gi) => {
+    if (!Array.isArray(group)) {
+      throw new Error(`@doki-land/live2d: Groups[${gi}] must be array`);
+    }
+    return group.map((entry, ei) => {
+      if (!entry || typeof entry !== "object") {
+        throw new Error(
+          `@doki-land/live2d: Groups[${gi}][${ei}] invalid`
+        );
+      }
+      const id = entry.Id;
+      if (typeof id !== "string" || !id) {
+        throw new Error(
+          `@doki-land/live2d: Groups[${gi}][${ei}] missing Id`
+        );
+      }
+      return id;
+    });
+  });
+  return { groups };
+}
+
+// src/stage/hit-area.ts
+function resolveHitAreaName(input) {
+  const { hitAreas, drawableIndex, artMeshId } = input;
+  const candidates = /* @__PURE__ */ new Set();
+  if (artMeshId) candidates.add(artMeshId);
+  candidates.add(`D_${drawableIndex}`);
+  candidates.add(`${drawableIndex}`);
+  for (const area of hitAreas) {
+    if (candidates.has(area.id)) return area.name;
+  }
+  return `drawable:${drawableIndex}`;
+}
+
 // src/stage/actor-model-slot.ts
 var ActorModelSlot = class {
   #assets;
@@ -525,6 +696,10 @@ var ActorModelSlot = class {
   #loadGeneration = 0;
   #paramById = /* @__PURE__ */ new Map();
   #paramIndexById = /* @__PURE__ */ new Map();
+  #expressionCache = /* @__PURE__ */ new Map();
+  #activeExpression = null;
+  #poseClip = null;
+  #physicsClip = null;
   constructor(options) {
     this.#assets = options.assets;
     this.#renderer = options.renderer;
@@ -559,16 +734,8 @@ var ActorModelSlot = class {
       if (s.weight <= 0) continue;
       if (s.target === "PartOpacity") {
         if (!this.#backend.setPartOpacity) continue;
-        if (s.weight >= 1) {
-          this.#backend.setPartOpacity(this.#model, s.id, s.value);
-        } else {
-          const cur2 = 1;
-          this.#backend.setPartOpacity(
-            this.#model,
-            s.id,
-            cur2 + (s.value - cur2) * s.weight
-          );
-        }
+        const value = s.weight >= 1 ? s.value : 1 + (s.value - 1) * s.weight;
+        this.#setPartOpacityWithPose(s.id, value);
         continue;
       }
       if (s.target !== "Parameter" || !this.#backend.setParameter)
@@ -584,6 +751,75 @@ var ActorModelSlot = class {
         cur + (s.value - cur) * s.weight
       );
     }
+    this.#syncParamCacheFromBackend();
+  }
+  #setPartOpacityWithPose(partId, opacity) {
+    if (!this.#model || !this.#backend?.setPartOpacity) return;
+    if (this.#poseClip && opacity > 0) {
+      applyPose3Activation(this.#poseClip, partId, (id, value) => {
+        this.#backend?.setPartOpacity?.(this.#model, id, value);
+      });
+      return;
+    }
+    this.#backend.setPartOpacity(this.#model, partId, opacity);
+  }
+  #syncParamCacheFromBackend() {
+    if (!this.#model || !this.#backend?.listParameters) return;
+    for (const p of this.#backend.listParameters(this.#model)) {
+      const cached = this.#paramById.get(p.id);
+      if (cached) cached.value = p.value;
+    }
+  }
+  #tickExpression(deltaTimeSeconds) {
+    if (!this.#activeExpression) return;
+    const fadeSeconds = 0.25;
+    const step = deltaTimeSeconds / Math.max(1e-3, fadeSeconds);
+    this.#activeExpression.weight = Math.min(
+      1,
+      this.#activeExpression.weight + step
+    );
+  }
+  #applyExpressionLayer() {
+    if (!this.#activeExpression || !this.#model || !this.#backend) return;
+    applyExpression3Clip(
+      this.#activeExpression.clip,
+      this.#activeExpression.weight,
+      this.#paramById,
+      (id, value) => this.#backend?.setParameter?.(this.#model, id, value)
+    );
+    this.#syncParamCacheFromBackend();
+  }
+  async #loadPoseClip() {
+    this.#poseClip = null;
+    const posePath = this.#model?.settings.pose;
+    if (!posePath || !this.#lease) return;
+    try {
+      const json = await this.#lease.resolver.fetchJson(posePath);
+      this.#poseClip = parsePose3(json);
+    } catch {
+      this.#poseClip = null;
+    }
+  }
+  async #loadPhysicsClip() {
+    this.#physicsClip = null;
+    const physicsPath = this.#model?.settings.physics;
+    if (!physicsPath || !this.#lease) return;
+    try {
+      const json = await this.#lease.resolver.fetchJson(physicsPath);
+      this.#physicsClip = parsePhysics3(json);
+    } catch {
+      this.#physicsClip = null;
+    }
+  }
+  #applyPhysicsLayer(deltaTimeSeconds) {
+    if (!this.#physicsClip || !this.#model || !this.#backend) return;
+    applyPhysics3(
+      this.#physicsClip,
+      deltaTimeSeconds,
+      this.#paramById,
+      (id, value) => this.#backend?.setParameter?.(this.#model, id, value)
+    );
+    this.#syncParamCacheFromBackend();
   }
   #rebuildParamCache() {
     this.#paramById.clear();
@@ -614,24 +850,37 @@ var ActorModelSlot = class {
     }
     return this.#paramIndexById.get(id);
   }
-  async load(source, resolver) {
+  async load(source, resolver, options) {
     const gen = ++this.#loadGeneration;
+    const signal = options?.signal;
+    if (signal?.aborted) {
+      throw new Error("@doki-land/live2d: load cancelled");
+    }
+    const onAbort = () => {
+      this.#loadGeneration += 1;
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
     this.#report({
       stage: "mounting",
       progress: 0.01,
       detail: "prepare draw pass"
     });
     const drawPass = this.ensureDrawPass();
-    const lease = await this.#assets.acquire(
-      source,
-      resolver,
-      (p) => this.#report(p)
-    );
-    if (gen !== this.#loadGeneration) {
-      lease.release();
-      throw new Error("@doki-land/live2d: load cancelled");
+    try {
+      const lease = await this.#assets.acquire(
+        source,
+        resolver,
+        (p) => this.#report(p),
+        { signal }
+      );
+      if (gen !== this.#loadGeneration) {
+        lease.release();
+        throw new Error("@doki-land/live2d: load cancelled");
+      }
+      return await this.#attachLease(lease, drawPass, gen);
+    } finally {
+      signal?.removeEventListener("abort", onAbort);
     }
-    return await this.#attachLease(lease, drawPass, gen);
   }
   async loadAsset(asset) {
     const gen = ++this.#loadGeneration;
@@ -655,6 +904,9 @@ var ActorModelSlot = class {
   }
   async #attachLease(lease, drawPass, gen) {
     this.#motionPlayer.clear();
+    this.#activeExpression = null;
+    this.#poseClip = null;
+    this.#physicsClip = null;
     this.#releaseLease();
     const { model, backend } = await lease.createInstance(this.#renderer);
     if (gen !== this.#loadGeneration) {
@@ -670,6 +922,8 @@ var ActorModelSlot = class {
     this.#model = model;
     this.#backend = backend;
     this.#rebuildParamCache();
+    await this.#loadPoseClip();
+    await this.#loadPhysicsClip();
     this.#report({
       stage: "ready",
       progress: 1,
@@ -688,6 +942,28 @@ var ActorModelSlot = class {
   listMotionGroups() {
     return this.#model?.settings.motionGroups ?? {};
   }
+  listExpressions() {
+    return this.#model?.settings.expressions ?? [];
+  }
+  async setExpression(name) {
+    if (!this.#model || !this.#lease) return false;
+    if (name === null) {
+      this.#activeExpression = null;
+      return true;
+    }
+    const def = this.#model.settings.expressions.find(
+      (item) => item.name === name
+    );
+    if (!def) return false;
+    let clip = this.#expressionCache.get(def.file);
+    if (!clip) {
+      const json = await this.#lease.resolver.fetchJson(def.file);
+      clip = parseExpression3(json);
+      this.#expressionCache.set(def.file, clip);
+    }
+    this.#activeExpression = { name, clip, weight: 0 };
+    return true;
+  }
   async playMotion(group, index = 0, options = {}) {
     if (!this.#model || !this.#lease) return false;
     const list = this.#model.settings.motionGroups[group];
@@ -720,6 +996,9 @@ var ActorModelSlot = class {
   update(deltaTimeSeconds) {
     if (!this.#model || !this.#backend || !this.#drawPass) return null;
     this.#applyMotionSamples(this.#motionPlayer.update(deltaTimeSeconds));
+    this.#tickExpression(deltaTimeSeconds);
+    this.#applyExpressionLayer();
+    this.#applyPhysicsLayer(deltaTimeSeconds);
     this.#backend.updateModel(this.#model, deltaTimeSeconds);
     return this.#backend.getDrawables(this.#model);
   }
@@ -740,10 +1019,15 @@ var ActorModelSlot = class {
         const s1 = (bx - ax) * (modelY - ay) - (by - ay) * (modelX - ax);
         const s2 = (cx - bx) * (modelY - by) - (cy - by) * (modelX - bx);
         if (s >= 0 && s1 >= 0 && s2 >= 0 || s <= 0 && s1 <= 0 && s2 <= 0) {
-          const hitArea = this.#model.settings.hitAreas.find(
-            (h) => h.id === `D_${d.index}` || h.id === `${d.index}`
+          const artMeshId = this.#backend.getDrawableArtMeshId?.(
+            this.#model,
+            d.index
           );
-          return hitArea?.name ?? `drawable:${d.index}`;
+          return resolveHitAreaName({
+            hitAreas: this.#model.settings.hitAreas,
+            drawableIndex: d.index,
+            artMeshId
+          });
         }
       }
     }
@@ -752,6 +1036,9 @@ var ActorModelSlot = class {
   destroy() {
     this.#loadGeneration += 1;
     this.#motionPlayer.clear();
+    this.#activeExpression = null;
+    this.#poseClip = null;
+    this.#physicsClip = null;
     if (this.#model && this.#backend) {
       this.#backend.destroyModel(this.#model);
     }
@@ -977,9 +1264,18 @@ var Live2dActorImpl = class {
     this.#order = options?.order ?? 0;
     this.#slot = new ActorModelSlot({
       assets: shared.assets,
-      renderer: shared.renderer
+      renderer: shared.renderer,
+      onMotionStart: (payload) => this.#onMotionStart?.(payload),
+      onMotionFinish: (payload) => this.#onMotionFinish?.(payload)
     });
   }
+  #onMotionStart = null;
+  #onMotionFinish = null;
+  /** Bridge MotionPlayer lifecycle into Stage/facade event buses. */
+  setMotionEventHandlers(handlers) {
+    this.#onMotionStart = handlers.onStart ?? null;
+    this.#onMotionFinish = handlers.onFinish ?? null;
+  }
   get model() {
     return this.#slot.model;
   }
@@ -1016,11 +1312,11 @@ var Live2dActorImpl = class {
       ...patch
     });
   }
-  async load(source, resolver) {
+  async load(source, resolver, options) {
     if (this.#destroyed) {
       throw new Error("@doki-land/live2d: actor destroyed");
     }
-    return await this.#slot.load(source, resolver);
+    return await this.#slot.load(source, resolver, options);
   }
   async loadAsset(asset) {
     if (this.#destroyed) {
@@ -1056,6 +1352,12 @@ var Live2dActorImpl = class {
   listPlayingMotions() {
     return this.#slot.listPlayingMotions();
   }
+  listExpressions() {
+    return this.#slot.listExpressions();
+  }
+  setExpression(name) {
+    return this.#slot.setExpression(name);
+  }
   lookAt(stageX, stageY) {
     const { dragX, dragY } = stageFocusDrag(
       stageX,
@@ -1163,10 +1465,10 @@ function createSingleActorFacade(stage, actor, backends) {
         }
       );
     },
-    async loadModel(source, resolver) {
+    async loadModel(source, resolver, options) {
       setPhase("loading");
       try {
-        const model = await actor.load(source, resolver);
+        const model = await actor.load(source, resolver, options);
         lastError = null;
         setPhase("live");
         events.emit("ready", { modelId: model.id });
@@ -1212,6 +1514,12 @@ function createSingleActorFacade(stage, actor, backends) {
     listPlayingMotions() {
       return actor.listPlayingMotions();
     },
+    listExpressions() {
+      return actor.listExpressions();
+    },
+    setExpression(name) {
+      return actor.setExpression(name);
+    },
     async capturePng(opts = {}) {
       if (!canvas) {
         throw new Error(
@@ -1273,6 +1581,10 @@ function createSingleActorFacade(stage, actor, backends) {
       events.clear();
     }
   };
+  actor.setMotionEventHandlers({
+    onStart: (payload) => events.emit("motion:start", payload),
+    onFinish: (payload) => events.emit("motion:finish", payload)
+  });
   return runtime;
 }
 
@@ -1402,8 +1714,13 @@ var ModelAssetRegistry = class {
     const entry = await this.#ensureEntry(source, resolver);
     return new ModelAssetHandle(entry);
   }
-  async acquire(source, resolver, onProgress) {
-    const entry = await this.#ensureEntry(source, resolver, onProgress);
+  async acquire(source, resolver, onProgress, options) {
+    const entry = await this.#ensureEntry(
+      source,
+      resolver,
+      onProgress,
+      options
+    );
     entry.refCount += 1;
     return this.#leaseFromEntry(entry);
   }
@@ -1454,13 +1771,19 @@ var ModelAssetRegistry = class {
       }
     };
   }
-  async #ensureEntry(source, resolver, onProgress) {
+  async #ensureEntry(source, resolver, onProgress, options) {
     const key = resolveModelAssetKey(source);
     const existing = this.#entries.get(key);
     if (existing) return existing;
     let pending = this.#inFlight.get(key);
     if (!pending) {
-      pending = this.#compileEntry(key, source, resolver, onProgress);
+      pending = this.#compileEntry(
+        key,
+        source,
+        resolver,
+        onProgress,
+        options
+      );
       this.#inFlight.set(key, pending);
     }
     try {
@@ -1471,8 +1794,12 @@ var ModelAssetRegistry = class {
       this.#inFlight.delete(key);
     }
   }
-  async #compileEntry(key, source, resolver, onProgress) {
+  async #compileEntry(key, source, resolver, onProgress, options) {
     const notify = (payload) => onProgress?.(payload);
+    const signal = options?.signal;
+    if (signal?.aborted) {
+      throw new Error("@doki-land/live2d: load cancelled");
+    }
     notify({
       stage: "resolve",
       progress: 0.02,
@@ -1501,19 +1828,26 @@ var ModelAssetRegistry = class {
         progress: 0.05,
         detail: fetchUrl
       });
-      json = await fetchModelJson(fetchUrl, (u) => {
-        const ratio = u.bytesTotal && u.bytesTotal > 0 ? u.bytesLoaded / u.bytesTotal : 0;
-        notify({
-          stage: "settings",
-          progress: lerp(0.05, 0.22, ratio),
-          detail: fetchUrl,
-          bytesLoaded: u.bytesLoaded,
-          bytesTotal: u.bytesTotal
-        });
-      });
+      json = await fetchModelJson(
+        fetchUrl,
+        (u) => {
+          const ratio = u.bytesTotal && u.bytesTotal > 0 ? u.bytesLoaded / u.bytesTotal : 0;
+          notify({
+            stage: "settings",
+            progress: lerp(0.05, 0.22, ratio),
+            detail: fetchUrl,
+            bytesLoaded: u.bytesLoaded,
+            bytesTotal: u.bytesTotal
+          });
+        },
+        { signal }
+      );
       baseUrl = fetchUrl;
       settingsUrl = fetchUrl;
     }
+    if (signal?.aborted) {
+      throw new Error("@doki-land/live2d: load cancelled");
+    }
     const settings = normalizeModelSettings(json, settingsUrl);
     notify({
       stage: "moc",
@@ -1521,6 +1855,7 @@ var ModelAssetRegistry = class {
       detail: settings.moc
     });
     const assetResolver = resolver ?? createUrlAssetResolver(baseUrl, {
+      signal,
       onBytesProgress: (assetKey, u) => {
         const isMoc = assetKey === settings.moc;
         const ratio = u.bytesTotal && u.bytesTotal > 0 ? u.bytesLoaded / u.bytesTotal : 0;
@@ -1550,6 +1885,9 @@ var ModelAssetRegistry = class {
       detail: `decode ${settings.format}`
     });
     const mocBytes = await assetResolver.fetchBytes(settings.moc);
+    if (signal?.aborted) {
+      throw new Error("@doki-land/live2d: load cancelled");
+    }
     const sharedCompile = compileSharedModelCompile(settings, mocBytes);
     const textures = [];
     if (settings.textures.length > 0) {
@@ -1573,6 +1911,9 @@ var ModelAssetRegistry = class {
         })
       );
     }
+    if (signal?.aborted) {
+      throw new Error("@doki-land/live2d: load cancelled");
+    }
     notify({
       stage: "ready",
       progress: 1,
@@ -1620,6 +1961,7 @@ var Live2dStageImpl = class {
   ]);
   #drawScratch = new StageDrawableScratch();
   #sortedActors = [];
+  #frameListeners = /* @__PURE__ */ new Set();
   #canvas = null;
   #initPromise = null;
   #rafId = null;
@@ -1717,11 +2059,20 @@ var Live2dStageImpl = class {
   }
   update(deltaTimeSeconds) {
     if (this.#destroyed) return;
+    for (const listener of this.#frameListeners) {
+      listener(deltaTimeSeconds);
+    }
     for (const actor of this.#actors.values()) {
       actor.update(deltaTimeSeconds);
     }
     this.#applyPointerTracking();
   }
+  onFrame(listener) {
+    this.#frameListeners.add(listener);
+    return () => {
+      this.#frameListeners.delete(listener);
+    };
+  }
   render() {
     if (this.#destroyed || !this.#canvas) return;
     const sorted = this.#sortedActors;
@@ -1809,6 +2160,7 @@ var Live2dStageImpl = class {
     if (this.#destroyed) return;
     this.#destroyed = true;
     this.stop();
+    this.#frameListeners.clear();
     this.#detachPointerListeners();
     for (const actor of this.#actors.values()) {
       actor.destroy();
@@ -1931,7 +2283,7 @@ function createLive2dStage(options) {
 }
 
 // src/facade/create-live2d.ts
-function createLive2D(options = {}) {
+function createLive2d(options = {}) {
   const backends = options.backends ?? [
     createMoc2Backend2(),
     createMoc3Backend2()
@@ -1946,6 +2298,7 @@ function createLive2D(options = {}) {
   });
   return createSingleActorFacade(stage, actor, backends);
 }
+var createLive2D = createLive2d;
 
 // src/index.ts
 var LIVE2D_VERSION = "0.0.0";
@@ -1956,9 +2309,14 @@ export {
   LIVE2D_VERSION,
   MotionPlayer,
   MotionPriority,
+  allocateActorId,
+  applyExpression3Clip,
+  applyPhysics3,
+  applyPose3Activation,
   blendMotionLayers,
   createCanvas2DRenderer,
   createLive2D,
+  createLive2d,
   createLive2dStage,
   createMoc2Backend3 as createMoc2Backend,
   createMoc3Backend3 as createMoc3Backend,
@@ -1973,7 +2331,11 @@ export {
   fingerprintSnapshot,
   focusParameterUpdates,
   parseCpuProgram,
+  parseExpression3,
   parseMotion3,
+  parsePhysics3,
+  parsePose3,
+  resolveHitAreaName,
   resolveModelSourceUrl2 as resolveModelSourceUrl,
   resolveNpmSpecifier,
   serializeCpuProgram