@taole/giftstage 0.1.34 → 0.1.36

package/dist/gpu/webgl2-backend.d.ts

@@ -22,8 +22,16 @@ export declare class WebGL2Backend implements GPUBackend {
     private videoElementDirectUploadValidated;
     /** DYNAMIC_DRAW upload target for `svga-instanced-premul` (`FrameJobData` per instance). */
     private static readonly INST_SVGA_GL_MAX;
+    private static readonly INST_SVGA_GL_FLOATS;
+    private static readonly INST_SVGA_GL_STRIDE;
     private static readonly INST_SVGA_GL_BYTES;
     private instancedSvgaInstanceGLBuffer;
+    /** DYNAMIC_DRAW upload target for instanced clip-mask affine transforms. */
+    private static readonly INST_CLIP_MASK_GL_MAX;
+    private static readonly INST_CLIP_MASK_GL_FLOATS;
+    private static readonly INST_CLIP_MASK_GL_STRIDE;
+    private static readonly INST_CLIP_MASK_GL_BYTES;
+    private instancedClipMaskGLBuffer;
     /** DYNAMIC_DRAW upload target for `alpha-video-instanced` (rect+atlasRemap+opacity per instance). */
     private static readonly INST_ALPHA_GL_MAX;
     private static readonly INST_ALPHA_GL_BYTES;
@@ -81,6 +89,8 @@ export declare class WebGL2Backend implements GPUBackend {
     private deleteAllVertexArrays;
     private ensureInstancedSvgaInstanceBuffer;
     private drawInstancedSvgaGL;
+    private ensureInstancedClipMaskBuffer;
+    private drawInstancedClipMaskGL;
     private ensureInstancedAlphaInstanceBuffer;
     private drawInstancedAlphaGL;
     private ensureInstancedVapInstanceBuffer;

package/dist/gpu/webgpu-backend.d.ts

@@ -85,18 +85,16 @@ export declare class WebGPUBackend implements GPUBackend {
     private dualTexturedBindGroupCache;
     /** All instanced pipelines also share one texture layout. */
     private instancedTextureBindGroupCache;
-    /** Batched SVGA sprites (FrameJobData packed as 13 floats per instance). */
+    /** Batched SVGA sprites (pre-scaled affine, UVs, and packed framebuffer clip rect). */
     private static readonly SVGA_INSTANCED_MAX;
     private static readonly SVGA_INSTANCED_STRIDE;
+    private static readonly CLIP_MASK_INSTANCED_MAX;
+    private static readonly CLIP_MASK_INSTANCED_STRIDE;
     /** Batched alpha-video (storage instances + projection uniform). */
     private static readonly ALPHA_INSTANCED_MAX;
     private static readonly ALPHA_INSTANCED_STRIDE;
     private static readonly VAP_INSTANCED_MAX;
     private static readonly VAP_INSTANCED_STRIDE;
-    /** One draw may bind up to this many bytes of instance storage (max instances × stride). */
-    private static readonly INSTANCED_SVGA_CHUNK_BYTES;
-    private static readonly INSTANCED_ALPHA_CHUNK_BYTES;
-    private static readonly INSTANCED_VAP_CHUNK_BYTES;
     /**
      * Multiple `queue.writeBuffer(..., offset 0)` to the same storage buffer before one `submit` only keep the
      * last write; one shared ring + dynamic offsets keeps all instanced paths non-overlapping until submit.
@@ -107,9 +105,19 @@ export declare class WebGPUBackend implements GPUBackend {
     private storageBindOffsetAlign;
     /** Reset in `beginFrame`; all instanced draw types reserve non-overlapping chunks. */
     private instancedStorageRingOffset;
+    /** Grow-only CPU mirror; expands to the frame's actual storage high-water mark. */
+    private instancedStorageShadow;
+    private instancedStorageShadowDirtyMax;
     private readonly instancedProjectionCache;
     private instancedProjectionValid;
+    /** Storage range written by the latest instanced clip-mask write pass; reused by its clear. */
+    private lastClipMaskStorageBase;
+    private lastClipMaskStorageByteLength;
     private lastInstancedTextureBindGroup;
+    private performanceBufferWrites;
+    private performanceBufferWriteBytes;
+    private performanceStorageBufferWrites;
+    private performanceStorageBufferWriteBytes;
     constructor(canvas: HTMLCanvasElement, adapter: GPUAdapter, wantAntialias?: boolean);
     init(): Promise<void>;
     private configureCanvasContext;
@@ -118,10 +126,13 @@ export declare class WebGPUBackend implements GPUBackend {
     private ensureStencilPipelines;
     private ensureInstancedProjectionBuffer;
     private ensureInstancedStorageBuffer;
+    private ensureInstancedDataBindGroup;
     private ensureInstancedSvgaPipeline;
+    private ensureInstancedClipMaskPipeline;
     private ensureInstancedAlphaPipeline;
     private ensureInstancedVapPipeline;
     private createInstancedSvgaPipeline;
+    private createInstancedClipMaskPipeline;
     private createVapInstancedPipeline;
     private createInstancedAlphaVideoPipeline;
     private createTexturedPipeline;
@@ -130,8 +141,19 @@ export declare class WebGPUBackend implements GPUBackend {
         stencil?: boolean;
     }): void;
     endFrame(): void;
+    getPerformanceSnapshot(): {
+        bufferWrites: number;
+        bufferWriteBytes: number;
+        storageBufferWrites: number;
+        storageBufferWriteBytes: number;
+    };
+    resetPerformanceSnapshot(): void;
+    private writeBuffer;
     /** Uploads the touched range of `uniformShadow` in one call — must run before `queue.submit`. */
     private flushUniformShadow;
+    /** Uploads every instanced draw's non-overlapping shadow range in one call before submit. */
+    private flushInstancedStorageShadow;
+    private writeInstancedStorageShadow;
     /** Records a per-draw uniform write into the CPU shadow instead of touching the GPU buffer. */
     private writeUniformShadow;
     private ensureInstancedProjection;
@@ -167,6 +189,7 @@ export declare class WebGPUBackend implements GPUBackend {
     draw(cmd: DrawCommand): void;
     /** One `drawIndexed` with `instanceCount` for all SVGA sprites sharing the same atlas. */
     private drawInstancedSvga;
+    private drawInstancedClipMask;
     /** One `drawIndexed` with `instanceCount` for all gifts sharing the same video texture (e.g. atlas). */
     private drawInstancedAlpha;
     private drawInstancedVap;

package/dist/parsers/svga-sprite-table.d.ts

@@ -2,7 +2,7 @@
  * SVGA sprite SoA table: flat frame floats + deduped clip/shapes side tables.
  * Replaces per-sprite `frames: SVGAFrame[]` object graphs on the hot path.
  */
-import type { SVGAShape, SVGATransform } from '../types';
+import type { SVGAParams, SVGAShape, SVGATransform } from '../types';
 /** Floats per frame in `frameData`: layoutW, layoutH, a, b, c, d, tx, ty, alpha. */
 export declare const SPRITE_FRAME_FLOATS = 9;
 export interface SVGASpriteTable {
@@ -20,6 +20,7 @@ export interface SVGASpriteTable {
     /** spriteCount × frameCount; -1 = none. */
     shapesIndex: Int32Array;
     hasAnyShapes: boolean;
+    allFramesInsideViewBox?: boolean;
 }
 /** Loose frame shape used when converting from AoS decode (JS proto / fixtures). */
 export interface SVGAFrameLike {
@@ -55,5 +56,10 @@ export declare function getSpriteClipPath(table: SVGASpriteTable, spriteIndex: n
  * Resolves shape `keep` chains to shared array references.
  */
 export declare function spriteTableFromSprites(sprites: SVGASpriteLike[], frameCountHint?: number): SVGASpriteTable;
+/**
+ * Compute the renderer's scissor-elision flag before the entity becomes renderable. Shapes are
+ * conservative because their geometry is not represented by the sprite layout rectangle.
+ */
+export declare function ensureAllFramesInsideViewBox(params: Pick<SVGAParams, 'viewBoxWidth' | 'viewBoxHeight'>, table: SVGASpriteTable): boolean;
 /** Empty table used when there are no sprites. */
 export declare function emptySpriteTable(frameCount?: number): SVGASpriteTable;

package/dist/parsers/vap-config-parser.d.ts

@@ -1,20 +1,22 @@
 import type { VAPConfig, VAPFrameItem } from '../types';
 export declare function parseVAPConfig(config: string | object): Promise<VAPConfig>;
 export declare function getVAPFrame(config: VAPConfig, frameIndex: number): VAPFrameItem | undefined;
-/**
- * Logical content size for layout/aspect (matches visible RGB frame, not full mp4 frame).
- * `videoW`/`videoH` often include separate alpha bands; use `w`/`h` or `rgbFrame` w×h.
- */
-export declare function getVAPContentSize(info: VAPConfig['info']): {
+export interface VAPContentSize {
     w: number;
     h: number;
-};
+}
 /**
- * Compute normalized UV coordinates for a frame region within the video texture.
+ * Logical content size for layout/aspect (matches visible RGB frame, not full mp4 frame).
+ * `videoW`/`videoH` often include separate alpha bands; use `w`/`h` or `rgbFrame` w×h.
  */
-export declare function computeVAPUV(region: [number, number, number, number], videoW: number, videoH: number): {
+export declare function getVAPContentSize(info: VAPConfig['info'], out?: VAPContentSize): VAPContentSize;
+export interface VAPUVRect {
     left: number;
     right: number;
     top: number;
     bottom: number;
-};
+}
+/**
+ * Compute normalized UV coordinates for a frame region within the video texture.
+ */
+export declare function computeVAPUV(region: [number, number, number, number], videoW: number, videoH: number, out?: VAPUVRect): VAPUVRect;

package/dist/renderers/image-renderer.d.ts

@@ -8,6 +8,9 @@ export declare class ImageRenderer {
     private projCacheW;
     private projCacheH;
     private projCache;
+    private readonly texturesScratch;
+    private readonly uniformsScratch;
+    private readonly drawCommand;
     private static readonly QUAD_VERTS;
     private static readonly QUAD_INDICES;
     drawSlot(backend: GPUBackend, slot: GiftSlot): void;

package/dist/renderers/svga-batch-renderer.d.ts

@@ -12,6 +12,13 @@ export interface ClipMeshCache {
         w: number;
         h: number;
     } | null;
+    /** Local-space bounds cached for conservative instanced stencil safety checks. */
+    bounds?: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
     /** Lazily created static GPU buffers (local-space vertices, transformed via u_transform). */
     vertexBuf?: GPUBufferHandle | null;
     indexBuf?: GPUBufferHandle | null;
@@ -59,8 +66,10 @@ export declare class SVGABatchRenderer {
      * back — each captured entry clones out of it immediately via `.slice()`. */
     private staticBatchCacheRowScratch;
     private instancedFrameDataScratch;
+    private instancedFrameDataWords;
     private clipSpriteVertsScratch;
     private clipSpriteIndicesScratch;
+    private clipMaskBatchTransformsScratch;
     private instancedQuadVB;
     private instancedQuadIB;
     private whiteTexture;
@@ -73,10 +82,14 @@ export declare class SVGABatchRenderer {
     private shapeTransformMat;
     /** Scissor rect of the slot currently being drawn (canvas pixels), for clip intersection/restore. */
     private slotScissor;
+    private slotClipX0;
+    private slotClipY0;
+    private slotClipX1;
+    private slotClipY1;
     /**
      * Whether `slotScissor` is currently the *active* GPU scissor rect (vs. the outer scissor
      * having been intentionally skipped for a slot that cannot draw outside its own box — see
-     * `allFramesInsideViewBox`). Drives `restoreSlotScissor`'s fallback target.
+     * `spriteTable.allFramesInsideViewBox`). Drives `restoreSlotScissor`'s fallback target.
      */
     private slotScissorActive;
     /**
@@ -92,6 +105,10 @@ export declare class SVGABatchRenderer {
     /** Reused scratch arrays (consumed synchronously). */
     private batchSpritesScratch;
     private drawGroupScratch;
+    private sharedSlotLayerWorkPool;
+    private sharedSlotLayerWorksScratch;
+    private clipLayerBatchPool;
+    private clipLayerBatchesScratch;
     /** Per-entity result of the "any frame has shapes" scan (no-atlas render check). */
     private entityHasShapesCache;
     /** 0=no clip, 1=scissor-compatible clips only, 2=stencil required, 255=not analyzed. */
@@ -103,15 +120,6 @@ export declare class SVGABatchRenderer {
      * resolution always goes through `getClipMesh`'s string cache, so array entries never go stale.
      */
     private entityClipMeshArrayCache;
-    /**
-     * Per-entity result of scanning every sprite×frame layout AABB (in local viewBox space) to see
-     * whether it ever draws outside the entity's own viewBox. Entities with vector shapes are
-     * excluded (`false`) since shape geometry isn't covered by this scan. Used by `flushGroup` to
-     * skip the redundant outer scissor for contain/fill, non-rotated slots — such slots structurally
-     * cannot paint outside their own box, so consecutive same-atlas slots can share one scissor-free
-     * batch run instead of forcing a draw call per slot.
-     */
-    private entityAllFramesInsideViewBoxCache;
     private readonly affineScratch;
     /**
      * Reused DrawCommand/uniforms/textures per rendering branch (never allocated per draw).
@@ -142,6 +150,8 @@ export declare class SVGABatchRenderer {
     private readonly clipMaskTexturesScratch;
     private readonly clipMaskUniformsScratch;
     private readonly clipMaskDrawCommand;
+    private readonly clipMaskInstancedUniformsScratch;
+    private readonly clipMaskInstancedDrawCommand;
     /**
      * `drawShapeFrame`'s fill/stroke draw (always the shared white texture). `u_transform`
      * carries the per-frame sprite x slot transform so the static shape mesh stays on the GPU;
@@ -155,8 +165,17 @@ export declare class SVGABatchRenderer {
     drawSlot(backend: GPUBackend, slot: GiftSlot): void;
     drawSlots(backend: GPUBackend, slots: Iterable<GiftSlot>): void;
     requiresStencil(slots: Iterable<GiftSlot>): boolean;
+    /**
+     * Returns the target frame only when every clip path referenced by its visible sprites has a
+     * resolved cache entry. A miss queues background triangulation and keeps the previous complete
+     * frame on screen, preventing a partially built frame from being drawn without clipping.
+     */
+    private resolveRenderableFrame;
+    private isFrameClipReady;
     private getFrameClipMode;
     prewarmClipMeshes(entity: Pick<VideoEntity, 'spriteTable'>, options?: SVGAClipPrewarmOptions): Promise<number>;
+    prewarmClipMeshesForFrame(entity: Pick<VideoEntity, 'spriteTable'>, frame: number, options?: SVGAClipPrewarmOptions): Promise<number>;
+    private collectFrameClipPaths;
     /** Builds every not-yet-cached path in `paths`, worker-first with a frame-budgeted fallback. */
     private buildMissingClipMeshes;
     /**
@@ -171,6 +190,17 @@ export declare class SVGABatchRenderer {
     hydrateClipMeshes(meshes: SVGAClipMeshMap | null | undefined): void;
     snapshotClipMeshes(entity: Pick<VideoEntity, 'spriteTable'>): SVGAClipMeshMap;
     private flushGroup;
+    /**
+     * Transposes disjoint slots sharing one entity into sprite layers. Reordering across slots is
+     * safe because their outer clip bounds do not overlap; order within every slot remains sprite
+     * index order. Non-rect clips sharing one mesh become write -> instanced test -> clear.
+     */
+    private tryFlushDisjointSharedEntityLayers;
+    private resetClipLayerBatches;
+    private acquireClipLayerBatch;
+    private resolveClipTransform;
+    private intersectWorkClipRect;
+    private drawBatchedClipLayer;
     private acquireSpriteWork;
     /**
      * Like `acquireSpriteWork`, but for a P1-10 static batch cache replay entry: only `handle` and
@@ -178,6 +208,8 @@ export declare class SVGABatchRenderer {
      * call only reads `work.handle`.
      */
     private acquireCachedSpriteWork;
+    private updateSlotClipBounds;
+    private copyCurrentSlotClipToWork;
     /** Drop object references so removed slots/entities are not retained by the pool. */
     private releaseSpriteWorks;
     /** Snapshot check for a P1-10 static batch cache: any mismatch means rebuild, never a stale hit. */
@@ -201,12 +233,16 @@ export declare class SVGABatchRenderer {
     private applyClipRectScissor;
     private restoreSlotScissor;
     private getClipRect;
+    private getClipMeshBounds;
     private ensureClipMeshBuffers;
     private packClipTransform;
     private drawSingleSprite;
     private clearClipStencil;
     private rotateTransform;
     private packFrameData;
+    private packInstancedFrameData;
+    private packClipCoordinatePair;
+    private packFrameDataAt;
     /** Resolve atlas/override texture into a pooled SpriteWork entry. Returns false when missing. */
     private resolveSpriteTextureInto;
     private drawShapeFrame;
@@ -219,14 +255,6 @@ export declare class SVGABatchRenderer {
     private packShapeTransform;
     private hasAtlasTexture;
     private hasRenderableSVGA;
-    /**
-     * True when every sprite frame's transformed layout rect stays within the entity's own
-     * viewBox (with a small epsilon for float error). Computed once per entity and cached — the
-     * scan touches every sprite×frame combination, which is only affordable as a one-time cost.
-     * Entities with vector shapes always return `false`: shape geometry has its own coordinate
-     * system that this scan does not cover, so we conservatively keep per-slot scissoring for them.
-     */
-    private allFramesInsideViewBox;
     private getWhiteTexture;
     private getShapeMesh;
     private appendShape;

package/dist/renderers/vap-renderer.d.ts

@@ -15,6 +15,10 @@ export declare class VAPRenderer {
     private readonly scratchAtlasRemap;
     private instancePackScratch;
     private scratchTransform;
+    private readonly contentSizeScratch;
+    private readonly rgbUVScratch;
+    private readonly alphaUVScratch;
+    private readonly maskUVScratch;
     private readonly processedHtmlGatesScratch;
     private readonly vapVertexScratch;
     private readonly layoutScratch;

package/dist/shaders/index.d.ts

@@ -35,6 +35,10 @@ export declare const glsl: {
         readonly vert: string;
         readonly frag: string;
     };
+    readonly clipMaskInstanced: {
+        readonly vert: string;
+        readonly frag: string;
+    };
 };
 export declare const wgsl: {
     readonly svgaBatchPremul: string;
@@ -46,4 +50,5 @@ export declare const wgsl: {
     readonly alphaVideoInstanced: string;
     readonly rgbaTextured: string;
     readonly clipMask: string;
+    readonly clipMaskInstanced: string;
 };

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;
@@ -607,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. */

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

@@ -34,6 +34,8 @@ export declare function decodeH264ToFrames(codec: string, description: ArrayBuff
 }>;
 export interface IncrementalH264DecoderCallbacks {
     onFrame: (index: number, frame: VideoFrame) => void;
+    onDecoded?: () => void;
+    onDropped?: () => void;
     onEos?: () => void;
     onError?: (error: unknown) => void;
 }
@@ -61,11 +63,13 @@ export declare class IncrementalH264Decoder {
     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;

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;

package/package.json

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