@empty-sekai/sekai-custom-profile-sdk 0.3.0

package/dist/renderer.d.ts

@@ -0,0 +1,218 @@
+import { type BrowserSemanticResourceSet } from "./gpu/browserSemanticResources.js";
+import { type ResourceProvider } from "./resourceProvider.js";
+import { type LocalizationProvider } from "./localizationProvider.js";
+import { type FontProvider } from "./fontProvider.js";
+import { SemanticWebglSceneRenderer } from "./gpu/semanticWebglSceneRenderer.js";
+import type { NumericTextRegion } from "./interaction/numericTextRegions.js";
+import { type PersistentCacheSelection, type SdfAtlas, type SdfBackend } from "./fontSdfAtlas.js";
+import { type PrebuiltSdfAtlasProvider } from "./prebuiltSdfAtlas.js";
+import { RendererMasterData, RendererScene, type RendererWorkerClientOptions } from "./worker-client.js";
+import type { CoreSceneDelta, CoreSceneDump, StableId } from "./types/core.js";
+import { type RendererTelemetryOptions, type RendererRuntimeSnapshot } from "./telemetry/rendererTelemetry.js";
+export type BrowserRendererOptions = RendererWorkerClientOptions & {
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+    region: string;
+    resourceProvider: ResourceProvider;
+    resourceConcurrency?: number;
+    localizationProvider?: LocalizationProvider;
+    localizationConcurrency?: number;
+    fontProvider?: FontProvider;
+    fontConcurrency?: number;
+    prebuiltSdfAtlasProvider?: PrebuiltSdfAtlasProvider;
+    telemetry?: RendererTelemetryOptions;
+};
+export type MasterDataTableRequest = {
+    table: string;
+    region: string;
+    revision: string;
+};
+export type MasterDataTableLoader = (request: MasterDataTableRequest, context: {
+    signal: AbortSignal;
+}) => Promise<unknown>;
+export type ProfileSceneCreateOptions = {
+    masterData: RendererMasterData;
+    documentKey: string;
+    card: unknown;
+    profile?: unknown;
+    locale?: string;
+    frameMode?: "final" | "animate";
+    signal?: AbortSignal;
+    sdf?: {
+        backend?: SdfBackend;
+        supersample?: number;
+        persistence?: PersistentCacheSelection;
+    };
+};
+/**
+ * WebGL2-only browser renderer. Rust/WASM scene, text layout, and glyph work
+ * stay in one worker; the main thread owns resource decoding and GPU state.
+ */
+export declare class BrowserRenderer {
+    private gl;
+    private readonly worker;
+    private readonly region;
+    private readonly prebuiltSdfAtlasProvider?;
+    private readonly resources;
+    private readonly localizations;
+    private readonly providedFonts;
+    private readonly fonts;
+    private readonly fontRegistrations;
+    private readonly scenes;
+    private readonly canvas;
+    private readonly telemetryOptions;
+    private contextLost;
+    private restorePromise;
+    private readonly lifetime;
+    private destroyed;
+    private constructor();
+    static create(options: BrowserRendererOptions): Promise<BrowserRenderer>;
+    createProfileScene(options: ProfileSceneCreateOptions): Promise<BrowserScene>;
+    createMasterData(revision: string): Promise<RendererMasterData>;
+    loadMasterData(revision: string, loadTable: MasterDataTableLoader, options?: {
+        signal?: AbortSignal;
+        concurrency?: number;
+    }): Promise<RendererMasterData>;
+    registerFont(font: {
+        family: string;
+        bytes: ArrayBuffer;
+    }): Promise<void>;
+    stats(): Promise<{
+        worker: import("./protocol.js").RendererWorkerStats;
+        resources: {
+            provider: {
+                active: number;
+                queued: number;
+                limit: number;
+                peak: number;
+                requested: number;
+                loaded: number;
+                failures: number;
+                cancellations: number;
+                encodedBytes: number;
+                resolveMs: number;
+            };
+            entries: number;
+            bytes: number;
+            pinned: number;
+            loads: number;
+            hits: number;
+            evictions: number;
+        };
+        fonts: {
+            registered: number;
+            provider: import("./fontProvider.js").FontProviderStats | null;
+        };
+        localizations: import("./localizationProvider.js").LocalizationProviderStats | null;
+        scenes: {
+            active: number;
+            contextLost: number;
+        };
+    }>;
+    restoreContext(): Promise<void>;
+    destroy(): void;
+    private assertAlive;
+    private readonly handleContextLost;
+    private readonly handleContextRestored;
+}
+export declare class BrowserScene {
+    private readonly core;
+    private readonly renderer;
+    private readonly resources;
+    private readonly atlas;
+    private destroyed;
+    private readonly runtime;
+    private readonly onDestroy;
+    constructor(core: RendererScene, renderer: SemanticWebglSceneRenderer, resources: BrowserSemanticResourceSet, atlas: SdfAtlas | null, options: {
+        dynamicProgramCount: number;
+        canvas: HTMLCanvasElement | OffscreenCanvas;
+        telemetry?: RendererTelemetryOptions;
+        bootstrap: RendererRuntimeSnapshot["bootstrap"];
+        onDestroy?: (scene: BrowserScene) => void;
+    });
+    /** Whether this scene owns renderer-driven programs that require timeline advancement. */
+    readonly animated: boolean;
+    /** Number of renderer-compiled dynamic programs retained by this scene. */
+    readonly dynamicProgramCount: number;
+    private readonly canvas;
+    draw(): import("./gpu/webglSemanticCommandExecutor.js").SemanticGpuMetrics;
+    /** Draws the current frame and encodes an exact 1830×812 PNG snapshot. */
+    exportPng(): Promise<Blob>;
+    advance(tick: number): Promise<{
+        delta: CoreSceneDelta;
+        gpu: {
+            commandMaskUploadBytes: number;
+            commandStateUploadBytes: number;
+            stateUploadBytes: number;
+            maskUploadBytes: number;
+        };
+    }>;
+    setLayerVisible(layerId: StableId, visible: boolean): Promise<{
+        delta: CoreSceneDelta;
+        gpu: {
+            commandMaskUploadBytes: number;
+            commandStateUploadBytes: number;
+            stateUploadBytes: number;
+            maskUploadBytes: number;
+        };
+    }>;
+    setLayerMasks(expectedRevision: number, overrides: Array<{
+        layerId: StableId;
+        visible: boolean | null;
+    }>): Promise<{
+        delta: CoreSceneDelta;
+        gpu: {
+            commandMaskUploadBytes: number;
+            commandStateUploadBytes: number;
+            stateUploadBytes: number;
+            maskUploadBytes: number;
+        };
+    }>;
+    setTab(controlId: StableId, value: string): Promise<{
+        delta: CoreSceneDelta;
+        gpu: {
+            commandMaskUploadBytes: number;
+            commandStateUploadBytes: number;
+            stateUploadBytes: number;
+            maskUploadBytes: number;
+        };
+    }>;
+    setScrollOffset(controlId: StableId, offset: number): Promise<{
+        delta: CoreSceneDelta;
+        gpu: {
+            commandMaskUploadBytes: number;
+            commandStateUploadBytes: number;
+            stateUploadBytes: number;
+            maskUploadBytes: number;
+        };
+    }>;
+    scrollBy(controlId: StableId, delta: number): Promise<{
+        delta: CoreSceneDelta;
+        gpu: {
+            commandMaskUploadBytes: number;
+            commandStateUploadBytes: number;
+            stateUploadBytes: number;
+            maskUploadBytes: number;
+        };
+    }>;
+    setLayerPreviewTransform(layerId: StableId, matrix: [number, number, number, number, number, number] | null): {
+        gpu: {
+            previewUploadBytes: number;
+        };
+        draw: import("./gpu/webglSemanticCommandExecutor.js").SemanticGpuMetrics;
+    };
+    dump(): Promise<CoreSceneDump & {
+        numeric_text_regions: NumericTextRegion[];
+    }>;
+    destroy(): Promise<void>;
+    notifyContextLost(): void;
+    notifyContextRestoreFailed(restoreMs: number): void;
+    restoreContext(gl: WebGL2RenderingContext): Promise<void>;
+    stats(): RendererRuntimeSnapshot;
+    private apply;
+    private assertAlive;
+    private assertGpuReady;
+}
+export declare class BrowserRendererError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}