@doki-land/live2d 0.0.9 → 0.0.11

package/dist/index.js

@@ -0,0 +1,1068 @@
+// src/index.ts
+import { EventEmitter as EventEmitter2 } from "@doki-land/live2d-core";
+import {
+  DEFAULT_NPM_CDN,
+  resolveModelSourceUrl as resolveModelSourceUrl2,
+  resolveNpmSpecifier
+} from "@doki-land/live2d-loader";
+import {
+  createCanvas2DRenderer,
+  createMoc2Backend as createMoc2Backend2,
+  createMoc3Backend as createMoc3Backend2,
+  createQuadProgram,
+  createRenderer as createRenderer2,
+  createWebGl2Renderer,
+  createWebGpuRenderer,
+  decodeMoc3,
+  evaluateFrame,
+  fingerprintSnapshot,
+  parseCpuProgram,
+  serializeCpuProgram
+} from "@doki-land/live2d-renderer";
+
+// src/create-live2d.ts
+import { EventEmitter, modelSourceUrl } from "@doki-land/live2d-core";
+import {
+  createUrlAssetResolver,
+  fetchModelJson,
+  normalizeModelSettings,
+  resolveModelSourceUrl
+} from "@doki-land/live2d-loader";
+import {
+  createMoc2Backend,
+  createMoc3Backend,
+  createRenderer,
+  selectModelBackend
+} from "@doki-land/live2d-renderer";
+
+// src/load-textures.ts
+function guessMime(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+  if (lower.endsWith(".webp")) return "image/webp";
+  if (lower.endsWith(".gif")) return "image/gif";
+  return "image/png";
+}
+async function bytesToImageBitmap(bytes, path) {
+  if (typeof createImageBitmap !== "function") {
+    throw new Error(
+      "@doki-land/live2d: createImageBitmap is not available in this environment"
+    );
+  }
+  const blob = new Blob([new Uint8Array(bytes)], {
+    type: guessMime(path)
+  });
+  return createImageBitmap(blob);
+}
+async function loadTextureData(resolver, paths, options = {}) {
+  const out = [];
+  const total = paths.length;
+  for (let i = 0; i < paths.length; i++) {
+    const key = paths[i];
+    options.onProgress?.({
+      index: i,
+      total,
+      key,
+      bytesLoaded: 0,
+      bytesTotal: null
+    });
+    const bytes = await resolver.fetchBytes(key);
+    options.onProgress?.({
+      index: i,
+      total,
+      key,
+      bytesLoaded: bytes.byteLength,
+      bytesTotal: bytes.byteLength
+    });
+    const image = await bytesToImageBitmap(bytes, key);
+    out.push({
+      index: i,
+      image,
+      width: image.width,
+      height: image.height
+    });
+  }
+  return out;
+}
+function releaseTextureData(textures) {
+  for (const t of textures) {
+    const img = t.image;
+    if (typeof ImageBitmap !== "undefined" && img instanceof ImageBitmap) {
+      img.close();
+    }
+  }
+}
+
+// src/motion/evaluate-curve.ts
+function evaluateMotion3(clip, timeSeconds) {
+  const t = clamp(timeSeconds, 0, clip.duration);
+  const out = [];
+  for (const curve of clip.curves) {
+    out.push({
+      target: curve.target,
+      id: curve.id,
+      value: evaluateCurve(curve, t, clip.areBeziersRestricted)
+    });
+  }
+  return out;
+}
+function evaluateCurve(curve, timeSeconds, areBeziersRestricted) {
+  const segs = curve.segments;
+  if (segs.length === 0) return 0;
+  if (timeSeconds <= segs[0].p0.time) return segs[0].p0.value;
+  const last = segs[segs.length - 1];
+  if (timeSeconds >= last.p3.time) return last.p3.value;
+  for (let i = 0; i < segs.length; i += 1) {
+    const seg = segs[i];
+    const isLast = i === segs.length - 1;
+    if (timeSeconds < seg.p3.time || isLast && timeSeconds <= seg.p3.time) {
+      return evaluateSegment(seg, timeSeconds, areBeziersRestricted);
+    }
+  }
+  return last.p3.value;
+}
+function evaluateSegment(seg, time, areBeziersRestricted) {
+  const { p0, p3 } = seg;
+  switch (seg.kind) {
+    case "linear": {
+      const span = p3.time - p0.time;
+      if (span <= 0) return p3.value;
+      const u = (time - p0.time) / span;
+      return p0.value + (p3.value - p0.value) * u;
+    }
+    case "stepped":
+      return p0.value;
+    case "inverseStepped":
+      return p3.value;
+    case "bezier": {
+      const p1 = seg.p1;
+      const p2 = seg.p2;
+      if (areBeziersRestricted) {
+        const span = p3.time - p0.time;
+        if (span <= 0) return p3.value;
+        const u2 = (time - p0.time) / span;
+        return cubic(p0.value, p1.value, p2.value, p3.value, u2);
+      }
+      const u = solveBezierTime(p0.time, p1.time, p2.time, p3.time, time);
+      return cubic(p0.value, p1.value, p2.value, p3.value, u);
+    }
+    default:
+      return p3.value;
+  }
+}
+function cubic(a, b, c, d, t) {
+  const u = 1 - t;
+  return u * u * u * a + 3 * u * u * t * b + 3 * u * t * t * c + t * t * t * d;
+}
+function solveBezierTime(t0, t1, t2, t3, target) {
+  let lo = 0;
+  let hi = 1;
+  for (let i = 0; i < 20; i += 1) {
+    const mid = (lo + hi) * 0.5;
+    const x = cubic(t0, t1, t2, t3, mid);
+    if (x < target) lo = mid;
+    else hi = mid;
+  }
+  return (lo + hi) * 0.5;
+}
+function clamp(n, min, max) {
+  if (n < min) return min;
+  if (n > max) return max;
+  return n;
+}
+
+// src/motion/types.ts
+var MotionPriority = {
+  none: 0,
+  idle: 1,
+  normal: 2,
+  force: 3
+};
+
+// src/motion/motion-player.ts
+var MotionPlayer = class {
+  #slots = /* @__PURE__ */ new Map();
+  #queues = /* @__PURE__ */ new Map();
+  #handlers;
+  constructor(handlers = {}) {
+    this.#handlers = handlers;
+  }
+  get isPlaying() {
+    return this.#slots.size > 0;
+  }
+  listPlaying() {
+    return [...this.#slots.values()].map((a) => ({
+      slot: a.slot,
+      group: a.group,
+      index: a.index,
+      time: a.time,
+      priority: a.priority
+    }));
+  }
+  /** @deprecated Prefer {@link listPlaying}; returns highest-priority slot. */
+  get current() {
+    const list = [...this.listPlaying()];
+    if (!list.length) return null;
+    list.sort((a, b) => b.priority - a.priority);
+    const top = list[0];
+    return {
+      group: top.group,
+      index: top.index,
+      time: top.time,
+      priority: top.priority
+    };
+  }
+  /**
+   * Start a clip on a slot. Returns false if rejected by priority
+   * (and not queued).
+   */
+  start(group, index, clip, options = {}) {
+    const priority = options.priority ?? MotionPriority.normal;
+    const slot = options.slot ?? `priority:${priority}`;
+    const existing = this.#slots.get(slot);
+    if (existing && priority < existing.priority) {
+      if (options.queue) {
+        this.#enqueue(slot, { group, index, clip, options });
+        return true;
+      }
+      return false;
+    }
+    if (existing && options.queue && !existing.fadingOut) {
+      this.#enqueue(slot, { group, index, clip, options });
+      return true;
+    }
+    if (existing) {
+      if (existing.fadeOutTime > 0 && !existing.fadingOut) {
+        existing.fadingOut = true;
+        existing.fadeOutElapsed = 0;
+        this.#enqueueFront(slot, { group, index, clip, options });
+        return true;
+      }
+      this.#finish(existing, false);
+    }
+    this.#slots.set(
+      slot,
+      this.#createActive(slot, group, index, clip, options)
+    );
+    return true;
+  }
+  /** Fade out (default) or hard-stop; `slot` omits → all slots. */
+  stop(fade = true, slot) {
+    if (slot !== void 0) {
+      const a = this.#slots.get(slot);
+      if (!a) return;
+      this.#stopOne(a, fade);
+      return;
+    }
+    for (const a of [...this.#slots.values()]) {
+      this.#stopOne(a, fade);
+    }
+  }
+  clear() {
+    this.#slots.clear();
+    this.#queues.clear();
+  }
+  /**
+   * Advance all slots and return blended samples (weight baked in; apply as absolute).
+   */
+  update(deltaTimeSeconds) {
+    const dt = Math.max(0, deltaTimeSeconds);
+    const layerSamples = [];
+    for (const a of [...this.#slots.values()]) {
+      const samples = this.#tick(a, dt);
+      if (samples) {
+        layerSamples.push({ priority: a.priority, samples });
+      }
+    }
+    layerSamples.sort((a, b) => a.priority - b.priority);
+    return blendMotionLayers(layerSamples);
+  }
+  #tick(a, dt) {
+    if (!a.started) {
+      a.started = true;
+      this.#handlers.onStart?.({
+        group: a.group,
+        index: a.index,
+        slot: a.slot
+      });
+    }
+    a.time += dt;
+    if (a.fadingOut) {
+      a.fadeOutElapsed += dt;
+      if (a.fadeOutElapsed >= a.fadeOutTime) {
+        this.#finish(a, true);
+        return null;
+      }
+    } else if (!a.loop && a.time >= a.clip.duration) {
+      if (a.fadeOutTime > 0) {
+        a.fadingOut = true;
+        a.fadeOutElapsed = 0;
+      } else {
+        const samples = this.#sample(a, a.clip.duration, 1);
+        this.#finish(a, true);
+        return samples;
+      }
+    }
+    let playTime = a.time;
+    if (a.loop && a.clip.duration > 0) {
+      playTime = a.time % a.clip.duration;
+    } else {
+      playTime = Math.min(playTime, a.clip.duration);
+    }
+    this.#emitEvents(a, playTime);
+    return this.#sample(a, playTime, this.#fadeWeight(a));
+  }
+  #createActive(slot, group, index, clip, options) {
+    const fadeIn = options.fadeInTime ?? (clip.fadeInTime > 0 ? clip.fadeInTime : 0);
+    const fadeOut = options.fadeOutTime ?? (clip.fadeOutTime > 0 ? clip.fadeOutTime : 0);
+    return {
+      slot,
+      group,
+      index,
+      clip,
+      priority: options.priority ?? MotionPriority.normal,
+      loop: options.loop ?? clip.loop,
+      fadeInTime: Math.max(0, fadeIn),
+      fadeOutTime: Math.max(0, fadeOut),
+      time: 0,
+      fadingOut: false,
+      fadeOutElapsed: 0,
+      lastEventIndex: -1,
+      started: false
+    };
+  }
+  #enqueue(slot, item) {
+    const q = this.#queues.get(slot) ?? [];
+    q.push(item);
+    this.#queues.set(slot, q);
+  }
+  #enqueueFront(slot, item) {
+    const q = this.#queues.get(slot) ?? [];
+    q.unshift(item);
+    this.#queues.set(slot, q);
+  }
+  #stopOne(a, fade) {
+    if (!fade || a.fadeOutTime <= 0) {
+      this.#finish(a, true);
+      return;
+    }
+    a.fadingOut = true;
+    a.fadeOutElapsed = 0;
+  }
+  #finish(a, promoteQueue) {
+    if (this.#slots.get(a.slot) !== a) return;
+    this.#slots.delete(a.slot);
+    this.#handlers.onFinish?.({
+      group: a.group,
+      index: a.index,
+      slot: a.slot
+    });
+    if (!promoteQueue) return;
+    const q = this.#queues.get(a.slot);
+    const next = q?.shift();
+    if (next) {
+      this.#slots.set(
+        a.slot,
+        this.#createActive(
+          a.slot,
+          next.group,
+          next.index,
+          next.clip,
+          next.options
+        )
+      );
+    }
+  }
+  #sample(a, playTime, weight) {
+    const values = evaluateMotion3(a.clip, playTime);
+    return values.map((v) => ({
+      target: v.target,
+      id: v.id,
+      value: v.value,
+      weight
+    }));
+  }
+  #fadeWeight(a) {
+    let w = 1;
+    if (a.fadeInTime > 0 && a.time < a.fadeInTime) {
+      w = sineEase(a.time / a.fadeInTime);
+    }
+    if (a.fadingOut && a.fadeOutTime > 0) {
+      const u = 1 - a.fadeOutElapsed / a.fadeOutTime;
+      w *= sineEase(Math.max(0, u));
+    }
+    return w;
+  }
+  #emitEvents(a, playTime) {
+    const events = a.clip.userData;
+    for (let i = a.lastEventIndex + 1; i < events.length; i += 1) {
+      const e = events[i];
+      if (e.time > playTime) break;
+      a.lastEventIndex = i;
+      this.#handlers.onEvent?.({
+        group: a.group,
+        index: a.index,
+        slot: a.slot,
+        time: e.time,
+        value: e.value
+      });
+    }
+    if (a.loop && a.clip.duration > 0) {
+      const prevMod = (a.time - 1e-6) % a.clip.duration + (a.time - 1e-6 < 0 ? a.clip.duration : 0);
+      if (playTime < prevMod - 1e-4) {
+        a.lastEventIndex = -1;
+      }
+    }
+  }
+};
+function blendMotionLayers(layers) {
+  const map = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    for (const s of layer.samples) {
+      const key = `${s.target}\0${s.id}`;
+      const w = Math.min(1, Math.max(0, s.weight));
+      const prev = map.get(key);
+      if (!prev) {
+        map.set(key, {
+          target: s.target,
+          id: s.id,
+          value: s.value,
+          weight: w
+        });
+      } else {
+        prev.value = prev.value + (s.value - prev.value) * w;
+        prev.weight = Math.min(1, prev.weight + w * (1 - prev.weight));
+      }
+    }
+  }
+  return [...map.values()];
+}
+function sineEase(t) {
+  const x = Math.min(1, Math.max(0, t));
+  return 0.5 - 0.5 * Math.cos(x * Math.PI);
+}
+
+// src/motion/parse-motion3.ts
+var SEGMENT_KIND = {
+  0: "linear",
+  1: "bezier",
+  2: "stepped",
+  3: "inverseStepped"
+};
+function parseMotion3(json) {
+  if (!json || typeof json !== "object") {
+    throw new Error(
+      "@doki-land/live2d: motion3.json root must be an object"
+    );
+  }
+  const root = json;
+  const version = Number(root.Version ?? 3);
+  const meta = root.Meta;
+  if (!meta || typeof meta !== "object") {
+    throw new Error("@doki-land/live2d: motion3.json missing Meta");
+  }
+  const m = meta;
+  const duration = num(m.Duration, "Meta.Duration");
+  const fps = num(m.Fps, "Meta.Fps");
+  const loop = m.Loop === true;
+  const areBeziersRestricted = m.AreBeziersRestricted !== false;
+  const fadeInTime = optionalNum(m.FadeInTime) ?? 0;
+  const fadeOutTime = optionalNum(m.FadeOutTime) ?? 0;
+  const curvesRaw = root.Curves;
+  if (!Array.isArray(curvesRaw)) {
+    throw new Error("@doki-land/live2d: motion3.json missing Curves");
+  }
+  const curves = curvesRaw.map((c, i) => parseCurve(c, i));
+  const userData = [];
+  if (Array.isArray(root.UserData)) {
+    for (const item of root.UserData) {
+      if (!item || typeof item !== "object") continue;
+      const u = item;
+      if (typeof u.Time === "number" && typeof u.Value === "string") {
+        userData.push({ time: u.Time, value: u.Value });
+      }
+    }
+    userData.sort((a, b) => a.time - b.time);
+  }
+  return {
+    version,
+    duration,
+    fps,
+    loop,
+    areBeziersRestricted,
+    fadeInTime,
+    fadeOutTime,
+    curves,
+    userData
+  };
+}
+function parseCurve(raw, index) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error(`@doki-land/live2d: Curves[${index}] invalid`);
+  }
+  const c = raw;
+  const target = c.Target;
+  const id = c.Id;
+  if (typeof target !== "string" || typeof id !== "string") {
+    throw new Error(`@doki-land/live2d: Curves[${index}] needs Target/Id`);
+  }
+  if (target !== "Parameter" && target !== "PartOpacity" && target !== "Model") {
+    throw new Error(
+      `@doki-land/live2d: Curves[${index}] unknown Target ${target}`
+    );
+  }
+  const segmentsFlat = c.Segments;
+  if (!Array.isArray(segmentsFlat) || segmentsFlat.length < 2) {
+    throw new Error(`@doki-land/live2d: Curves[${index}] empty Segments`);
+  }
+  const numbers = segmentsFlat.map((n, j) => {
+    if (typeof n !== "number" || !Number.isFinite(n)) {
+      throw new Error(
+        `@doki-land/live2d: Curves[${index}].Segments[${j}] not a number`
+      );
+    }
+    return n;
+  });
+  return {
+    target,
+    id,
+    fadeInTime: optionalNum(c.FadeInTime),
+    fadeOutTime: optionalNum(c.FadeOutTime),
+    segments: parseSegments(numbers, index)
+  };
+}
+function parseSegments(flat, curveIndex) {
+  let i = 0;
+  const p0 = { time: flat[i++], value: flat[i++] };
+  const out = [];
+  let prev = p0;
+  while (i < flat.length) {
+    const kindId = flat[i++];
+    const kind = SEGMENT_KIND[kindId];
+    if (!kind) {
+      throw new Error(
+        `@doki-land/live2d: Curves[${curveIndex}] unknown segment ${kindId}`
+      );
+    }
+    if (kind === "bezier") {
+      if (i + 5 >= flat.length) {
+        throw new Error(
+          `@doki-land/live2d: Curves[${curveIndex}] truncated bezier`
+        );
+      }
+      const p1 = { time: flat[i++], value: flat[i++] };
+      const p2 = { time: flat[i++], value: flat[i++] };
+      const p3 = { time: flat[i++], value: flat[i++] };
+      out.push({ kind, p0: prev, p1, p2, p3 });
+      prev = p3;
+    } else {
+      if (i + 1 >= flat.length) {
+        throw new Error(
+          `@doki-land/live2d: Curves[${curveIndex}] truncated ${kind}`
+        );
+      }
+      const p3 = { time: flat[i++], value: flat[i++] };
+      out.push({ kind, p0: prev, p3 });
+      prev = p3;
+    }
+  }
+  return out;
+}
+function num(v, label) {
+  if (typeof v !== "number" || !Number.isFinite(v)) {
+    throw new Error(`@doki-land/live2d: motion3 ${label} must be a number`);
+  }
+  return v;
+}
+function optionalNum(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+
+// src/create-live2d.ts
+function lerp(a, b, t) {
+  return a + (b - a) * Math.min(1, Math.max(0, t));
+}
+function nowMs() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function createLive2D(options = {}) {
+  const backends = options.backends ?? [
+    createMoc2Backend(),
+    createMoc3Backend()
+  ];
+  const renderer = options.renderer ?? createRenderer({ prefer: options.prefer });
+  const events = new EventEmitter();
+  let canvas = null;
+  let model = null;
+  let activeBackend = null;
+  let drawPass = null;
+  let loadedTextures = [];
+  let initPromise = null;
+  let phase = "idle";
+  let lastError = null;
+  let generation = 0;
+  let loadGeneration = 0;
+  let fpsSmooth = 0;
+  let activeResolver = null;
+  const motionCache = /* @__PURE__ */ new Map();
+  const motionPlayer = new MotionPlayer({
+    onStart: ({ group, index, slot }) => events.emit("motion:start", { group, index, slot }),
+    onFinish: ({ group, index, slot }) => events.emit("motion:finish", { group, index, slot })
+  });
+  const applyMotionSamples = (samples) => {
+    if (!model || !activeBackend) return;
+    for (const s of samples) {
+      if (s.weight <= 0) continue;
+      if (s.target === "PartOpacity") {
+        if (!activeBackend.setPartOpacity) continue;
+        if (s.weight >= 1) {
+          activeBackend.setPartOpacity(model, s.id, s.value);
+        } else {
+          const cur2 = 1;
+          activeBackend.setPartOpacity(
+            model,
+            s.id,
+            cur2 + (s.value - cur2) * s.weight
+          );
+        }
+        continue;
+      }
+      if (s.target !== "Parameter" || !activeBackend.setParameter)
+        continue;
+      if (s.weight >= 1) {
+        activeBackend.setParameter(model, s.id, s.value);
+        continue;
+      }
+      const cur = activeBackend.listParameters?.(model).find((p) => p.id === s.id)?.value ?? s.value;
+      activeBackend.setParameter(
+        model,
+        s.id,
+        cur + (s.value - cur) * s.weight
+      );
+    }
+  };
+  const clearTextures = () => {
+    if (loadedTextures.length > 0) {
+      releaseTextureData(loadedTextures);
+      loadedTextures = [];
+    }
+    drawPass?.setTextures([]);
+  };
+  const setPhase = (next) => {
+    phase = next;
+    events.emit("phase", { phase, generation });
+  };
+  const report = (payload) => {
+    events.emit("progress", payload);
+  };
+  const state = () => ({
+    phase,
+    lastError,
+    generation
+  });
+  const ensureInitialized = async () => {
+    if (!canvas) {
+      throw new Error(
+        "@doki-land/live2d: call mount(canvas) before loadModel"
+      );
+    }
+    if (!initPromise) {
+      setPhase("mounting");
+      const gen = generation;
+      initPromise = renderer.initialize(canvas).then(() => {
+        if (gen !== generation) return;
+        drawPass = renderer.createModelDrawPass();
+        setPhase("ready");
+      }).catch((err) => {
+        lastError = err;
+        setPhase("error");
+        events.emit("error", { error: err });
+        throw err;
+      });
+    }
+    await initPromise;
+  };
+  const runtime = {
+    events,
+    backends,
+    renderer,
+    get model() {
+      return model;
+    },
+    get state() {
+      return state();
+    },
+    mount(target) {
+      generation += 1;
+      canvas = target;
+      initPromise = null;
+      clearTextures();
+      drawPass?.destroy();
+      drawPass = null;
+      setPhase("idle");
+      void ensureInitialized();
+    },
+    async loadModel(source, resolver) {
+      const gen = ++loadGeneration;
+      setPhase("loading");
+      report({
+        stage: "mounting",
+        progress: 0.01,
+        detail: "initialize renderer"
+      });
+      await ensureInitialized();
+      if (gen !== loadGeneration) {
+        throw new Error("@doki-land/live2d: load cancelled");
+      }
+      report({
+        stage: "resolve",
+        progress: 0.02,
+        detail: "resolve source"
+      });
+      try {
+        let json;
+        let baseUrl;
+        let settingsUrl;
+        if (typeof source === "object" && source.kind === "json") {
+          json = source.json;
+          baseUrl = source.baseUrl;
+          settingsUrl = source.baseUrl;
+          report({
+            stage: "settings",
+            progress: 0.2,
+            detail: "inline settings"
+          });
+        } else {
+          const raw = typeof source === "string" ? source : source.kind === "npm" ? modelSourceUrl(source) : source.url;
+          const cdnBase = typeof source === "object" && source.kind === "npm" ? source.cdnBase : void 0;
+          const fetchUrl = resolveModelSourceUrl(raw, {
+            npmCdnBase: cdnBase
+          });
+          report({
+            stage: "settings",
+            progress: 0.05,
+            detail: fetchUrl
+          });
+          json = await fetchModelJson(fetchUrl, (u) => {
+            const ratio = u.bytesTotal && u.bytesTotal > 0 ? u.bytesLoaded / u.bytesTotal : 0;
+            report({
+              stage: "settings",
+              progress: lerp(0.05, 0.22, ratio),
+              detail: fetchUrl,
+              bytesLoaded: u.bytesLoaded,
+              bytesTotal: u.bytesTotal
+            });
+          });
+          baseUrl = fetchUrl;
+          settingsUrl = fetchUrl;
+        }
+        if (gen !== loadGeneration) {
+          throw new Error("@doki-land/live2d: load cancelled");
+        }
+        const settings = normalizeModelSettings(json, settingsUrl);
+        report({
+          stage: "moc",
+          progress: 0.25,
+          detail: settings.moc
+        });
+        const assetResolver = resolver ?? createUrlAssetResolver(baseUrl, {
+          onBytesProgress: (key, u) => {
+            const isMoc = key === settings.moc;
+            const ratio = u.bytesTotal && u.bytesTotal > 0 ? u.bytesLoaded / u.bytesTotal : 0;
+            if (isMoc) {
+              report({
+                stage: "moc",
+                progress: lerp(0.25, 0.8, ratio),
+                detail: key,
+                bytesLoaded: u.bytesLoaded,
+                bytesTotal: u.bytesTotal
+              });
+            } else {
+              report({
+                stage: "textures",
+                progress: lerp(0.8, 0.9, ratio),
+                detail: key,
+                bytesLoaded: u.bytesLoaded,
+                bytesTotal: u.bytesTotal
+              });
+            }
+          }
+        });
+        activeResolver = assetResolver;
+        motionPlayer.clear();
+        motionCache.clear();
+        const backend = selectModelBackend(backends, json);
+        report({
+          stage: "decode",
+          progress: 0.85,
+          detail: `decode ${settings.format}`
+        });
+        const next = await backend.createModel(settings, {
+          renderer,
+          resolver: assetResolver
+        });
+        if (gen !== loadGeneration) {
+          backend.destroyModel(next);
+          throw new Error("@doki-land/live2d: load cancelled");
+        }
+        clearTextures();
+        if (settings.textures.length > 0 && drawPass) {
+          report({
+            stage: "textures",
+            progress: 0.88,
+            detail: `${settings.textures.length} textures`
+          });
+          const textures = await loadTextureData(
+            assetResolver,
+            settings.textures,
+            {
+              onProgress: (u) => {
+                const ratio = u.total > 0 ? (u.index + 1) / u.total : 1;
+                report({
+                  stage: "textures",
+                  progress: lerp(0.88, 0.96, ratio),
+                  detail: u.key,
+                  bytesLoaded: u.bytesLoaded,
+                  bytesTotal: u.bytesTotal
+                });
+              }
+            }
+          );
+          if (gen !== loadGeneration) {
+            releaseTextureData(textures);
+            backend.destroyModel(next);
+            throw new Error("@doki-land/live2d: load cancelled");
+          }
+          loadedTextures = textures;
+          drawPass.setTextures(textures);
+        }
+        if (model && activeBackend) {
+          activeBackend.destroyModel(model);
+        }
+        model = next;
+        activeBackend = backend;
+        lastError = null;
+        setPhase("live");
+        report({
+          stage: "ready",
+          progress: 1,
+          detail: model.id
+        });
+        events.emit("ready", { modelId: model.id });
+        return model;
+      } catch (err) {
+        lastError = err;
+        setPhase("error");
+        events.emit("error", { error: err });
+        throw err;
+      }
+    },
+    captureFrame() {
+      if (!model || !activeBackend?.captureFrame) return null;
+      return activeBackend.captureFrame(model);
+    },
+    setParameter(id, value) {
+      if (!model || !activeBackend?.setParameter) return;
+      activeBackend.setParameter(model, id, value);
+    },
+    hitTest(x, y) {
+      if (!model || !activeBackend) return null;
+      const drawables = activeBackend.getDrawables(model);
+      for (let n = drawables.length - 1; n >= 0; n -= 1) {
+        const d = drawables[n];
+        if (!d.visible || d.opacity <= 0) continue;
+        const p = d.vertexPositions;
+        const idx = d.indices;
+        for (let i = 0; i + 2 < idx.length; i += 3) {
+          const a = idx[i] * 2, b = idx[i + 1] * 2, c = idx[i + 2] * 2;
+          const ax = p[a], ay = p[a + 1];
+          const bx = p[b], by = p[b + 1];
+          const cx = p[c], cy = p[c + 1];
+          const s = (ax - cx) * (y - cy) - (ay - cy) * (x - cx);
+          const s1 = (bx - ax) * (y - ay) - (by - ay) * (x - ax);
+          const s2 = (cx - bx) * (y - by) - (cy - by) * (x - bx);
+          if (s >= 0 && s1 >= 0 && s2 >= 0 || s <= 0 && s1 <= 0 && s2 <= 0) {
+            return `drawable:${d.index}`;
+          }
+        }
+      }
+      return null;
+    },
+    listParameters() {
+      if (!model || !activeBackend?.listParameters) return [];
+      return activeBackend.listParameters(model);
+    },
+    listMotionGroups() {
+      return model?.settings.motionGroups ?? {};
+    },
+    async playMotion(group, index = 0, options2 = {}) {
+      if (!model || !activeResolver) return false;
+      const list = model.settings.motionGroups[group];
+      const def = list?.[index];
+      if (!def) return false;
+      let clip = motionCache.get(def.file);
+      if (!clip) {
+        const json = await activeResolver.fetchJson(def.file);
+        clip = parseMotion3(json);
+        motionCache.set(def.file, clip);
+      }
+      const fadeInTime = options2.fadeInTime ?? def.fadeInTime ?? clip.fadeInTime;
+      const fadeOutTime = options2.fadeOutTime ?? def.fadeOutTime ?? clip.fadeOutTime;
+      return motionPlayer.start(group, index, clip, {
+        priority: options2.priority ?? MotionPriority.normal,
+        slot: options2.slot,
+        queue: options2.queue,
+        loop: options2.loop,
+        fadeInTime,
+        fadeOutTime
+      });
+    },
+    stopMotion(opts) {
+      motionPlayer.stop(opts?.fade !== false, opts?.slot);
+    },
+    listPlayingMotions() {
+      return motionPlayer.listPlaying();
+    },
+    async capturePng(opts = {}) {
+      if (!canvas) {
+        throw new Error(
+          "@doki-land/live2d: mount(canvas) before capturePng"
+        );
+      }
+      if (phase === "live" && model && activeBackend && drawPass) {
+        runtime.update(0);
+      }
+      const mime = opts.mimeType ?? "image/png";
+      return await new Promise((resolve, reject) => {
+        canvas.toBlob(
+          (blob) => {
+            if (blob) resolve(blob);
+            else
+              reject(
+                new Error(
+                  "@doki-land/live2d: canvas.toBlob returned null"
+                )
+              );
+          },
+          mime,
+          opts.quality
+        );
+      });
+    },
+    update(deltaTimeSeconds) {
+      if (!model || !activeBackend || !drawPass) return;
+      if (phase !== "live") return;
+      const t0 = nowMs();
+      applyMotionSamples(motionPlayer.update(deltaTimeSeconds));
+      activeBackend.updateModel(model, deltaTimeSeconds);
+      const drawables = activeBackend.getDrawables(model);
+      const t1 = nowMs();
+      renderer.beginFrame();
+      drawPass.draw(drawables, new Float32Array(16));
+      renderer.endFrame();
+      const t2 = nowMs();
+      let vertexCount = 0;
+      let indexCount = 0;
+      for (const d of drawables) {
+        vertexCount += d.vertexPositions.length / 2;
+        indexCount += d.indices.length;
+      }
+      const frameMs = t2 - t0;
+      const evaluateMs = t1 - t0;
+      const drawMs = t2 - t1;
+      const fps = deltaTimeSeconds > 0 ? 1 / deltaTimeSeconds : 0;
+      fpsSmooth = fpsSmooth <= 0 ? fps : fpsSmooth * 0.85 + fps * 0.15;
+      events.emit("profile", {
+        fps,
+        fpsSmooth,
+        frameMs,
+        evaluateMs,
+        drawMs,
+        drawableCount: drawables.length,
+        vertexCount,
+        indexCount
+      });
+    },
+    destroy() {
+      loadGeneration += 1;
+      generation += 1;
+      motionPlayer.clear();
+      motionCache.clear();
+      activeResolver = null;
+      if (model && activeBackend) {
+        activeBackend.destroyModel(model);
+      }
+      model = null;
+      activeBackend = null;
+      clearTextures();
+      drawPass?.destroy();
+      drawPass = null;
+      initPromise = null;
+      renderer.destroy();
+      canvas = null;
+      setPhase("destroyed");
+      events.clear();
+    }
+  };
+  return runtime;
+}
+
+// src/focus.ts
+function focusParameterUpdates(parameters, dragX, dragY) {
+  const byId = new Map(parameters.map((p) => [p.id, p]));
+  const x = clampUnit(dragX);
+  const y = clampUnit(dragY);
+  const out = [];
+  const set = (id, normalized) => {
+    const binding = byId.get(id);
+    if (!binding) return;
+    out.push({ id, value: valueFromNormalized(binding, normalized) });
+  };
+  set("PARAM_ANGLE_X", x);
+  set("PARAM_ANGLE_Y", y);
+  set("PARAM_ANGLE_Z", clampUnit(x * y * -1));
+  set("PARAM_BODY_ANGLE_X", x);
+  set("PARAM_BODY_ANGLE_Y", y);
+  set("PARAM_EYE_BALL_X", x);
+  set("PARAM_EYE_BALL_Y", y);
+  return out;
+}
+function clampUnit(n) {
+  if (n > 1) return 1;
+  if (n < -1) return -1;
+  return n;
+}
+function valueFromNormalized(binding, normalized) {
+  const n = clampUnit(normalized);
+  return n >= 0 ? binding.defaultValue + (binding.max - binding.defaultValue) * n : binding.defaultValue + (binding.defaultValue - binding.min) * n;
+}
+
+// src/index.ts
+var LIVE2D_VERSION = "0.0.0";
+export {
+  DEFAULT_NPM_CDN,
+  EventEmitter2 as EventEmitter,
+  LIVE2D_VERSION,
+  MotionPlayer,
+  MotionPriority,
+  blendMotionLayers,
+  createCanvas2DRenderer,
+  createLive2D,
+  createMoc2Backend2 as createMoc2Backend,
+  createMoc3Backend2 as createMoc3Backend,
+  createQuadProgram,
+  createRenderer2 as createRenderer,
+  createWebGl2Renderer,
+  createWebGpuRenderer,
+  decodeMoc3,
+  evaluateCurve,
+  evaluateFrame,
+  evaluateMotion3,
+  fingerprintSnapshot,
+  focusParameterUpdates,
+  parseCpuProgram,
+  parseMotion3,
+  resolveModelSourceUrl2 as resolveModelSourceUrl,
+  resolveNpmSpecifier,
+  serializeCpuProgram
+};