@taole/giftstage 0.3.3 → 0.3.5

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

@@ -144,6 +144,7 @@ export declare class WebGL2Backend implements GPUBackend {
     private recordSubmittedDraw;
     private rejectSVGAFastPathDraw;
     private initPrograms;
+    prepareParticleSpritePipelines(): void;
     private ensureParticleSpriteProgram;
     private makeProgramEntry;
     /**

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

@@ -57,6 +57,8 @@ export declare class WebGPUBackend implements GPUBackend {
     private buffers;
     private textures;
     private pipelines;
+    private particleSpritePreparations;
+    private particleSpritePreparationEpoch;
     private sampler;
     private uniformBuffer;
     private texturedBindGroupLayout;
@@ -214,7 +216,9 @@ export declare class WebGPUBackend implements GPUBackend {
     private ensureSVGAFrameTableMeshPipeline;
     private ensureMotionSvgaPipeline;
     private ensureParticlePipeline;
+    prepareParticleSpritePipelines(): Promise<void>;
     private ensureParticleSpritePipeline;
+    private particleSpritePipelineDescriptor;
     private createInstancedSvgaPipeline;
     private createInstancedClipMaskPipeline;
     private createVapInstancedPipeline;

package/dist/index.d.ts

@@ -34,3 +34,4 @@ export { WebCodecsMp4Playback } from './video/webcodecs-mp4-playback.js';
 export type { WebCodecsMp4CreateOptions } from './video/webcodecs-mp4-playback.js';
 export type { WebCodecsPlaybackHandle, GPUBackend, BackendOperationFailureReason, BackendOperationResult, GPUBufferHandle, GPUTextureHandle, TextureOpts, BufferUsage, DrawCommand, ShaderType, BackendType, ParentMotionMode, SVGADrawBatchMode, SVGAFrameEvaluation, SVGAFrameEvaluationStrategy, SVGAFrameTableBinding, SVGAFrameTableBindingBase, SVGAFrameTableCreateOptions, SVGAFrameTableState, SVGAFrameTimelineFallbackReason, SVGAFrameTimelinePath, SVGAFrameTimelineRenderInfo, SVGAFrameTimelineStrategy, SVGAFrameTimelineTransport, SVGARenderFallbackReason, SVGARenderInfo, SVGARenderPath, SVGARenderPathState, SVGARenderPathChangeInfo, GiftStageRuntimeDiagnosticType, GiftStageRuntimeDiagnosticEvent, GiftStageRuntimeDiagnostics, SVGAHybridCommandTable, SVGAHybridOperation, SVGAHybridOperationType, SVGATimelineDrawRun, WebGL2FrameTableBinding, WebGPUFrameTableBinding, GiftStageOptions, AddGiftOptions, GiftHandle, GiftSlot, GiftType, GiftObjectFit, GiftCoordinate, GiftState, GiftAnimationStep, GiftAnimationChain, SVGAMovieEntity, SVGAParams, SVGASpriteTable, SVGAAudio, SVGATransform, SVGAShape, VideoEntity, UVRect, FrameJobData, FlyAnimation, VAPConfig, VAPSrcItem, VAPFrameItem, VAPFrameObj, } from './types/index.js';
 export type { GiftAssetLease, GiftAssetMetadata, GiftStageCapabilities, SVGAFrameTimelineCapabilities, GiftStagePlugin, GiftStagePluginHost, MountedGiftStagePlugin, MotionBindingOptions, MotionTrackDescriptor, MotionTrackLease, BallisticV1ParticleBatchDescriptor, ParticleAtlasDescriptor, ParticleAtlasHandle, ParticleBatchDescriptor, ParticleBatchEnvelope, ParticleBatchGroupHandle, ParticleBatchHandle, ParticleEnvelopeSegment, SpriteV2ParticleBatchDescriptor, PlaybackFrame, PlaybackScope, PlaybackScopeStartOptions, PlaybackScopeState, ReadonlyTableDescriptor, ReadonlyTableLease, } from './plugin/types.js';
+export type { SVGAPreparationProfile, SVGAPreparationPhase, SVGAPreparationStageProfile } from './types/index.js';

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

@@ -1,3 +1,5 @@
+import { SVGAClipAnalysisCache } from '../utils/svga-clip-analysis.js';
+import { type SVGAPreparationRecorder } from '../utils/svga-preparation-profile.js';
 import type { GPUBackend, GPUBufferHandle, GiftSlot, VideoEntity } from '../types/index.js';
 /** Signals RenderManager to discard and replay the complete frame after a resource fallback. */
 export declare class SVGAFastPathFrameReplayError extends Error {
@@ -32,6 +34,7 @@ export interface ClipMeshCache {
     indexBuf?: GPUBufferHandle | null;
 }
 interface SVGAClipPrewarmOptions {
+    profile?: SVGAPreparationRecorder;
     frameBudgetMs?: number;
     workerTimeSliceMs?: number;
     checkActive?: () => void;
@@ -78,9 +81,10 @@ export declare class SVGABatchRenderer {
     /** Shared producers outlive individual addGift/preload subscribers. */
     private clipMeshProducerController;
     private clipMeshProducerTasks;
+    private clipResourceProducers;
     private destroyed;
     private clipMeshDestroyed;
-    private clipGeometryKindCache;
+    readonly clipAnalysis: SVGAClipAnalysisCache;
     /** Meshes with lazily created GPU buffers (released in destroy). */
     private clipMeshesWithBuffers;
     private clipMeshRefCounts;
@@ -258,7 +262,8 @@ export declare class SVGABatchRenderer {
     /** Validates every immutable Hybrid mesh reference and retains its GPU buffers for this entity. */
     retainHybridMeshes(backend: GPUBackend, entity: VideoEntity): void;
     releaseHybridMeshes(backend: GPUBackend, entity: VideoEntity): void;
-    private collectFrameClipPaths;
+    releaseClipPreparation(entity: Pick<VideoEntity, 'spriteTable'>): void;
+    private collectClipPathsSteps;
     /**
      * Ensures shared producers exist, then waits as the current subscriber. A subscriber signal
      * never owns or cancels shared mesh production; it only detaches this caller's waiter.
@@ -284,6 +289,7 @@ export declare class SVGABatchRenderer {
     private queueClipMeshBuild;
     private scheduleClipMeshBuildFlush;
     private flushPendingClipMeshBuilds;
+    hydrateClipMeshesCooperative(meshes: SVGAClipMeshMap | null | undefined, options?: SVGAClipPrewarmOptions): Promise<void>;
     hydrateClipMeshes(meshes: SVGAClipMeshMap | null | undefined): void;
     snapshotClipMeshes(entity: Pick<VideoEntity, 'spriteTable'>): SVGAClipMeshMap;
     private canUseTimelinePath;

package/dist/types/index.d.ts

@@ -314,6 +314,8 @@ export interface GPUBackend {
     createSVGAFrameTable?(packedData: Float32Array, options: SVGAFrameTableCreateOptions): SVGAFrameTableBinding;
     /** Releases a frame table returned by `createSVGAFrameTable`. */
     deleteSVGAFrameTable?(binding: SVGAFrameTableBinding): void;
+    /** Prepares sprite-v2 shaders before playback, without drawing or advancing a clock. */
+    prepareParticleSpritePipelines?(): void | Promise<void>;
     createTexture(source: TexImageSource | ArrayBuffer, opts: TextureOpts): GPUTextureHandle;
     /** Uninitialized RGBA texture (e.g. WebCodecs atlas backing store). */
     createEmptyTexture(width: number, height: number, opts?: TextureOpts): GPUTextureHandle;
@@ -810,6 +812,10 @@ export interface GiftStageOptions {
      * Default: true.
      */
     svgaClipPrewarmInWorker?: boolean;
+    /** Build immutable GPU command/frame tables in a Worker. Defaults to true. */
+    svgaCommandTableInWorker?: boolean;
+    /** Optional per-resource preparation summary. Detailed sampling is disabled when absent. */
+    onSVGAPreparationProfile?: (profile: SVGAPreparationProfile) => void;
     /** Called when a gift's selected SVGA rendering path changes. */
     onSVGARenderPathChange?: (info: SVGARenderPathChangeInfo) => void;
     /** Receives production runtime diagnostics. GiftStage does not upload these events. */
@@ -1152,3 +1158,23 @@ export interface GiftAnimationChain {
     /** Cancel the active animation for this gift. */
     cancel(): void;
 }
+export type SVGAPreparationPhase = 'clip-prepare' | 'worker-queue' | 'input-copy' | 'command-build' | 'frame-pack' | 'validation' | 'gpu-submit';
+export interface SVGAPreparationStageProfile {
+    /** Combined CPU execution across threads; excludes waits. */
+    executionMs: number;
+    mainThreadExecutionMs: number;
+    workerExecutionMs: number;
+    elapsedMs: number;
+    maxSliceMs: number;
+    slices: number;
+    cacheHits: number;
+    bytes: number;
+}
+export interface SVGAPreparationProfile {
+    resourceId: number;
+    executor: 'worker' | 'main-thread';
+    fallbackReason?: string;
+    status: 'complete' | 'canceled' | 'failed';
+    elapsedMs: number;
+    phases: Partial<Record<SVGAPreparationPhase, SVGAPreparationStageProfile>>;
+}

package/dist/utils/clip-mesh.d.ts

@@ -1,9 +1,10 @@
+import { parseSvgPath } from './svg-path-parser.js';
 export interface ClipMeshData {
     vertices: Float32Array;
     indices: Uint32Array;
 }
-/** Returns a stable validation failure, or null for a renderable triangle mesh. */
 export declare function validateClipMeshData(mesh: ClipMeshData): string | null;
+export declare function validateClipMeshDataSteps(mesh: ClipMeshData): Generator<void, string | null>;
 export type ClipMeshTriangulator = (vertices: Float64Array, polygonStarts: Uint32Array) => Uint32Array | null;
 export type ClipPathGeometryKind = 'empty' | 'fillable' | 'invalid';
 /**
@@ -16,4 +17,9 @@ export type ClipPathGeometryKind = 'empty' | 'fillable' | 'invalid';
  * validation remains authoritative for those genuinely malformed contours.
  */
 export declare function classifyClipPathGeometry(clipPath: string): ClipPathGeometryKind;
+/** Reuses flattened geometry when callers also inspect the path's bounds. */
+export declare function classifyParsedClipPathGeometry(subPaths: ReturnType<typeof parseSvgPath>): ClipPathGeometryKind;
+/** Checkpoints also bound work for a single large, collinear contour. */
+export declare function classifyParsedClipPathGeometrySteps(subPaths: ReturnType<typeof parseSvgPath>): Generator<void, ClipPathGeometryKind>;
 export declare function buildClipMeshFromPath(clipPath: string, triangulator?: ClipMeshTriangulator): ClipMeshData | null;
+export declare function buildClipMeshFromParsedPath(subPaths: ReturnType<typeof parseSvgPath>, triangulator?: ClipMeshTriangulator): ClipMeshData | null;

package/dist/utils/svg-path-parser.d.ts

@@ -8,4 +8,6 @@ interface Point {
     y: number;
 }
 export declare function parseSvgPath(d: string): Point[][];
+/** Incremental curve flattening for frame-budgeted clip analysis. */
+export declare function parseSvgPathSteps(d: string): Generator<void, Point[][]>;
 export {};

package/dist/utils/svga-clip-analysis.d.ts

@@ -0,0 +1,37 @@
+import type { VideoEntity } from '../types/index.js';
+import { type ClipPathGeometryKind } from './clip-mesh.js';
+import { type parseSvgPath } from './svg-path-parser.js';
+export interface ClipAnalysis {
+    kind: ClipPathGeometryKind;
+    localRect: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    } | null;
+}
+export declare function detectAxisAlignedClipRect(paths: ReturnType<typeof parseSvgPath>): {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+} | null;
+export declare function analyzeParsedClipSteps(points: ReturnType<typeof parseSvgPath>, blank?: boolean): Generator<void, ClipAnalysis>;
+/** One Stage owns this small cache. Meshes and flattened points are not retained here. */
+export declare class SVGAClipAnalysisCache {
+    private paths;
+    private tables;
+    private resourcePaths;
+    private pathUsers;
+    private released;
+    hits: number;
+    trackHits: boolean;
+    retain(table: VideoEntity['spriteTable'], path: string): void;
+    release(table: VideoEntity['spriteTable']): string[];
+    get(path: string): ClipAnalysis | undefined;
+    set(path: string, value: ClipAnalysis): void;
+    getByIndex(table: VideoEntity['spriteTable'], index: number): ClipAnalysis | undefined;
+    analyze(table: VideoEntity['spriteTable'], index: number): Generator<void, ClipAnalysis>;
+    clear(): void;
+}
+export declare function getStandaloneClipAnalysis(table: VideoEntity['spriteTable']): SVGAClipAnalysisCache;

package/dist/utils/svga-command-preparation.d.ts

@@ -0,0 +1,13 @@
+import type { VideoEntity } from '../types/index.js';
+import { type SVGAHybridCommandTableBuildOptions } from './svga-hybrid-command-table.js';
+import { type SVGACommandInput } from './svga-hybrid-command-data.js';
+import type { SVGACommandResult } from '../workers/svga-command-worker.js';
+export interface SVGACommandPreparationOptions extends SVGAHybridCommandTableBuildOptions {
+    useWorker?: boolean;
+    workerTimeSliceMs?: number;
+    signal?: AbortSignal;
+}
+/** Transfer only dedicated copies, in at most 64 KiB copy operations. */
+export declare function copySVGACommandInputSteps(input: SVGACommandInput): Generator<void, SVGACommandInput>;
+export declare function validateSVGACommandResultSteps(result: SVGACommandResult, input: SVGACommandInput, hybrid: boolean): Generator<void, void>;
+export declare function prepareSVGACommandTables(entity: VideoEntity, hybrid: boolean, options?: SVGACommandPreparationOptions): Promise<SVGACommandResult>;

package/dist/utils/svga-hybrid-command-data.d.ts

@@ -0,0 +1,18 @@
+import type { SVGAHybridCommandTable } from '../types/index.js';
+/** Dedicated numeric snapshot; no paths, entity references or GPU handles. */
+export interface SVGACommandInput {
+    frameCount: number;
+    spriteCount: number;
+    frameData: Float32Array;
+    shapesIndex: Int32Array;
+    clipPathIndex: Int32Array;
+    shapePresence: Uint8Array;
+    clipKinds: Uint8Array;
+    clipRects: Float64Array;
+    atlas: Float64Array;
+}
+/** FNV-1a over canonical numeric bytes; -0 and 0 have the same identity. */
+export declare function hashScheduleNumber(hash: number, value: number): number;
+/** All executors drain this same generator. Hashes only select exact-comparison buckets. */
+export declare function buildSVGACommandDataSteps(input: SVGACommandInput, hashNumber?: typeof hashScheduleNumber): Generator<void, SVGAHybridCommandTable>;
+export declare function packSVGAFrameDataSteps(data: Float32Array): Generator<void, Float32Array>;

package/dist/utils/svga-hybrid-command-table.d.ts

@@ -1,12 +1,16 @@
 import type { SVGAHybridCommandTable, VideoEntity } from '../types/index.js';
+import { type SVGAClipAnalysisCache } from './svga-clip-analysis.js';
+import { type SVGACommandInput } from './svga-hybrid-command-data.js';
+import { type PreparationStepOptions } from './svga-preparation-profile.js';
 export declare const SVGA_HYBRID_OP_TEXTURE = 0;
 export declare const SVGA_HYBRID_OP_SHAPE = 1;
 export declare const SVGA_HYBRID_OP_CLIP_WRITE = 2;
 export declare const SVGA_HYBRID_OP_CLIP_TEST = 3;
 export declare const SVGA_HYBRID_OP_CLIP_CLEAR = 4;
-/**
- * Compiles the SVGA paint graph once per resource. Runtime Hybrid rendering
- * indexes one immutable frame slice and never scans all sprite rows or resolves
- * image/shape/clip keys on the hot path.
- */
+export interface SVGAHybridCommandTableBuildOptions extends PreparationStepOptions {
+    clipAnalysis?: SVGAClipAnalysisCache;
+}
+/** Input references remain on the main thread until explicitly copied for a Worker. */
+export declare function prepareSVGACommandInputSteps(entity: VideoEntity, options?: SVGAHybridCommandTableBuildOptions): Generator<void, SVGACommandInput>;
 export declare function buildSVGAHybridCommandTable(entity: VideoEntity): SVGAHybridCommandTable;
+export declare function buildSVGAHybridCommandTableCooperative(entity: VideoEntity, options?: SVGAHybridCommandTableBuildOptions): Promise<SVGAHybridCommandTable>;

package/dist/utils/svga-preparation-profile.d.ts

@@ -0,0 +1,21 @@
+import type { SVGAPreparationPhase, SVGAPreparationProfile, SVGAPreparationStageProfile } from '../types/index.js';
+export declare class SVGAPreparationRecorder {
+    readonly resourceId: number;
+    readonly started: number;
+    readonly phases: Partial<Record<SVGAPreparationPhase, SVGAPreparationStageProfile>>;
+    executor: SVGAPreparationProfile['executor'];
+    fallbackReason?: string;
+    constructor(resourceId: number);
+    phase(name: SVGAPreparationPhase): SVGAPreparationStageProfile;
+    record(name: SVGAPreparationPhase, duration: number, thread?: 'main' | 'worker'): void;
+    measure<T>(name: SVGAPreparationPhase, action: () => T): T;
+    finish(status: SVGAPreparationProfile['status']): SVGAPreparationProfile;
+}
+export interface PreparationStepOptions {
+    signal?: AbortSignal;
+    frameBudgetMs?: number;
+    checkActive?: () => void;
+    profile?: SVGAPreparationRecorder;
+}
+/** Record only execution slices, excluding rAF waits and competing tasks. */
+export declare function runPreparationSteps<T>(steps: Generator<void, T>, options?: PreparationStepOptions, phase?: SVGAPreparationPhase): Promise<T>;

package/dist/utils/svga-work-scheduler.d.ts

@@ -1,7 +1,8 @@
+export type SVGAWorkerTaskPriority = 'foreground' | 'background';
 /**
  * SVGA parser, image decode, atlas and clip workers share this gate so they
  * do not create a multi-core CPU burst while real-time media is active.
  */
 export declare function configureSVGAWorkerTaskConcurrency(maxConcurrent?: number): void;
-export declare function runSVGAWorkerTask<T>(task: () => Promise<T>, signal?: AbortSignal): Promise<T>;
-export declare function acquireSVGAWorkerTask(signal?: AbortSignal): Promise<() => void>;
+export declare function runSVGAWorkerTask<T>(task: () => Promise<T>, signal?: AbortSignal, priority?: SVGAWorkerTaskPriority): Promise<T>;
+export declare function acquireSVGAWorkerTask(signal?: AbortSignal, priority?: SVGAWorkerTaskPriority): Promise<() => void>;

package/dist/workers/svga-clip-worker-client.d.ts

@@ -1,6 +1,11 @@
+import { type SVGAPreparationRecorder } from '../utils/svga-preparation-profile.js';
+import type { ClipAnalysis } from '../utils/svga-clip-analysis.js';
 import { type ClipMeshData } from '../utils/clip-mesh.js';
 export declare function canUseSVGAClipWorker(): boolean;
 export declare function requestSVGAClipMeshesInWorker(paths: string[], options?: {
+    profile?: SVGAPreparationRecorder;
     workerTimeSliceMs?: number;
     signal?: AbortSignal;
+    frameBudgetMs?: number;
+    onAnalysis?: (path: string, analysis: ClipAnalysis) => void;
 }): Promise<Map<string, ClipMeshData | null>>;

package/dist/workers/svga-clip-worker.d.ts

@@ -1,11 +1,14 @@
+import { type ClipAnalysis } from '../utils/svga-clip-analysis.js';
 export interface SVGAClipWorkerRequest {
     type: 'build-svga-clip-meshes';
     id: number;
     paths: string[];
     workerTimeSliceMs?: number;
+    profile?: boolean;
 }
 export interface SVGAClipWorkerEntry {
     path: string;
+    analysis: ClipAnalysis;
     vertices: Float32Array | null;
     indices: Uint32Array | null;
 }
@@ -14,4 +17,10 @@ export interface SVGAClipWorkerResponse {
     id: number;
     entries?: SVGAClipWorkerEntry[];
     error?: string;
+    profile?: {
+        executionMs: number;
+        elapsedMs: number;
+        maxSliceMs: number;
+        slices: number;
+    };
 }

package/dist/workers/svga-command-worker-client.d.ts

@@ -0,0 +1,8 @@
+import type { SVGACommandResult } from './svga-command-worker.js';
+import type { SVGACommandInput } from '../utils/svga-hybrid-command-data.js';
+import type { PreparationStepOptions } from '../utils/svga-preparation-profile.js';
+export interface CommandWorkerOptions extends PreparationStepOptions {
+    signal?: AbortSignal;
+    workerTimeSliceMs?: number;
+}
+export declare function requestSVGACommandTableInWorker(input: SVGACommandInput, hybrid: boolean, options: CommandWorkerOptions): Promise<SVGACommandResult>;

package/dist/workers/svga-command-worker.d.ts

@@ -0,0 +1,27 @@
+import { type SVGACommandInput } from '../utils/svga-hybrid-command-data.js';
+import type { SVGAHybridCommandTable } from '../types/index.js';
+export interface SVGACommandResult {
+    commandTable?: SVGAHybridCommandTable;
+    packed: Float32Array;
+}
+export interface SVGACommandRequest {
+    type: 'start' | 'resume' | 'cancel';
+    id: number;
+    generation: number;
+    input?: SVGACommandInput;
+    hybrid?: boolean;
+    sliceMs?: number;
+    profile?: boolean;
+}
+export interface SVGACommandResponse {
+    id: number;
+    generation: number;
+    type: 'paused' | 'complete' | 'error';
+    result?: SVGACommandResult;
+    error?: string;
+    samples?: Array<{
+        phase: 'command-build' | 'frame-pack';
+        executionMs: number;
+        elapsedMs: number;
+    }>;
+}

package/package.json

@@ -1,82 +1,82 @@
-{
-  "name": "@taole/giftstage",
-  "version": "0.3.3",
-  "description": "High-performance WebGPU/WebGL gift animation player unifying SVGA, VAP, AlphaVideo, and images",
-  "type": "module",
-  "main": "dist/gift-stage.cjs",
-  "module": "dist/gift-stage.es.js",
-  "types": "dist/public.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/public.d.ts",
-      "import": "./dist/gift-stage.es.js",
-      "require": "./dist/gift-stage.cjs"
-    }
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "files": [
-    "dist",
-    "!dist/**/*.map",
-    "!dist/bundle-report.*.html",
-    "!dist/fixtures/**"
-  ],
-  "scripts": {
-    "dev": "vite",
-    "build": "tsc --noEmit && vite build && tsc -p tsconfig.build.json && node scripts/write-public-types.mjs",
-    "build:analyze": "tsc --noEmit && vite build --mode analyze-es && vite build --mode analyze-cjs && tsc -p tsconfig.build.json && node scripts/write-public-types.mjs",
-    "build:demo": "tsc --noEmit && vite build --config vite.demo.config.ts && node -e \"const fs=require('fs'); fs.mkdirSync('dist-demo/static',{recursive:true}); fs.copyFileSync('static/vap.min.js','dist-demo/static/vap.min.js');\"",
-    "build:wasm": "echo \"Requires: cargo install wasm-pack\" && cd wasm && wasm-pack build --target web --out-dir pkg",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:browser": "vitest run --browser.enabled --browser.name=chromium",
-    "test:e2e": "playwright test",
-    "test:perf": "node scripts/run-performance.mjs",
-    "test:real-assets": "node scripts/verify-real-svga-manifest.mjs",
-    "test:package": "npm run build && node scripts/check-package-contract.mjs",
-    "perf:record": "node scripts/run-performance.mjs --record",
-    "lint": "eslint src/ tests/",
-    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
-    "typecheck": "tsc --noEmit",
-    "dp": "node publish/deploy.mjs"
-  },
-  "devDependencies": {
-    "@playwright/test": "^1.50.0",
-    "@types/dom-webcodecs": "^0.1.11",
-    "@types/earcut": "^3.0.0",
-    "@types/node": "^25.6.0",
-    "@types/pngjs": "^6.0.5",
-    "@vitest/browser": "^3.0.0",
-    "eslint": "^9.0.0",
-    "fake-indexeddb": "^6.2.5",
-    "jsdom": "^24.1.3",
-    "playwright": "^1.50.0",
-    "pngjs": "^7.0.0",
-    "prettier": "^3.4.0",
-    "rollup-plugin-visualizer": "^7.0.1",
-    "typescript": "^5.7.0",
-    "typescript-eslint": "^8.68.0",
-    "vite": "^6.0.0",
-    "vite-plugin-wasm": "^3.4.0",
-    "vitest": "^3.0.0"
-  },
-  "keywords": [
-    "svga",
-    "vap",
-    "alpha-video",
-    "image",
-    "webgl",
-    "webgpu",
-    "animation",
-    "gift",
-    "transparent-video"
-  ],
-  "license": "MIT",
-  "dependencies": {
-    "@webgpu/types": "^0.1.69",
-    "earcut": "^3.0.2",
-    "mp4box": "^2.3.0"
-  }
-}
+{
+  "name": "@taole/giftstage",
+  "version": "0.3.5",
+  "description": "High-performance WebGPU/WebGL gift animation player unifying SVGA, VAP, AlphaVideo, and images",
+  "type": "module",
+  "main": "dist/gift-stage.cjs",
+  "module": "dist/gift-stage.es.js",
+  "types": "dist/public.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/public.d.ts",
+      "import": "./dist/gift-stage.es.js",
+      "require": "./dist/gift-stage.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "!dist/bundle-report.*.html",
+    "!dist/fixtures/**"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc --noEmit && vite build && tsc -p tsconfig.build.json && node scripts/write-public-types.mjs",
+    "build:analyze": "tsc --noEmit && vite build --mode analyze-es && vite build --mode analyze-cjs && tsc -p tsconfig.build.json && node scripts/write-public-types.mjs",
+    "build:demo": "tsc --noEmit && vite build --config vite.demo.config.ts && node -e \"const fs=require('fs'); fs.mkdirSync('dist-demo/static',{recursive:true}); fs.copyFileSync('static/vap.min.js','dist-demo/static/vap.min.js');\"",
+    "build:wasm": "echo \"Requires: cargo install wasm-pack\" && cd wasm && wasm-pack build --target web --out-dir pkg",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:browser": "vitest run --browser.enabled --browser.name=chromium",
+    "test:e2e": "playwright test",
+    "test:perf": "node scripts/run-performance.mjs",
+    "test:real-assets": "node scripts/verify-real-svga-manifest.mjs",
+    "test:package": "npm run build && node scripts/check-package-contract.mjs",
+    "perf:record": "node scripts/run-performance.mjs --record",
+    "lint": "eslint src/ tests/",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "typecheck": "tsc --noEmit",
+    "dp": "node publish/deploy.mjs"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.50.0",
+    "@types/dom-webcodecs": "^0.1.11",
+    "@types/earcut": "^3.0.0",
+    "@types/node": "^25.6.0",
+    "@types/pngjs": "^6.0.5",
+    "@vitest/browser": "^3.0.0",
+    "eslint": "^9.0.0",
+    "fake-indexeddb": "^6.2.5",
+    "jsdom": "^24.1.3",
+    "playwright": "^1.50.0",
+    "pngjs": "^7.0.0",
+    "prettier": "^3.4.0",
+    "rollup-plugin-visualizer": "^7.0.1",
+    "typescript": "^5.7.0",
+    "typescript-eslint": "^8.68.0",
+    "vite": "^6.0.0",
+    "vite-plugin-wasm": "^3.4.0",
+    "vitest": "^3.0.0"
+  },
+  "keywords": [
+    "svga",
+    "vap",
+    "alpha-video",
+    "image",
+    "webgl",
+    "webgpu",
+    "animation",
+    "gift",
+    "transparent-video"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@webgpu/types": "^0.1.69",
+    "earcut": "^3.0.2",
+    "mp4box": "^2.3.0"
+  }
+}