@taole/giftstage 0.1.32 → 0.1.33

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

@@ -20,7 +20,9 @@ export declare class WebGL1Backend implements GPUBackend {
     init(): Promise<void>;
     private initPrograms;
     private getUniforms;
-    beginFrame(): void;
+    beginFrame(options?: {
+        stencil?: boolean;
+    }): void;
     endFrame(): void;
     private getBufferSourceByteLength;
     private normalizeIndexSource;

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

@@ -35,7 +35,9 @@ export declare class WebGL2Backend implements GPUBackend {
     init(): Promise<void>;
     private initPrograms;
     private getUniforms;
-    beginFrame(): void;
+    beginFrame(options?: {
+        stencil?: boolean;
+    }): void;
     endFrame(): void;
     private getBufferSourceByteLength;
     createBuffer(data: GPUBufferSource, usage: BufferUsage): GPUBufferHandle;

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

@@ -20,6 +20,7 @@ export declare class WebGPUBackend implements GPUBackend {
     private texturedBindGroupLayout;
     private dualTexturedBindGroupLayout;
     private instancedTextureBindGroupLayout;
+    private uniformOnlyBindGroupLayout;
     /** `device.limits.minUniformBufferOffsetAlignment` (typically 256). */
     private uniformSlotStride;
     /** Ring size for per-draw uniforms (`queue.writeBuffer` must not overwrite before draw — see `draw()`). */
@@ -29,6 +30,7 @@ export declare class WebGPUBackend implements GPUBackend {
     /** Skip redundant `setPipeline` / stencil / VB-IB when drawing many quads with the same geometry. */
     private lastDrawPipeline;
     private lastStencilRef;
+    private frameUsesStencil;
     private lastVertexBufferId;
     private lastIndexBufferId;
     /** Single 160-byte upload for textured draws (replaces multiple `writeBuffer` calls). */
@@ -98,8 +100,9 @@ export declare class WebGPUBackend implements GPUBackend {
     constructor(canvas: HTMLCanvasElement, adapter: GPUAdapter, wantAntialias?: boolean);
     init(): Promise<void>;
     private configureCanvasContext;
-    private ensureDepthStencil;
+    private ensureFrameAttachments;
     private initPipelines;
+    private ensureStencilPipelines;
     private ensureInstancedProjectionBuffer;
     private ensureInstancedStorageBuffer;
     private ensureInstancedSvgaPipeline;
@@ -110,7 +113,9 @@ export declare class WebGPUBackend implements GPUBackend {
     private createInstancedAlphaVideoPipeline;
     private createTexturedPipeline;
     private createClipMaskPipeline;
-    beginFrame(): void;
+    beginFrame(options?: {
+        stencil?: boolean;
+    }): void;
     endFrame(): void;
     private ensureInstancedProjection;
     private gpuBufferUsage;

package/dist/renderers/alpha-video-renderer.d.ts

@@ -18,6 +18,7 @@ export declare class AlphaVideoRenderer {
     private readonly processedHtmlGatesScratch;
     private readonly instancedTexturesScratch;
     private readonly instancedUniformsScratch;
+    constructor(onHtmlVideoFrame?: (video: HTMLVideoElement) => void);
     private readonly instancedDrawCommand;
     private readonly geometryTexturesScratch;
     private readonly geometryUniformsScratch;

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

@@ -63,11 +63,15 @@ export declare class SVGABatchRenderer {
     private drawGroupScratch;
     /** 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. */
+    private entityFrameClipModeCache;
     private readonly affineScratch;
     beginFrame(backend: GPUBackend): void;
     flush(backend: GPUBackend, slots: Map<string, GiftSlot>): void;
     drawSlot(backend: GPUBackend, slot: GiftSlot): void;
     drawSlots(backend: GPUBackend, slots: Iterable<GiftSlot>): void;
+    requiresStencil(slots: Iterable<GiftSlot>): boolean;
+    private getFrameClipMode;
     prewarmClipMeshes(entity: Pick<VideoEntity, 'spriteTable'>, options?: SVGAClipPrewarmOptions): Promise<number>;
     hydrateClipMeshes(meshes: SVGAClipMeshMap | null | undefined): void;
     snapshotClipMeshes(entity: Pick<VideoEntity, 'spriteTable'>): SVGAClipMeshMap;

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

@@ -17,6 +17,7 @@ export declare class VAPRenderer {
     private scratchTransform;
     private readonly processedHtmlGatesScratch;
     private readonly vapVertexScratch;
+    constructor(onHtmlVideoFrame?: (video: HTMLVideoElement) => void);
     private projCacheW;
     private projCacheH;
     private projCache;

package/dist/types/index.d.ts

@@ -62,7 +62,9 @@ export interface GPUBackend {
     /** Maximum supported 2D texture dimension for this backend/device. */
     readonly maxTextureSize?: number;
     init(): Promise<void>;
-    beginFrame(): void;
+    beginFrame(options?: {
+        stencil?: boolean;
+    }): void;
     endFrame(): void;
     createBuffer(data: GPUBufferSource, usage: BufferUsage): GPUBufferHandle;
     updateBuffer(handle: GPUBufferHandle, data: GPUBufferSource, offset?: number): void;
@@ -318,9 +320,9 @@ export interface GiftStageOptions {
     } | false;
     /**
      * Edge smoothing: WebGL2 uses the context multisampled framebuffer; WebGPU uses 4× MSAA + resolve.
-     * Default: **true** for WebGL2, **false** for WebGPU (MSAA is expensive with large transparent-video fills).
-     * Set `true` explicitly when using WebGPU + sharp SVGA edges.
-     * Many concurrent transparent videos: keep WebGPU `antialias` off (default) and consider lowering {@link resolution}.
+     * Default: **true** for WebGL2 and WebGPU.
+     * Many concurrent transparent videos: consider setting `antialias: false` and lowering {@link resolution}
+     * when fill-rate or framebuffer bandwidth becomes the bottleneck.
      */
     antialias?: boolean;
     /**

package/dist/utils/html-video-upload-gate.d.ts

@@ -4,6 +4,7 @@
  * when many `<video>` elements run together (especially with WebGPU texture copies).
  */
 export declare class HtmlVideoUploadGate {
+    private readonly onFrameAvailable?;
     private readonly frameInfo;
     private readonly pending;
     private readonly lastHandle;
@@ -18,12 +19,16 @@ export declare class HtmlVideoUploadGate {
     private readonly stagnationLogged;
     /** When `requestVideoFrameCallback` is missing, fall back to `currentTime` changes (coarser than rVFC). */
     private readonly lastTimeFallback;
+    /** Low-frequency wake-up used to detect browsers that stop delivering rVFC callbacks. */
+    private readonly healthTimers;
+    constructor(onFrameAvailable?: (video: HTMLVideoElement) => void);
     /**
      * Returns true when `updateTexture` should run for this slot: first time, or a new decoded frame was signaled.
      */
     preUpload(slotId: string, video: HTMLVideoElement): boolean;
     getFrameInfo(slotId: string): VideoFrameCallbackMetadata | undefined;
     private ensureRvf;
+    private ensureHealthTimer;
     private consumeTimeAdvance;
     private markProgress;
     private tryRecoverStalledPlayback;

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

@@ -1,6 +1,52 @@
 import type { SVGAWorkerMoviePayload } from '../parsers/svga-parser-worker-client';
 type PersistKind = 'arrayBuffer' | 'text';
 type MemoryKind = PersistKind | 'json' | 'svga-payload' | 'svga-asset';
+export declare class AsyncLimiter {
+    private maxConcurrent;
+    private active;
+    private queue;
+    constructor(maxConcurrent: number);
+    setMaxConcurrent(maxConcurrent: number): void;
+    run<T>(task: () => Promise<T>): Promise<T>;
+    private drain;
+}
+export declare class ResourceCacheManager {
+    private readonly limiter;
+    private readonly pending;
+    private readonly memory;
+    private memoryBytes;
+    private maxMemoryBytes;
+    private maxPersistentBytes;
+    private dbPromise;
+    private persistentTrimPromise;
+    configure(opts?: {
+        maxConcurrent?: number;
+        maxMemoryBytes?: number;
+        maxPersistentBytes?: number;
+    }): void;
+    runLimited<T>(task: () => Promise<T>): Promise<T>;
+    fetchArrayBuffer(url: string, signal?: AbortSignal): Promise<ArrayBuffer>;
+    fetchText(url: string, signal?: AbortSignal): Promise<string>;
+    fetchJSON<T>(url: string, signal?: AbortSignal): Promise<T>;
+    getSVGAWorkerPayload(cacheKey: string): SVGAWorkerMoviePayload | null;
+    setSVGAWorkerPayload(cacheKey: string, payload: SVGAWorkerMoviePayload): void;
+    getMemoryValue<T>(key: string, kind: MemoryKind): T | null;
+    setMemoryValue<T>(key: string, kind: MemoryKind, value: T, size: number): void;
+    getPersistedArrayBuffer(key: string): Promise<ArrayBuffer | null>;
+    setPersistedArrayBuffer(key: string, value: ArrayBuffer): Promise<void>;
+    deletePersistedValue(key: string): Promise<void>;
+    private getOrCreatePending;
+    private getMemory;
+    private setMemory;
+    private trimMemory;
+    private openDb;
+    private getPersistent;
+    private setPersistent;
+    private touchPersistent;
+    private schedulePersistentTrim;
+    private trimPersistent;
+    private deletePersistent;
+}
 export declare function configureResourceCache(opts?: {
     maxConcurrent?: number;
     maxMemoryBytes?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taole/giftstage",
-  "version": "0.1.32",
+  "version": "0.1.33",
   "description": "High-performance WebGPU/WebGL gift animation player unifying SVGA, VAP, AlphaVideo, and images",
   "type": "module",
   "main": "dist/gift-stage.cjs.js",
@@ -33,6 +33,8 @@
     "test:watch": "vitest",
     "test:browser": "vitest run --browser.enabled --browser.name=chromium",
     "test:e2e": "playwright test",
+    "test:perf": "node scripts/run-performance.mjs",
+    "perf:record": "node scripts/run-performance.mjs --record",
     "lint": "eslint src/ tests/",
     "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
     "typecheck": "tsc --noEmit",
@@ -46,6 +48,7 @@
     "@vitest/browser": "^3.0.0",
     "@webgpu/types": "^0.1.69",
     "eslint": "^9.0.0",
+    "fake-indexeddb": "^6.2.5",
     "jsdom": "^24.1.3",
     "playwright": "^1.50.0",
     "prettier": "^3.4.0",