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

package/dist/renderer.js

@@ -0,0 +1,641 @@
+import { BrowserSemanticResourceManager, } from "./gpu/browserSemanticResources.js";
+import { profileResourceDescriptors, } from "./resourceProvider.js";
+import { LocalizationProviderManager, } from "./localizationProvider.js";
+import { FontProviderManager, } from "./fontProvider.js";
+import { semanticCommandPlanFromCoreSnapshot, } from "./gpu/semanticCommandPlanner.js";
+import { SemanticWebglSceneRenderer } from "./gpu/semanticWebglSceneRenderer.js";
+import { buildSdfAtlas, disposeWorkerAtlasSessions, } from "./fontSdfAtlas.js";
+import { buildPrebuiltSdfAtlas, } from "./prebuiltSdfAtlas.js";
+import { RendererWorkerClient, } from "./worker-client.js";
+import { RendererRuntimeTelemetry, } from "./telemetry/rendererTelemetry.js";
+const CARD_WIDTH = 1830;
+const CARD_HEIGHT = 812;
+/**
+ * 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 class BrowserRenderer {
+    gl;
+    worker;
+    region;
+    prebuiltSdfAtlasProvider;
+    resources;
+    localizations;
+    providedFonts;
+    fonts = new Map();
+    fontRegistrations = new Map();
+    scenes = new Set();
+    canvas;
+    telemetryOptions;
+    contextLost = false;
+    restorePromise = null;
+    lifetime = new AbortController();
+    destroyed = false;
+    constructor(gl, worker, region, canvas, resourceProvider, resourceConcurrency, localizationProvider, localizationConcurrency, fontProvider, fontConcurrency, prebuiltSdfAtlasProvider, telemetryOptions = {}) {
+        this.gl = gl;
+        this.worker = worker;
+        this.region = region;
+        this.prebuiltSdfAtlasProvider = prebuiltSdfAtlasProvider;
+        this.canvas = canvas;
+        this.telemetryOptions = telemetryOptions;
+        this.resources = new BrowserSemanticResourceManager({
+            provider: resourceProvider,
+            concurrency: resourceConcurrency,
+        });
+        this.localizations = localizationProvider
+            ? new LocalizationProviderManager({
+                provider: localizationProvider,
+                concurrency: localizationConcurrency,
+            })
+            : null;
+        this.providedFonts = fontProvider
+            ? new FontProviderManager({
+                provider: fontProvider,
+                concurrency: fontConcurrency,
+            })
+            : null;
+        if (isHtmlCanvas(canvas)) {
+            canvas.addEventListener("webglcontextlost", this.handleContextLost);
+            canvas.addEventListener("webglcontextrestored", this.handleContextRestored);
+        }
+    }
+    static async create(options) {
+        const gl = options.canvas.getContext("webgl2", {
+            alpha: true,
+            antialias: true,
+            depth: false,
+            premultipliedAlpha: true,
+            preserveDrawingBuffer: false,
+        });
+        if (!gl)
+            throw new BrowserRendererError("WEBGL2_UNAVAILABLE", "WebGL2 is required by renderer-wasm 0.2");
+        options.canvas.width = CARD_WIDTH;
+        options.canvas.height = CARD_HEIGHT;
+        const worker = await RendererWorkerClient.create(options);
+        return new BrowserRenderer(gl, worker, options.region, options.canvas, options.resourceProvider, options.resourceConcurrency, options.localizationProvider, options.localizationConcurrency, options.fontProvider, options.fontConcurrency, options.prebuiltSdfAtlasProvider, options.telemetry);
+    }
+    async createProfileScene(options) {
+        this.assertAlive();
+        let resources = null;
+        let core = null;
+        let atlas = null;
+        const abort = combinedAbortSignal(this.lifetime.signal, options.signal);
+        try {
+            const locale = options.locale ?? this.region;
+            let localizedText;
+            if (this.localizations) {
+                const demandPreparation = await options.masterData.prepareProfile({
+                    documentKey: options.documentKey,
+                    card: options.card,
+                    profile: options.profile,
+                    locale,
+                    demandOnly: true,
+                });
+                localizedText = await this.localizations.resolve(preparedLocalizationDemands(demandPreparation), abort.signal);
+            }
+            if (this.providedFonts) {
+                const fontPreparation = await options.masterData.prepareProfile({
+                    documentKey: options.documentKey,
+                    card: options.card,
+                    profile: options.profile,
+                    locale,
+                    localizedText,
+                    fontDemandOnly: true,
+                });
+                const missing = preparedFontDemands(fontPreparation, this.region)
+                    .filter((request) => !this.fonts.has(request.family));
+                const provided = await this.providedFonts.resolve(missing, abort.signal);
+                await Promise.all([...provided].map(([family, bytes]) => this.registerFont({ family, bytes })));
+            }
+            const preparation = await options.masterData.prepareProfile({
+                documentKey: options.documentKey,
+                card: options.card,
+                profile: options.profile,
+                locale,
+                localizedText,
+            });
+            const glyphRequests = preparedGlyphRequests(preparation);
+            if (glyphRequests.length === 0) {
+                atlas = null;
+            }
+            else {
+                atlas = this.prebuiltSdfAtlasProvider
+                    ? await buildPrebuiltSdfAtlas(this.prebuiltSdfAtlasProvider, glyphRequests, abort.signal)
+                    : null;
+                atlas ??= await buildSdfAtlas(requiredFontSources(glyphRequests, this.fonts), glyphRequests, { worker: this.worker, persistence: options.sdf?.persistence ?? "origin" }, options.sdf?.supersample, options.sdf?.backend);
+            }
+            const requestedResources = profileResourceDescriptors(preparation);
+            let acquired;
+            acquired = await this.resources.acquire(requestedResources, abort.signal);
+            resources = acquired;
+            const compiled = await options.masterData.createProfileScene({
+                documentKey: options.documentKey,
+                card: options.card,
+                profile: options.profile,
+                locale,
+                localizedText,
+                frameMode: options.frameMode ?? "animate",
+                resourceMetrics: requestedResources.map((resource) => {
+                    const image = acquired.sources.get(resource.id);
+                    return {
+                        namespace: resource.namespace,
+                        key: resource.key,
+                        width: image?.width ?? 0,
+                        height: image?.height ?? 0,
+                        available: acquired.availability.get(resource.id) ?? false,
+                    };
+                }),
+            }, preparedLayoutRequest(preparation, atlas));
+            core = compiled.scene;
+            const plan = semanticCommandPlanFromCoreSnapshot(core.initial.snapshot);
+            assertPreparedResources(plan.resourceRequests(), acquired.sources);
+            const renderer = new SemanticWebglSceneRenderer(this.gl);
+            const bootstrap = await renderer.setScene({
+                plan,
+                atlas,
+                layout: compiled.layout,
+                imageSources: acquired.sources,
+            });
+            const scene = new BrowserScene(core, renderer, acquired, atlas, {
+                dynamicProgramCount: compiled.layout.dynamicPrograms.length,
+                canvas: this.canvas,
+                telemetry: this.telemetryOptions,
+                bootstrap,
+                onDestroy: (destroyed) => this.scenes.delete(destroyed),
+            });
+            this.scenes.add(scene);
+            return scene;
+        }
+        catch (error) {
+            atlas?.release();
+            resources?.release();
+            await core?.destroy().catch(() => undefined);
+            throw error;
+        }
+        finally {
+            abort.dispose();
+        }
+    }
+    async createMasterData(revision) {
+        this.assertAlive();
+        return this.worker.createMasterData(this.region, revision);
+    }
+    async loadMasterData(revision, loadTable, options = {}) {
+        if (typeof loadTable !== "function")
+            throw new BrowserRendererError("MASTERDATA_LOADER_REQUIRED", "A master-data table loader is required");
+        const session = await this.createMasterData(revision);
+        const signal = options.signal ?? new AbortController().signal;
+        const concurrency = options.concurrency ?? 4;
+        if (!Number.isInteger(concurrency) || concurrency <= 0) {
+            await session.destroy().catch(() => undefined);
+            throw new BrowserRendererError("INVALID_MASTERDATA_CONCURRENCY", "Master-data concurrency must be a positive integer");
+        }
+        try {
+            let cursor = 0;
+            const workers = Array.from({ length: Math.min(concurrency, session.requiredTables.length) }, async () => {
+                while (cursor < session.requiredTables.length) {
+                    if (signal.aborted)
+                        throw abortReason(signal);
+                    const table = session.requiredTables[cursor++];
+                    const value = await loadTable({ table, region: this.region, revision }, { signal });
+                    await session.putTable(table, value);
+                }
+            });
+            await Promise.all(workers);
+            await session.seal();
+            return session;
+        }
+        catch (error) {
+            await session.destroy().catch(() => undefined);
+            throw error;
+        }
+    }
+    async registerFont(font) {
+        this.assertAlive();
+        if (typeof font.family !== "string" || font.family.length === 0) {
+            throw new BrowserRendererError("INVALID_FONT_FAMILY", "Font family must be a non-empty string");
+        }
+        if (!(font.bytes instanceof ArrayBuffer) || font.bytes.byteLength === 0) {
+            throw new BrowserRendererError("INVALID_FONT_BYTES", `Font bytes are empty: ${font.family}`);
+        }
+        const sourceHash = await sha256Hex(font.bytes);
+        const pending = this.fontRegistrations.get(font.family);
+        if (pending)
+            await pending;
+        const registered = this.fonts.get(font.family);
+        if (registered) {
+            if (registered.sourceHash === sourceHash)
+                return;
+            throw new BrowserRendererError("FONT_IDENTITY_CONFLICT", `Font family is already registered with different bytes: ${font.family}`);
+        }
+        const source = { region: this.region, family: font.family, sourceHash };
+        const registration = this.worker.registerFont({ ...source, bytes: font.bytes })
+            .then(() => { this.fonts.set(font.family, source); });
+        this.fontRegistrations.set(font.family, registration);
+        try {
+            await registration;
+        }
+        finally {
+            this.fontRegistrations.delete(font.family);
+        }
+    }
+    async stats() {
+        if (this.destroyed)
+            throw new BrowserRendererError("RENDERER_DESTROYED", "Browser renderer is destroyed");
+        return {
+            worker: await this.worker.stats(),
+            resources: this.resources.stats(),
+            fonts: {
+                registered: this.fonts.size,
+                provider: this.providedFonts?.stats() ?? null,
+            },
+            localizations: this.localizations?.stats() ?? null,
+            scenes: {
+                active: this.scenes.size,
+                contextLost: [...this.scenes].filter((scene) => scene.stats().state === "context-lost").length,
+            },
+        };
+    }
+    async restoreContext() {
+        if (this.destroyed)
+            throw new BrowserRendererError("RENDERER_DESTROYED", "Browser renderer is destroyed");
+        if (this.restorePromise)
+            return this.restorePromise;
+        this.restorePromise = (async () => {
+            const started = monotonicNow();
+            const gl = this.canvas.getContext("webgl2", {
+                alpha: true,
+                antialias: true,
+                depth: false,
+                premultipliedAlpha: true,
+                preserveDrawingBuffer: false,
+            });
+            if (!gl) {
+                const restoreMs = monotonicNow() - started;
+                for (const scene of this.scenes)
+                    scene.notifyContextRestoreFailed(restoreMs);
+                throw new BrowserRendererError("WEBGL2_RESTORE_FAILED", "WebGL2 context restoration failed");
+            }
+            this.gl = gl;
+            await Promise.all([...this.scenes].map((scene) => scene.restoreContext(gl)));
+            this.contextLost = false;
+        })();
+        try {
+            await this.restorePromise;
+        }
+        finally {
+            this.restorePromise = null;
+        }
+    }
+    destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.lifetime.abort(new BrowserRendererError("RENDERER_DESTROYED", "Browser renderer is destroyed"));
+        if (isHtmlCanvas(this.canvas)) {
+            this.canvas.removeEventListener("webglcontextlost", this.handleContextLost);
+            this.canvas.removeEventListener("webglcontextrestored", this.handleContextRestored);
+        }
+        disposeWorkerAtlasSessions(this.worker);
+        this.worker.terminate();
+    }
+    assertAlive() {
+        if (this.destroyed)
+            throw new BrowserRendererError("RENDERER_DESTROYED", "Browser renderer is destroyed");
+        if (this.contextLost)
+            throw new BrowserRendererError("WEBGL_CONTEXT_LOST", "WebGL context is lost");
+    }
+    handleContextLost = (event) => {
+        event.preventDefault();
+        this.contextLost = true;
+        for (const scene of this.scenes)
+            scene.notifyContextLost();
+    };
+    handleContextRestored = () => {
+        void this.restoreContext().catch(() => {
+            // Scene recovery counters retain the failure. Call restoreContext() explicitly
+            // when the host needs an actionable rejection.
+        });
+    };
+}
+function atlasLayoutInput(atlas) {
+    return {
+        baseSize: atlas.baseSize,
+        spread: atlas.spread,
+        glyphs: Array.from(atlas.glyphs.values()),
+    };
+}
+function preparedGlyphRequests(preparation) {
+    const demand = preparation.glyph_demand;
+    if (!demand || typeof demand !== "object" || Array.isArray(demand)) {
+        throw new BrowserRendererError("INVALID_PROFILE_PREPARATION", "Profile preparation did not return glyph demand");
+    }
+    const requests = demand.requests;
+    if (!Array.isArray(requests)) {
+        throw new BrowserRendererError("INVALID_PROFILE_PREPARATION", "Profile glyph demand is invalid");
+    }
+    return requests.map((entry) => {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            throw new BrowserRendererError("INVALID_PROFILE_PREPARATION", "Profile glyph request is invalid");
+        }
+        const request = entry;
+        if (typeof request.region !== "string"
+            || typeof request.family !== "string"
+            || typeof request.font_source_hash !== "string"
+            || typeof request.char !== "string") {
+            throw new BrowserRendererError("INVALID_PROFILE_PREPARATION", "Profile glyph identity is invalid");
+        }
+        return {
+            region: request.region,
+            family: request.family,
+            fontSourceHash: request.font_source_hash,
+            char: request.char,
+        };
+    });
+}
+function preparedFontDemands(preparation, region) {
+    const values = preparation.fontDemands;
+    if (!Array.isArray(values)) {
+        throw new BrowserRendererError("INVALID_PROFILE_PREPARATION", "Profile preparation did not return font demands");
+    }
+    return values.map((family, index) => {
+        if (typeof family !== "string" || family.length === 0) {
+            throw new BrowserRendererError("INVALID_PROFILE_PREPARATION", `Profile font demand is invalid at index ${index}`);
+        }
+        return { region, family };
+    });
+}
+function preparedLayoutRequest(preparation, atlas) {
+    const request = preparation.layout_request;
+    if (!request || typeof request !== "object" || Array.isArray(request)) {
+        throw new BrowserRendererError("INVALID_PROFILE_PREPARATION", "Profile preparation did not return an authored layout request");
+    }
+    if (!atlas) {
+        const layers = request.layers;
+        if (!Array.isArray(layers) || layers.length !== 0) {
+            throw new BrowserRendererError("INVALID_PROFILE_PREPARATION", "Profile preparation returned text layers without glyph demand");
+        }
+        return {
+            ...request,
+            atlas: { baseSize: 1, spread: 0, glyphs: [] },
+        };
+    }
+    return {
+        ...request,
+        atlas: atlasLayoutInput(atlas),
+    };
+}
+function requiredFontSources(requests, fonts) {
+    const output = new Map();
+    for (const request of requests) {
+        const source = fonts.get(request.family);
+        if (!source || source.sourceHash !== request.fontSourceHash) {
+            throw new BrowserRendererError("FONT_NOT_REGISTERED", `Required font is not registered: ${request.family}`);
+        }
+        output.set(`${source.region}\0${source.sourceHash}\0${source.family}`, source);
+    }
+    return [...output.values()];
+}
+function assertPreparedResources(requested, sources) {
+    for (const resource of requested) {
+        if (!sources.has(`${resource.namespace}\0${resource.key}`)) {
+            throw new BrowserRendererError("RESOURCE_PREPARATION_DRIFT", `Scene requested an unprepared resource: ${resource.namespace}/${resource.key}`);
+        }
+    }
+}
+function preparedLocalizationDemands(preparation) {
+    const raw = preparation.localizationDemands;
+    if (!Array.isArray(raw))
+        return [];
+    return raw.map((value, index) => {
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            throw new BrowserRendererError("INVALID_LOCALIZATION_DEMAND", `Invalid localization demand at index ${index}`);
+        }
+        const { region, locale, key } = value;
+        if (typeof region !== "string" || typeof locale !== "string" || typeof key !== "string") {
+            throw new BrowserRendererError("INVALID_LOCALIZATION_DEMAND", `Invalid localization demand at index ${index}`);
+        }
+        return { region, locale, key };
+    });
+}
+function combinedAbortSignal(lifetime, request) {
+    if (!request || lifetime.aborted || request.aborted) {
+        return { signal: request?.aborted ? request : lifetime, dispose() { } };
+    }
+    const controller = new AbortController();
+    const abortLifetime = () => controller.abort(lifetime.reason);
+    const abortRequest = () => controller.abort(request.reason);
+    lifetime.addEventListener("abort", abortLifetime, { once: true });
+    request.addEventListener("abort", abortRequest, { once: true });
+    return {
+        signal: controller.signal,
+        dispose() {
+            lifetime.removeEventListener("abort", abortLifetime);
+            request.removeEventListener("abort", abortRequest);
+        },
+    };
+}
+function abortReason(signal) {
+    return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}
+export class BrowserScene {
+    core;
+    renderer;
+    resources;
+    atlas;
+    destroyed = false;
+    runtime;
+    onDestroy;
+    constructor(core, renderer, resources, atlas, options) {
+        this.core = core;
+        this.renderer = renderer;
+        this.resources = resources;
+        this.atlas = atlas;
+        this.dynamicProgramCount = options.dynamicProgramCount;
+        this.animated = this.dynamicProgramCount > 0;
+        this.canvas = options.canvas;
+        this.runtime = new RendererRuntimeTelemetry(options.telemetry ?? {}, atlasSummary(atlas), options.bootstrap);
+        this.onDestroy = options.onDestroy;
+    }
+    /** Whether this scene owns renderer-driven programs that require timeline advancement. */
+    animated;
+    /** Number of renderer-compiled dynamic programs retained by this scene. */
+    dynamicProgramCount;
+    canvas;
+    draw() {
+        this.assertAlive();
+        this.assertGpuReady();
+        const started = monotonicNow();
+        const metrics = this.renderer.draw();
+        this.runtime.recordDraw(metrics, monotonicNow() - started);
+        return metrics;
+    }
+    /** Draws the current frame and encodes an exact 1830×812 PNG snapshot. */
+    async exportPng() {
+        this.assertAlive();
+        this.draw();
+        if (typeof document !== "undefined") {
+            const snapshot = document.createElement("canvas");
+            snapshot.width = CARD_WIDTH;
+            snapshot.height = CARD_HEIGHT;
+            const context = snapshot.getContext("2d");
+            if (!context)
+                throw new BrowserRendererError("PNG_EXPORT_UNAVAILABLE", "Canvas 2D is required for PNG export");
+            context.drawImage(this.canvas, 0, 0, CARD_WIDTH, CARD_HEIGHT);
+            return new Promise((resolve, reject) => {
+                snapshot.toBlob((blob) => blob
+                    ? resolve(blob)
+                    : reject(new BrowserRendererError("PNG_EXPORT_FAILED", "Canvas PNG encoding returned no data")), "image/png");
+            });
+        }
+        if (typeof OffscreenCanvas === "undefined") {
+            throw new BrowserRendererError("PNG_EXPORT_UNAVAILABLE", "OffscreenCanvas is required outside a document");
+        }
+        const snapshot = new OffscreenCanvas(CARD_WIDTH, CARD_HEIGHT);
+        const context = snapshot.getContext("2d");
+        if (!context)
+            throw new BrowserRendererError("PNG_EXPORT_UNAVAILABLE", "Canvas 2D is required for PNG export");
+        context.drawImage(this.canvas, 0, 0, CARD_WIDTH, CARD_HEIGHT);
+        return snapshot.convertToBlob({ type: "image/png" });
+    }
+    async advance(tick) { this.assertGpuReady(); return this.apply(await this.core.advance(tick)); }
+    async setLayerVisible(layerId, visible) { this.assertGpuReady(); return this.apply(await this.core.setLayerVisible(layerId, visible)); }
+    async setLayerMasks(expectedRevision, overrides) {
+        this.assertGpuReady();
+        return this.apply(await this.core.setLayerMasks(expectedRevision, overrides));
+    }
+    async setTab(controlId, value) { this.assertGpuReady(); return this.apply(await this.core.setTab(controlId, value)); }
+    async setScrollOffset(controlId, offset) { this.assertGpuReady(); return this.apply(await this.core.setScrollOffset(controlId, offset)); }
+    async scrollBy(controlId, delta) { this.assertGpuReady(); return this.apply(await this.core.scrollBy(controlId, delta)); }
+    setLayerPreviewTransform(layerId, matrix) {
+        this.assertGpuReady();
+        const gpu = this.renderer.setLayerPreviewTransform(layerId, matrix);
+        const draw = this.draw();
+        return { gpu, draw };
+    }
+    async dump() {
+        this.assertAlive();
+        const dump = await this.core.dump();
+        const textGeometry = this.renderer.authoredTextHitGeometry();
+        const interactionRegions = dump.interaction_regions.map((region) => {
+            const geometry = region.role === "primary" ? textGeometry.get(region.layer_id) : undefined;
+            return geometry ? {
+                ...region,
+                hit_geometry: geometry.quad,
+            } : region;
+        });
+        return {
+            ...dump,
+            interaction_regions: interactionRegions,
+            numeric_text_regions: this.renderer.interactionRegions(),
+        };
+    }
+    async destroy() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        this.renderer.destroy();
+        this.resources.release();
+        await this.atlas?.release();
+        await this.core.destroy();
+        this.runtime.markDestroyed();
+        this.onDestroy?.(this);
+    }
+    notifyContextLost() {
+        if (this.destroyed)
+            return;
+        this.renderer.notifyContextLost();
+        this.runtime.markContextLost();
+    }
+    notifyContextRestoreFailed(restoreMs) {
+        if (this.destroyed)
+            return;
+        this.runtime.markRestoreFailed(restoreMs);
+    }
+    async restoreContext(gl) {
+        this.assertAlive();
+        const started = monotonicNow();
+        try {
+            const uploads = await this.renderer.restoreContext(gl);
+            this.runtime.markContextRestored(monotonicNow() - started, uploads);
+        }
+        catch (error) {
+            this.runtime.markRestoreFailed(monotonicNow() - started);
+            throw error;
+        }
+    }
+    stats() {
+        return this.runtime.snapshot();
+    }
+    apply(delta) {
+        this.assertAlive();
+        const gpu = this.renderer.applyCoreDelta(delta);
+        this.runtime.recordPatch(gpu);
+        return { delta, gpu };
+    }
+    assertAlive() {
+        if (this.destroyed)
+            throw new BrowserRendererError("SCENE_DESTROYED", "Browser scene is destroyed");
+    }
+    assertGpuReady() {
+        this.assertAlive();
+        if (this.runtime.state() === "context-lost") {
+            throw new BrowserRendererError("WEBGL_CONTEXT_LOST", "WebGL context is lost");
+        }
+    }
+}
+export class BrowserRendererError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "BrowserRendererError";
+    }
+}
+function atlasSummary(atlas) {
+    if (!atlas) {
+        return {
+            backend: "edt",
+            pages: 0,
+            glyphs: 0,
+            missingGlyphs: 0,
+            generation: { glyphs: 0, pixels: 0, glyphMs: 0, faceLoadMs: 0 },
+            cache: null,
+        };
+    }
+    const cache = atlas.perf.cache;
+    return {
+        backend: atlas.sdfBackend,
+        pages: atlas.depth,
+        glyphs: atlas.glyphs.size,
+        missingGlyphs: atlas.missing.length,
+        generation: {
+            glyphs: atlas.perf.totalGlyphCount,
+            pixels: atlas.perf.totalPixelCount,
+            glyphMs: atlas.perf.totalGlyphMs,
+            faceLoadMs: atlas.perf.totalFaceLoadMs,
+        },
+        cache: cache ? {
+            hits: cache.hits,
+            misses: cache.misses,
+            generations: cache.generations,
+            bytes: cache.bytes,
+            sessionHits: cache.sessionHits,
+            persistentHits: cache.persistentHits,
+            persistentMisses: cache.persistentMisses,
+            persistentWritesQueued: cache.persistentWritesQueued,
+            pinnedPages: cache.pinnedPages,
+            pageEvictions: cache.pageEvictions,
+        } : null,
+    };
+}
+function monotonicNow() {
+    return typeof performance === "undefined" ? Date.now() : performance.now();
+}
+async function sha256Hex(bytes) {
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+    return Array.from(digest, (value) => value.toString(16).padStart(2, "0")).join("");
+}
+function isHtmlCanvas(canvas) {
+    return typeof HTMLCanvasElement !== "undefined" && canvas instanceof HTMLCanvasElement;
+}

package/dist/resourceProvider.d.ts

@@ -0,0 +1,24 @@
+export type ResourceDescriptor = {
+    id: string;
+    namespace: string;
+    key: string;
+    role: string;
+    provenance: Record<string, unknown>;
+    expectedSize?: {
+        width: number;
+        height: number;
+    };
+};
+export type ResourceSource = Blob | ArrayBuffer | Uint8Array | TexImageSource;
+export type ProvidedResource = {
+    source: ResourceSource;
+};
+export type ResourceContext = {
+    signal: AbortSignal;
+};
+/** Resolves a semantic renderer resource through arbitrary caller-owned logic. */
+export interface ResourceProvider {
+    provide(descriptor: ResourceDescriptor, context: ResourceContext): Promise<ProvidedResource | null>;
+    cacheIdentity?(descriptor: ResourceDescriptor): string | null;
+}
+export declare function profileResourceDescriptors(preparation: Record<string, unknown>): ResourceDescriptor[];