@taole/giftstage 0.1.33 → 0.1.35

package/dist/types/index.d.ts

@@ -26,14 +26,16 @@ export interface TextureOpts {
     sourcePremultiplied?: boolean;
 }
 export type ShaderType = 'svga-batch-premul'
-/** WebGPU / WebGL2: SVGA premultiplied atlas sprites batched as instances using `FrameJobData` payloads. */
+/** WebGPU / WebGL2: SVGA premultiplied atlas sprites batched as packed instances. */
  | 'svga-instanced-premul' | 'vap'
 /** Main-context VAP mixed resource draw: resource texture multiplied by raw-video mask. */
  | 'vap-mix-overlay'
 /** WebGPU / WebGL2: batched VAP sharing one texture; see `instanceCount` / `instanceData` (32 floats/instance). */
  | 'vap-instanced' | 'alpha-video'
 /** WebGPU: batched draws sharing one texture (e.g. atlas); see `instanceCount` / `instanceData`. */
- | 'alpha-video-instanced' | 'rgba-textured' | 'clip-mask';
+ | 'alpha-video-instanced' | 'rgba-textured' | 'clip-mask'
+/** WebGPU / WebGL2: one local-space clip mesh transformed by per-instance affine data. */
+ | 'clip-mask-instanced';
 export type StencilMode = 'none' | 'write' | 'test' | 'clear';
 export interface DrawCommand {
     shader: ShaderType;
@@ -44,13 +46,15 @@ export interface DrawCommand {
     uniforms: Record<string, Float32Array | number>;
     stencil?: StencilMode;
     /**
-     * `svga-instanced-premul`: the first `instanceCount * 13` floats are consumed
-     * (layout + transform + alpha + uv rect).
+     * `svga-instanced-premul`: the first `instanceCount * 13` words are consumed
+     * (pre-scaled transform, alpha, UV rect, and two packed framebuffer clip pairs).
      *
      * `alpha-video-instanced`: the first `instanceCount * 12` floats are consumed
      * (display rect + atlasRemap + opacity/source-alpha-mode vec4).
      * `vap-instanced`: the first `instanceCount * 32` floats are consumed
      * (mat4 + atlasRemap + rgb/alpha rects + opacity/source-alpha-mode vec4).
+     * `clip-mask-instanced`: the first `instanceCount * 6` floats are consumed
+     * (a, b, c, d, tx, ty affine transform).
      * Renderers may pass a larger reused scratch array to avoid allocating a subarray view per draw.
      */
     instanceCount?: number;
@@ -80,6 +84,15 @@ export interface GPUBackend {
     clearStencil?(): void;
     setScissor(x: number, y: number, w: number, h: number): void;
     resetScissor(): void;
+    /** Internal performance-harness diagnostics; absent on backends without native buffer uploads. */
+    getPerformanceSnapshot?(): {
+        bufferWrites: number;
+        bufferWriteBytes: number;
+        storageBufferWrites: number;
+        storageBufferWriteBytes: number;
+    };
+    /** Resets the internal performance-harness diagnostics for a new sampling window. */
+    resetPerformanceSnapshot?(): void;
     destroy(): void;
 }
 export interface SVGAParams {
@@ -148,6 +161,8 @@ export interface SVGASpriteTable {
     shapesTable: SVGAShape[][];
     shapesIndex: Int32Array;
     hasAnyShapes: boolean;
+    /** Internal parser-derived fast-path flag; undefined only for legacy/incomplete data. */
+    allFramesInsideViewBox?: boolean;
 }
 export interface SVGAAudio {
     audioKey: string;
@@ -271,6 +286,47 @@ export interface ResolvedSVGASlotTexture {
     logicalWidth: number;
     logicalHeight: number;
 }
+/**
+ * SVGABatchRenderer-internal: one packed instance row for a `stopped` slot's static batch
+ * cache (P1-10). `row` mirrors the exact `FRAME_DATA_FLOATS` layout `packFrameData` produces.
+ * `isOverride` mirrors whether the sprite used a `svgaSlots` texture override (drawn immediately,
+ * breaking any running atlas batch) vs. a normal atlas sprite (batched with same-texture sprites).
+ */
+export interface SVGAStaticBatchCacheEntry {
+    row: Float32Array;
+    handle: GPUTextureHandle;
+    isOverride: boolean;
+}
+/**
+ * SVGABatchRenderer-internal: cached packed-instance-row list for a `stopped` SVGA slot, plus
+ * the exact snapshot of every input it was built from. Any mismatch against the slot's current
+ * values invalidates the cache (see `SVGABatchRenderer`'s match check) — favors over-invalidating
+ * to guarantee correctness over maximizing hit rate.
+ */
+export interface SVGAStaticBatchCache {
+    entries: SVGAStaticBatchCacheEntry[];
+    /** `VideoEntity` reference the cache was built against (covers spriteTable/atlasRects identity). */
+    entity: unknown;
+    /** `entity.atlasTextureHandles` (if any) or `entity.atlasTextureHandle`, whichever is in use. */
+    atlasHandlesDep: unknown;
+    /**
+     * `slot.svgaSlotTextures` map reference. `svgaSlots` overrides are immutable post-load, but
+     * tracked defensively so a future change to that invariant can't silently go stale here.
+     */
+    svgaSlotTextures: unknown;
+    currentFrame: number;
+    opacity: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    scale: number;
+    rotation: number;
+    sx: number;
+    sy: number;
+    offsetX: number;
+    offsetY: number;
+}
 export interface ResolvedVAPResource {
     source: CanvasImageSource;
     width: number;
@@ -566,6 +622,11 @@ export interface GiftSlot {
     accumulatedTime: number;
     lastTickTime: number;
     loopCount: number;
+    /**
+     * SVGABatchRenderer internal: most recent frame whose complete set of referenced clip meshes
+     * is ready. A later frame with a mesh miss renders this frame until the missing meshes land.
+     */
+    svgaClipReadyFrame?: number | null;
     videoEntity: VideoEntity | null;
     loadAbortController?: AbortController | null;
     /** HTMLVideoElement finite-playback watchdog; cleared on normal completion or resource release. */
@@ -613,6 +674,32 @@ export interface GiftSlot {
         map: unknown;
         size: number;
     };
+    /**
+     * RenderManager internal: cached coincident-visual-duplicate key + the exact field snapshot it
+     * was built from. Rebuilt only when one of those fields actually changes, avoiding a template
+     * string array + `join('|')` allocation on every dirty frame for every visible slot.
+     */
+    coincidentVisualKeyCache?: {
+        key: string;
+        resourceKey: string;
+        frameKey: string;
+        svgaSlotKey: string;
+        objectFit: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        scale: number;
+        opacity: number;
+        rotation: number | undefined;
+        originX: string | number;
+        originY: string | number;
+    };
+    /**
+     * SVGABatchRenderer internal: cached packed instance rows for a `stopped` slot with no
+     * shape/clip sprites this frame (P1-10). Rebuilt whenever any tracked input changes.
+     */
+    svgaStaticBatchCache?: SVGAStaticBatchCache | null;
     onFrame?: (frame: number, gift: GiftHandle) => void;
     onComplete?: (gift: GiftHandle) => void;
 }
@@ -654,6 +741,8 @@ export interface VAPFrameObj {
     mt?: number;
     frame: [number, number, number, number];
     mFrame: [number, number, number, number];
+    /** `String(srcId)` precomputed once by `buildVAPFrameMap` to avoid per-draw re-stringification. */
+    srcKey?: string;
 }
 export interface FlyAnimation {
     giftId: string;

package/dist/utils/gift-transform.d.ts

@@ -20,10 +20,11 @@ export declare function resolveGiftTransformOrigin(slot: GiftSlot, out?: GiftTra
 export declare function fillGiftTransformMatrix(slot: GiftSlot, x: number, y: number, width: number, height: number, out: Float32Array): Float32Array;
 /** Apply the gift's parent rotation to an existing local-to-stage affine transform. */
 export declare function rotateGiftAffine(slot: GiftSlot, transform: Affine2D, out?: Affine2D): Affine2D;
-/** AABB of a rotated stage-space rectangle, suitable for the backend scissor. */
-export declare function getRotatedRectAABB(slot: GiftSlot, x: number, y: number, width: number, height: number): {
+export interface RectAABB {
     x: number;
     y: number;
     w: number;
     h: number;
-};
+}
+/** AABB of a rotated stage-space rectangle, suitable for the backend scissor. */
+export declare function getRotatedRectAABB(slot: GiftSlot, x: number, y: number, width: number, height: number, out?: RectAABB): RectAABB;

package/dist/utils/resource-cache.d.ts

@@ -10,6 +10,19 @@ export declare class AsyncLimiter {
     run<T>(task: () => Promise<T>): Promise<T>;
     private drain;
 }
+/**
+ * Structural estimate; avoids JSON.stringify of the whole sprites tree (main-thread spike).
+ *
+ * When the worker-binary path is used, `imageBlob` is the *entire* deserialized SGPB buffer
+ * (see `deserializeSVGAWorkerPayload`), not just the image bytes — `spriteTable.frameData`/
+ * `clipPathIndex`/`shapesIndex` are typed-array *views* sharing that same underlying
+ * `ArrayBuffer` (see `readSpriteTable` in `svga-sprite-table-binary.ts`). Adding their
+ * `byteLength` again on top of `imageBlob.byteLength` would double-count them, systematically
+ * inflating the estimate and causing the memory LRU to evict/re-parse too eagerly. Only add
+ * them when they do *not* share `imageBlob`'s buffer (the legacy `images` record path, where
+ * the sprite table is a separate allocation).
+ */
+export declare function estimateSVGAWorkerPayloadBytes(payload: SVGAWorkerMoviePayload): number;
 export declare class ResourceCacheManager {
     private readonly limiter;
     private readonly pending;

package/dist/video/webcodecs-mp4-core.d.ts

@@ -32,6 +32,57 @@ export declare function decodeH264ToFrames(codec: string, description: ArrayBuff
     frames: VideoFrame[];
     timesSec: Float64Array;
 }>;
+export interface IncrementalH264DecoderCallbacks {
+    onFrame: (index: number, frame: VideoFrame) => void;
+    onDecoded?: () => void;
+    onDropped?: () => void;
+    onEos?: () => void;
+    onError?: (error: unknown) => void;
+}
+/**
+ * Playhead-driven incremental H.264 decode: feeds chunks in decode order only up to
+ * `needIdx + decodeAheadFrames` (via {@link ensure}), so memory stays bounded by how far ahead
+ * of playback the caller asks for instead of decoding (and retaining) the entire clip upfront.
+ * Originally the Worker's demux/decode pump (see `webcodecs-mp4.worker.ts`); lifted here so the
+ * main-thread WebCodecs fallback (no Worker available, or `useWorker: false`) can reuse the exact
+ * same backpressure/rewind semantics instead of decoding the whole file into memory at once —
+ * see P1-10 optimization notes / `WebCodecsMp4Playback.createOnMainThread`.
+ */
+export declare class IncrementalH264Decoder {
+    private readonly decodeOrder;
+    private readonly presTimes;
+    private readonly timescale;
+    private readonly codec;
+    private readonly description;
+    private readonly duration;
+    private readonly callbacks;
+    private decoder;
+    private nextChunk;
+    private chunksFed;
+    private targetNeedIdx;
+    private lastPostedMax;
+    private minPosted;
+    private playbackNeedFloor;
+    /** Remaining output budget from the latest `ensure`; decremented only when a frame is posted. */
+    private freeSlots;
+    private eosClosed;
+    private pumpScheduled;
+    private pumping;
+    private destroyed;
+    private readonly onDecoderDequeue;
+    constructor(decodeOrder: Sample[], presTimes: Float64Array, timescale: number, codec: string, description: ArrayBuffer | undefined, duration: number, callbacks: IncrementalH264DecoderCallbacks, initialNeedIdx: number);
+    /** Raise the decode target and/or update main-thread ring headroom; resumes the pump if idle. */
+    ensure(needIdx: number, freeSlots: number): void;
+    /** Restart decode from the nearest keyframe at/before t=0 (backward seek / loop wrap). */
+    rewind(): void;
+    destroy(): void;
+    private schedulePump;
+    private doRewind;
+    private openDecoder;
+    private feedOneChunk;
+    private finalizeEos;
+    private runPump;
+}
 export declare function frameIndexForTime(timesSec: Float64Array, clipDurationSec: number, t: number): number;
 export declare function computeClipDurationSeconds(metaDurationSec: number, timesSec: Float64Array, frames: VideoFrame[]): number;
 /** Clip duration from demux metadata + presentation timeline only (no decoded frames). */

package/dist/video/webcodecs-mp4-playback.d.ts

@@ -1,3 +1,12 @@
+export interface WebCodecsPerformanceSnapshot {
+    decodedFrames: number;
+    postedFrames: number;
+    closedFrames: number;
+    residentPeak: number;
+    workerMessages: number;
+}
+export declare function resetWebCodecsPerformanceSnapshot(): void;
+export declare function getWebCodecsPerformanceSnapshot(): WebCodecsPerformanceSnapshot;
 /**
  * Presentation-index → VideoFrame with bounded size.
  * Eviction follows the playhead (see {@link setPlaybackHint}) so we keep a window around the
@@ -11,6 +20,7 @@ export declare class VideoFrameRing {
     private playbackHint;
     constructor(maxSize: number);
     setPlaybackHint(idx: number): void;
+    private evictConsumedFrames;
     minKey(): number | undefined;
     set(idx: number, frame: VideoFrame): void;
     private evictDownToCapacity;
@@ -48,6 +58,8 @@ export declare class WebCodecsMp4Playback {
     private readonly timesSec;
     private readonly worker;
     private readonly workerMsgId;
+    /** Main-thread (no-Worker) counterpart of `worker`: same incremental pump, called in-process. */
+    private readonly mainThreadDecoder;
     private readonly streaming;
     private readonly ring;
     private readonly frames;
@@ -64,7 +76,19 @@ export declare class WebCodecsMp4Playback {
      */
     static create(source: string | ArrayBuffer, signal?: AbortSignal, opts?: WebCodecsMp4CreateOptions): Promise<WebCodecsMp4Playback>;
     private static createViaWorker;
+    /**
+     * Same incremental/backpressured decode as the Worker path (see `IncrementalH264Decoder`),
+     * called in-process instead of via `postMessage`. Bounds resident `VideoFrame`s to
+     * `maxDecodedFrames` via a `VideoFrameRing` instead of decoding the whole clip into a
+     * `VideoFrame[]` that stays fully resident for the playback's lifetime (P1-11) — the previous
+     * behavior made the main-thread fallback (used when Workers are unavailable or `useWorker:
+     * false`, typically the lowest-end devices) the worst case for decode-time memory peaks.
+     */
     private static createOnMainThread;
+    /** Send a `rewind` through whichever transport is active (Worker `postMessage` or in-process). */
+    private sendRewind;
+    /** Send an `ensure` through whichever transport is active (Worker `postMessage` or in-process). */
+    private sendEnsure;
     ensureDecodedThrough(tSec: number): void;
     getFrameForTime(tSec: number): VideoFrame | null;
     destroy(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taole/giftstage",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "High-performance WebGPU/WebGL gift animation player unifying SVGA, VAP, AlphaVideo, and images",
   "type": "module",
   "main": "dist/gift-stage.cjs.js",

package/dist/assets/webcodecs-mp4.worker-BvV8Fiyc.js

@@ -1,369 +0,0 @@
-let y = null;
-function v() {
-  return y || (y = import("./mp4box.all-Bcqr6y1c.js").catch((e) => {
-    throw y = null, e;
-  })), y;
-}
-const C = 800;
-function S(e) {
-  return e.startsWith("avc1") || e.startsWith("avc3");
-}
-function I(e) {
-  const t = new Uint8Array(e);
-  if (t.byteLength < 8) return e;
-  const n = t[4], r = t[5], o = t[6], i = t[7];
-  return n === 97 && r === 118 && o === 99 && i === 67 ? e.slice(8) : e;
-}
-async function F(e) {
-  const t = e.avcC;
-  if (!t) return;
-  const { DataStream: n } = await v(), r = new n();
-  t.write(r);
-  const o = r.byteLength;
-  if (o <= 0) return;
-  const i = r.buffer.slice(0, o);
-  return I(i);
-}
-async function P(e) {
-  const { createFile: t } = await v();
-  return new Promise((n, r) => {
-    const o = t(), i = e.slice(0);
-    i.fileStart = 0, o.onError = (d) => {
-      r(new Error(`mp4box: ${d}`));
-    }, o.onReady = (d) => {
-      var a, c, l, f, h, m, g;
-      const s = (a = d.videoTracks) == null ? void 0 : a[0];
-      if (!s) {
-        r(new Error("mp4box: no video track"));
-        return;
-      }
-      if (!S(s.codec)) {
-        r(new Error(`mp4box: unsupported video codec ${s.codec}`));
-        return;
-      }
-      if (s.nb_samples > C) {
-        r(new Error(`mp4box: too many samples (${s.nb_samples})`));
-        return;
-      }
-      const p = [];
-      o.onSamples = (q, B, k) => {
-        p.push(...k);
-      }, o.setExtractionOptions(s.id, null, {
-        nbSamples: Math.max(s.nb_samples, 1)
-      }), o.start();
-      const b = s.timescale > 0 ? s.duration / s.timescale : d.duration / (d.timescale || 1);
-      if (p.length === 0) {
-        r(new Error("mp4box: extraction produced no samples"));
-        return;
-      }
-      n({
-        codec: s.codec,
-        timescale: s.timescale,
-        durationSec: Number.isFinite(b) ? b : 0,
-        videoWidth: (f = (l = (c = s.video) == null ? void 0 : c.width) != null ? l : s.track_width) != null ? f : 0,
-        videoHeight: (g = (m = (h = s.video) == null ? void 0 : h.height) != null ? m : s.track_height) != null ? g : 0,
-        samples: p
-      });
-    }, o.appendBuffer(i), o.flush();
-  });
-}
-const x = 25e3;
-async function D(e, t, n) {
-  const r = performance.now();
-  let o = 0;
-  for (; e.decodeQueueSize > 0; )
-    if (await new Promise((i) => queueMicrotask(i)), o++, o % 120 === 0 && await new Promise((i) => setTimeout(i, 0)), performance.now() - r > n) {
-      console.warn("[GiftStage:WC] decodeQueue drain gave up", {
-        label: t,
-        decodeQueueSize: e.decodeQueueSize,
-        spins: o
-      });
-      break;
-    }
-}
-async function E(e, t) {
-  console.info("[GiftStage:WC] VideoDecoder.flush…", t);
-  try {
-    await Promise.race([
-      e.flush(),
-      new Promise((n, r) => {
-        setTimeout(
-          () => r(
-            new Error(
-              `VideoDecoder.flush() timed out after ${x}ms (${JSON.stringify(t)})`
-            )
-          ),
-          x
-        );
-      })
-    ]);
-  } catch (n) {
-    try {
-      e.close();
-    } catch (r) {
-    }
-    throw n;
-  }
-}
-function _(e, t, n) {
-  if (e.length === 0) return 0;
-  const r = e.length;
-  if (n <= e[0]) return 0;
-  const o = e[r - 1];
-  if (n >= t || n >= o) return r - 1;
-  let i = 0, d = r - 1;
-  for (; i + 1 < d; ) {
-    const a = i + d >>> 1;
-    e[a] <= n ? i = a : d = a;
-  }
-  return i;
-}
-function N(e, t) {
-  if (t.length === 0) return 1e-6;
-  const n = t.length, r = n - 1, o = t[r], i = n >= 2 ? t[r] - t[r - 1] : 1 / 30, d = o + i;
-  let a = e > 0 ? e : d;
-  if (!(a > 0) && n >= 2) {
-    const c = (t[n - 1] - t[0]) / (n - 1);
-    a = t[n - 1] + (c > 0 ? c : 1 / 30);
-  }
-  return a > 0 || (a = Math.max(d, 1 / 30)), a;
-}
-function T(e, t) {
-  var n, r;
-  if (e.length === 0) return new Float64Array(0);
-  const o = e.map((d, a) => a);
-  o.sort((d, a) => {
-    var c, l, f, h;
-    const m = e[d], g = e[a], s = (l = (c = m.cts) != null ? c : m.dts) != null ? l : 0, p = (h = (f = g.cts) != null ? f : g.dts) != null ? h : 0;
-    return s !== p ? s - p : d - a;
-  });
-  const i = new Float64Array(o.length);
-  for (let d = 0; d < o.length; d++) {
-    const a = e[o[d]];
-    i[d] = ((r = (n = a.cts) != null ? n : a.dts) != null ? r : 0) / t;
-  }
-  return i;
-}
-function O(e) {
-  return [...e].sort((t, n) => {
-    var r, o, i, d;
-    const a = ((o = (r = t.dts) != null ? r : t.cts) != null ? o : 0) - ((d = (i = n.dts) != null ? i : n.cts) != null ? d : 0);
-    return a !== 0 ? a : 0;
-  });
-}
-function W(e, t) {
-  if (e.length === 0) return 0;
-  const n = t / 1e6;
-  let r = 0, o = 1 / 0;
-  for (let i = 0; i < e.length; i++) {
-    const d = Math.abs(e[i] - n);
-    d < o && (o = d, r = i);
-  }
-  return r;
-}
-function A(e) {
-  for (let t = 0; t < e.length; t++)
-    if (e[t].is_sync) return t;
-  return 0;
-}
-async function V(e, t) {
-  var n;
-  const r = {
-    codec: e,
-    hardwareAcceleration: "prefer-software",
-    ...t && t.byteLength > 0 ? { description: t } : {}
-  };
-  let o = await VideoDecoder.isConfigSupported(r), i = r;
-  if (!o.supported) {
-    const d = {
-      codec: e,
-      ...t && t.byteLength > 0 ? { description: t } : {}
-    };
-    if (o = await VideoDecoder.isConfigSupported(d), !o.supported)
-      throw new Error(`WebCodecs: unsupported config ${e}`);
-    i = d;
-  }
-  return (n = o.config) != null ? n : i;
-}
-let u = null;
-self.onmessage = (e) => {
-  const t = e.data;
-  if (t) {
-    if (t.type === "init") {
-      H(t);
-      return;
-    }
-    if (!(!u || t.id !== u.id)) {
-      if (t.type === "ensure") {
-        u.targetNeedIdx = Math.max(u.targetNeedIdx, t.needIdx), w(u);
-        return;
-      }
-      if (t.type === "rewind") {
-        Q(u);
-        return;
-      }
-      t.type === "destroy" && M(u);
-    }
-  }
-};
-function M(e) {
-  if (e.destroyed = !0, e.decoder && e.decoder.state !== "closed")
-    try {
-      e.decoder.close();
-    } catch (t) {
-    }
-  e.decoder = null, u = null;
-}
-function w(e) {
-  e.pumpScheduled || e.destroyed || (e.pumpScheduled = !0, queueMicrotask(() => {
-    e.pumpScheduled = !1, U(e);
-  }));
-}
-async function H(e) {
-  u && M(u);
-  const t = e.id;
-  try {
-    const n = await P(e.buffer);
-    if (n.samples.length === 0) {
-      self.postMessage({ type: "error", id: t, message: "mp4box: no samples" });
-      return;
-    }
-    const r = O(n.samples), o = T(n.samples, n.timescale), i = N(n.durationSec, o), d = n.videoWidth || 0, a = n.videoHeight || 0, c = new Float64Array(o.length);
-    c.set(o), self.postMessage(
-      {
-        type: "meta",
-        id: t,
-        duration: i,
-        videoWidth: d,
-        videoHeight: a,
-        frameCount: o.length,
-        timesSec: c
-      },
-      { transfer: [c.buffer] }
-    );
-    const l = _(o, i, 0), f = Math.min(
-      o.length - 1,
-      Math.max(0, l + Math.max(0, e.decodeAheadFrames))
-    );
-    u = {
-      id: t,
-      destroyed: !1,
-      decodeOrder: r,
-      presTimes: o,
-      timescale: n.timescale,
-      codec: n.codec,
-      description: n.samples[0] ? await F(
-        n.samples[0].description
-      ) : void 0,
-      duration: i,
-      videoWidth: d,
-      videoHeight: a,
-      decoder: null,
-      nextChunk: 0,
-      chunksFed: 0,
-      targetNeedIdx: f,
-      lastPostedMax: -1,
-      minPosted: Number.POSITIVE_INFINITY,
-      playbackNeedFloor: l,
-      eosClosed: !1,
-      pumpScheduled: !1,
-      pumping: !1
-    }, w(u);
-  } catch (n) {
-    self.postMessage({
-      type: "error",
-      id: t,
-      message: n instanceof Error ? n.message : String(n)
-    });
-  }
-}
-async function L(e) {
-  if (e.decoder && e.decoder.state !== "closed") return;
-  const t = await V(e.codec, e.description), n = new VideoDecoder({
-    output: (r) => {
-      if (e.destroyed) {
-        try {
-          r.close();
-        } catch (i) {
-        }
-        return;
-      }
-      const o = W(e.presTimes, r.timestamp);
-      e.lastPostedMax = Math.max(e.lastPostedMax, o), e.minPosted = Math.min(e.minPosted, o), self.postMessage({ type: "frame", id: e.id, index: o, frame: r }, { transfer: [r] });
-    },
-    error: (r) => {
-      console.error("[GiftStage:WC] worker VideoDecoder error", r);
-    }
-  });
-  n.configure(t), e.decoder = n;
-}
-async function Q(e) {
-  if (e.destroyed) return;
-  if (e.decoder && e.decoder.state !== "closed")
-    try {
-      e.decoder.close();
-    } catch (n) {
-    }
-  e.decoder = null, e.nextChunk = A(e.decodeOrder), e.chunksFed = 0, e.lastPostedMax = -1, e.minPosted = Number.POSITIVE_INFINITY, e.eosClosed = !1;
-  const t = _(e.presTimes, e.duration, 0);
-  e.playbackNeedFloor = t, e.targetNeedIdx = Math.max(
-    e.targetNeedIdx,
-    Math.min(e.presTimes.length - 1, Math.max(0, t))
-  ), w(e);
-}
-function $(e) {
-  var t, n;
-  const r = e.decoder, o = e.nextChunk;
-  if (o >= e.decodeOrder.length) return;
-  const i = e.decodeOrder[o];
-  e.nextChunk = o + 1;
-  const d = i.data;
-  if (!d || d.byteLength === 0) return;
-  const a = (n = (t = i.cts) != null ? t : i.dts) != null ? n : 0, c = Math.round(a / e.timescale * 1e6), l = i.duration && e.timescale > 0 ? Math.round(i.duration / e.timescale * 1e6) : void 0, f = new Uint8Array(d.byteLength);
-  f.set(d);
-  const h = new EncodedVideoChunk({
-    type: i.is_sync ? "key" : "delta",
-    timestamp: c,
-    duration: l,
-    data: f
-  });
-  r.decode(h), e.chunksFed++;
-}
-async function z(e) {
-  if (!e.decoder || e.eosClosed) return;
-  const t = e.decoder;
-  await D(t, "before flush", 1e4);
-  const n = t.decodeQueueSize;
-  await E(t, {
-    chunksDecoded: e.chunksFed,
-    outputsBeforeFlush: e.lastPostedMax + 1,
-    queueBeforeFlush: n
-  });
-  try {
-    t.close();
-  } catch (r) {
-  }
-  e.decoder = null, e.eosClosed = !0, self.postMessage({ type: "eos", id: e.id });
-}
-async function U(e) {
-  if (!e.destroyed && !e.pumping) {
-    e.pumping = !0;
-    try {
-      for (; !e.destroyed; ) {
-        if (e.eosClosed)
-          return;
-        const t = e.nextChunk < e.decodeOrder.length, n = Number.isFinite(e.minPosted) && e.minPosted <= e.playbackNeedFloor, r = e.lastPostedMax < e.targetNeedIdx || !n;
-        if (!t && !e.eosClosed) {
-          await z(e);
-          continue;
-        }
-        if (!r && t || !r && !t)
-          return;
-        await L(e), $(e), e.chunksFed % 4 === 0 && await new Promise((o) => setTimeout(o, 0));
-      }
-    } finally {
-      e.pumping = !1;
-    }
-  }
-}
-//# sourceMappingURL=webcodecs-mp4.worker-BvV8Fiyc.js.map