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

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { BrowserRenderer, BrowserRendererError, BrowserScene, } from "./renderer.js";
+export { BrowserAuthoringClient } from "./authoring.js";
+export type { BrowserRendererOptions, MasterDataTableLoader, MasterDataTableRequest, ProfileSceneCreateOptions, } from "./renderer.js";
+export type { ProvidedResource, ResourceContext, ResourceDescriptor, ResourceProvider, ResourceSource, } from "./resourceProvider.js";
+export { LocalizationProviderManager } from "./localizationProvider.js";
+export type { LocalizationContext, LocalizationProvider, LocalizationProviderStats, LocalizationRequest, } from "./localizationProvider.js";
+export { FontProviderManager } from "./fontProvider.js";
+export type { FontContext, FontProvider, FontProviderStats, FontRequest, ProvidedFont, } from "./fontProvider.js";
+export { createHttpPrebuiltSdfAtlasProvider, isValidPrebuiltSdfAtlasManifest, } from "./prebuiltSdfAtlas.js";
+export type { PrebuiltSdfAtlasGlyph, PrebuiltSdfAtlasManifest, PrebuiltSdfAtlasPage, PrebuiltSdfAtlasProvider, } from "./prebuiltSdfAtlas.js";
+export { createOriginPrebuiltSdfAtlasPackage, PrebuiltSdfAtlasStorageError, } from "./originPrebuiltSdfAtlasPackage.js";
+export type { OriginPrebuiltSdfAtlasPackage, PrebuiltSdfAtlasInstallOptions, PrebuiltSdfAtlasInstallProgress, PrebuiltSdfAtlasPackageStatus, PrebuiltSdfAtlasStorageErrorCode, } from "./originPrebuiltSdfAtlasPackage.js";
+export type { CoreControlBinding, CoreInteractionRegion, CoreSceneDelta, CoreSceneDump, StableId, } from "./types/core.js";
+export type { RendererFontContract, RendererWorkerStats, } from "./protocol.js";
+export type { RendererMasterData, } from "./worker-client.js";
+export { RendererAuthoringDocument } from "./worker-client.js";
+export { AUTHORING_CHECKPOINT_SCHEMA } from "./types/authoring.js";
+export type { AuthoringCheckpoint, AuthoringCategory, AuthoringChangeKind, AuthoringCommand, AuthoringDelta, AuthoringElementChange, AuthoringSelection, AuthoringElementId, AuthoringPageChange, AuthoringPageChangeKind, GameProfileDocument, } from "./types/authoring.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export { BrowserRenderer, BrowserRendererError, BrowserScene, } from "./renderer.js";
+export { BrowserAuthoringClient } from "./authoring.js";
+export { LocalizationProviderManager } from "./localizationProvider.js";
+export { FontProviderManager } from "./fontProvider.js";
+export { createHttpPrebuiltSdfAtlasProvider, isValidPrebuiltSdfAtlasManifest, } from "./prebuiltSdfAtlas.js";
+export { createOriginPrebuiltSdfAtlasPackage, PrebuiltSdfAtlasStorageError, } from "./originPrebuiltSdfAtlasPackage.js";
+export { RendererAuthoringDocument } from "./worker-client.js";
+export { AUTHORING_CHECKPOINT_SCHEMA } from "./types/authoring.js";

package/dist/interaction/numericTextRegions.d.ts

@@ -0,0 +1,46 @@
+import type { GlyphInstance } from "../types/glyph.js";
+type NumericRun = {
+    text: string;
+    plain_start: number;
+    plain_end: number;
+};
+type NumericCommand = {
+    id: string;
+    layer_id: string;
+    clip?: Array<[number, number]> | null;
+    numeric_text_runs?: NumericRun[];
+};
+export type NumericTextRegion = {
+    id: string;
+    layer_id: string;
+    role: "numeric_run";
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    quad: [[number, number], [number, number], [number, number], [number, number]];
+    hit_geometry: [[number, number], [number, number], [number, number], [number, number]];
+    clip: Array<[number, number]> | null;
+    resolved_data: {
+        text: string;
+        plain_start: number;
+        plain_end: number;
+    };
+    capabilities: [];
+    render_mask: boolean;
+};
+export type NumericRegionRuntimeState = {
+    layerTransform: {
+        dx: number;
+        dy: number;
+    };
+    commandTransform: {
+        dx: number;
+        dy: number;
+    };
+};
+export declare function buildNumericTextRegions(command: NumericCommand, instances: Array<Pick<GlyphInstance, "layerId" | "plainTextIndex" | "deviceCharQuad">>, renderMask: boolean, runtimeState?: NumericRegionRuntimeState): NumericTextRegion[];
+export declare function applyNumericRegionRuntimeState(region: NumericTextRegion, state: NumericRegionRuntimeState): NumericTextRegion;
+export {};

package/dist/interaction/numericTextRegions.js

@@ -0,0 +1,44 @@
+export function buildNumericTextRegions(command, instances, renderMask, runtimeState) {
+    return (command.numeric_text_runs ?? []).flatMap((run) => {
+        const points = instances
+            .filter((instance) => instance.layerId === command.id && instance.plainTextIndex >= run.plain_start && instance.plainTextIndex < run.plain_end)
+            .flatMap((instance) => instance.deviceCharQuad[1]);
+        if (points.length === 0)
+            return [];
+        const minX = Math.min(...points.map(([x]) => x));
+        const minY = Math.min(...points.map(([, y]) => y));
+        const maxX = Math.max(...points.map(([x]) => x));
+        const maxY = Math.max(...points.map(([, y]) => y));
+        const quad = [[minX, minY], [maxX, minY], [maxX, maxY], [minX, maxY]];
+        const region = {
+            id: `${command.id}:numeric:${run.plain_start}:${run.plain_end}`,
+            layer_id: command.layer_id,
+            role: "numeric_run",
+            bounds: { x: minX, y: minY, width: maxX - minX, height: maxY - minY },
+            quad,
+            hit_geometry: quad,
+            clip: command.clip ?? null,
+            resolved_data: { text: run.text, plain_start: run.plain_start, plain_end: run.plain_end },
+            capabilities: [],
+            render_mask: renderMask,
+        };
+        return [runtimeState ? applyNumericRegionRuntimeState(region, runtimeState) : region];
+    });
+}
+export function applyNumericRegionRuntimeState(region, state) {
+    const dx = state.layerTransform.dx + state.commandTransform.dx;
+    const dy = state.layerTransform.dy + state.commandTransform.dy;
+    const translate = ([x, y]) => [x + dx, y + dy];
+    const translateClip = ([x, y]) => [
+        x + state.layerTransform.dx,
+        y + state.layerTransform.dy,
+    ];
+    const quad = region.quad.map(translate);
+    return {
+        ...region,
+        bounds: { ...region.bounds, x: region.bounds.x + dx, y: region.bounds.y + dy },
+        quad,
+        hit_geometry: quad,
+        clip: region.clip?.map(translateClip) ?? null,
+    };
+}

package/dist/localizationProvider.d.ts

@@ -0,0 +1,33 @@
+export type LocalizationRequest = {
+    region: string;
+    locale: string;
+    key: string;
+};
+export type LocalizationContext = {
+    signal: AbortSignal;
+};
+/** Resolves renderer-owned UI text through arbitrary caller-owned logic. */
+export interface LocalizationProvider {
+    provide(request: LocalizationRequest, context: LocalizationContext): Promise<string | null>;
+}
+export type LocalizationProviderManagerOptions = {
+    provider: LocalizationProvider;
+    concurrency?: number;
+};
+export type LocalizationProviderStats = {
+    requested: number;
+    unique: number;
+    resolved: number;
+    failures: number;
+    active: number;
+    peakActive: number;
+    resolveMs: number;
+};
+export declare class LocalizationProviderManager {
+    private readonly provider;
+    private readonly concurrency;
+    private readonly counters;
+    constructor(options: LocalizationProviderManagerOptions);
+    resolve(requests: readonly LocalizationRequest[], signal?: AbortSignal): Promise<Record<string, string>>;
+    stats(): LocalizationProviderStats;
+}

package/dist/localizationProvider.js

@@ -0,0 +1,74 @@
+export class LocalizationProviderManager {
+    provider;
+    concurrency;
+    counters = {
+        requested: 0,
+        unique: 0,
+        resolved: 0,
+        failures: 0,
+        active: 0,
+        peakActive: 0,
+        resolveMs: 0,
+    };
+    constructor(options) {
+        if (!options.provider || typeof options.provider.provide !== "function") {
+            throw new Error("localization provider is required");
+        }
+        const concurrency = options.concurrency ?? 8;
+        if (!Number.isInteger(concurrency) || concurrency <= 0) {
+            throw new Error("localization concurrency must be a positive integer");
+        }
+        this.provider = options.provider;
+        this.concurrency = concurrency;
+    }
+    async resolve(requests, signal = new AbortController().signal) {
+        const started = performance.now();
+        const unique = [...new Map(requests.map((request) => [
+                `${request.region}\0${request.locale}\0${request.key}`,
+                request,
+            ])).values()];
+        this.counters.requested += requests.length;
+        this.counters.unique += unique.length;
+        const values = new Map();
+        let cursor = 0;
+        const worker = async () => {
+            while (cursor < unique.length) {
+                if (signal.aborted)
+                    throw abortReason(signal);
+                const request = unique[cursor++];
+                this.counters.active += 1;
+                this.counters.peakActive = Math.max(this.counters.peakActive, this.counters.active);
+                let value;
+                try {
+                    value = await this.provider.provide(request, { signal });
+                }
+                catch (error) {
+                    this.counters.failures += 1;
+                    throw error;
+                }
+                finally {
+                    this.counters.active -= 1;
+                }
+                if (typeof value !== "string") {
+                    this.counters.failures += 1;
+                    throw new Error(`localization provider returned no text for ${request.locale}:${request.key}`);
+                }
+                this.counters.resolved += 1;
+                values.set(request.key, value);
+            }
+        };
+        try {
+            await Promise.all(Array.from({ length: Math.min(this.concurrency, unique.length) }, worker));
+            return Object.fromEntries(values);
+        }
+        finally {
+            this.counters.resolveMs += performance.now() - started;
+        }
+    }
+    stats() {
+        return { ...this.counters };
+    }
+}
+function abortReason(signal) {
+    return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}

package/dist/originPrebuiltSdfAtlasPackage.d.ts

@@ -0,0 +1,39 @@
+import { type PrebuiltSdfAtlasProvider } from "./prebuiltSdfAtlas.js";
+export type PrebuiltSdfAtlasInstallProgress = {
+    family: string;
+    completedPages: number;
+    totalPages: number;
+    storedBytes: number;
+    totalBytes: number;
+};
+export type PrebuiltSdfAtlasPackageStatus = {
+    namespace: string;
+    storageAvailable: boolean;
+    installedFamilies: string[];
+    installedPages: number;
+    storedBytes: number;
+};
+export type PrebuiltSdfAtlasInstallOptions = {
+    concurrency?: number;
+    onProgress?: (progress: PrebuiltSdfAtlasInstallProgress) => void;
+    requestPersistence?: boolean;
+    signal?: AbortSignal;
+};
+export type OriginPrebuiltSdfAtlasPackage = {
+    readonly namespace: string;
+    readonly provider: PrebuiltSdfAtlasProvider;
+    install(families: readonly string[], options?: PrebuiltSdfAtlasInstallOptions): Promise<PrebuiltSdfAtlasPackageStatus>;
+    remove(families?: readonly string[]): Promise<void>;
+    status(families: readonly string[]): Promise<PrebuiltSdfAtlasPackageStatus>;
+    close(): void;
+};
+export type PrebuiltSdfAtlasStorageErrorCode = "PREBUILT_ATLAS_STORAGE_UNAVAILABLE" | "PREBUILT_ATLAS_INVALID_MANIFEST" | "PREBUILT_ATLAS_QUOTA" | "PREBUILT_ATLAS_PAGE_HASH";
+export declare class PrebuiltSdfAtlasStorageError extends Error {
+    readonly code: PrebuiltSdfAtlasStorageErrorCode;
+    constructor(code: PrebuiltSdfAtlasStorageErrorCode, message: string);
+}
+export declare function createOriginPrebuiltSdfAtlasPackage(options: {
+    namespace: string;
+    source: PrebuiltSdfAtlasProvider;
+    databaseName?: string;
+}): OriginPrebuiltSdfAtlasPackage;

package/dist/originPrebuiltSdfAtlasPackage.js

@@ -0,0 +1,316 @@
+import { isValidPrebuiltSdfAtlasManifest, } from "./prebuiltSdfAtlas.js";
+const DATABASE_NAME = "sekai-custom-profile-sdk-prebuilt-atlas-v1";
+const DATABASE_VERSION = 1;
+const ENTRY_STORE = "entries";
+export class PrebuiltSdfAtlasStorageError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "PrebuiltSdfAtlasStorageError";
+    }
+}
+export function createOriginPrebuiltSdfAtlasPackage(options) {
+    if (!options.namespace.trim())
+        throw new TypeError("prebuilt atlas namespace must be non-empty");
+    const storage = new OriginPrebuiltAtlasStorage(options.databaseName ?? DATABASE_NAME);
+    const manifestCache = new Map();
+    const namespace = options.namespace.trim();
+    const installedManifest = async (family) => {
+        const cached = manifestCache.get(family);
+        if (cached)
+            return cached;
+        const record = await storage.getManifest(namespace, family);
+        if (!record || !isValidPrebuiltSdfAtlasManifest(record.manifest, family))
+            return null;
+        manifestCache.set(family, record.manifest);
+        return record.manifest;
+    };
+    const provider = {
+        async manifest(family, { signal }) {
+            if (signal.aborted)
+                throw abortReason(signal);
+            if (!storage.available)
+                return null;
+            try {
+                return await installedManifest(family);
+            }
+            catch {
+                return null;
+            }
+        },
+        async page(family, file, { signal }) {
+            if (signal.aborted)
+                throw abortReason(signal);
+            const manifest = await installedManifest(family);
+            const descriptor = manifest?.pages.find((page) => page.file === file);
+            if (!descriptor)
+                throw new Error(`prebuilt atlas page is not installed: ${family}/${file}`);
+            const record = await storage.getPage(namespace, family, file, descriptor.file_sha256);
+            if (!record) {
+                manifestCache.delete(family);
+                await storage.deleteManifest(namespace, family).catch(() => undefined);
+                throw new Error(`prebuilt atlas page is missing: ${family}/${file}`);
+            }
+            return record.bytes.slice(0);
+        },
+    };
+    return {
+        namespace,
+        provider,
+        async status(families) {
+            if (!storage.available)
+                return emptyStatus(namespace, false);
+            const records = await Promise.all(uniqueFamilies(families).map((family) => storage.getManifest(namespace, family)));
+            return records.reduce((status, record) => {
+                if (!record || !isValidPrebuiltSdfAtlasManifest(record.manifest, record.family))
+                    return status;
+                status.installedFamilies.push(record.family);
+                status.installedPages += record.installedPages;
+                status.storedBytes += record.storedBytes;
+                return status;
+            }, emptyStatus(namespace, true));
+        },
+        async install(families, installOptions = {}) {
+            if (!storage.available) {
+                throw new PrebuiltSdfAtlasStorageError("PREBUILT_ATLAS_STORAGE_UNAVAILABLE", "IndexedDB is unavailable for the prebuilt atlas package");
+            }
+            const signal = installOptions.signal ?? new AbortController().signal;
+            const requested = uniqueFamilies(families);
+            const current = await this.status(requested);
+            const installed = new Set(current.installedFamilies);
+            const missing = requested.filter((family) => !installed.has(family));
+            if (missing.length === 0)
+                return current;
+            const manifests = new Map();
+            for (const family of missing) {
+                if (signal.aborted)
+                    throw abortReason(signal);
+                const manifest = await options.source.manifest(family, { signal });
+                if (!manifest || !isValidPrebuiltSdfAtlasManifest(manifest, family)) {
+                    throw new PrebuiltSdfAtlasStorageError("PREBUILT_ATLAS_INVALID_MANIFEST", `prebuilt atlas manifest is invalid: ${family}`);
+                }
+                manifests.set(family, manifest);
+            }
+            const totalPages = [...manifests.values()].reduce((sum, manifest) => sum + manifest.pages.length, 0);
+            const totalBytes = [...manifests.values()].flatMap((manifest) => manifest.pages)
+                .reduce((sum, page) => sum + 64 + page.width * page.height, 0);
+            await assertStorageQuota(totalBytes);
+            if (installOptions.requestPersistence)
+                await requestOriginPersistence();
+            await storage.remove(namespace, missing);
+            manifestCache.clear();
+            const tasks = [...manifests].flatMap(([family, manifest]) => manifest.pages.map((page) => ({ family, page })));
+            const concurrency = boundedConcurrency(installOptions.concurrency ?? 4);
+            let cursor = 0;
+            let completedPages = 0;
+            let storedBytes = 0;
+            const familyBytes = new Map();
+            try {
+                await Promise.all(Array.from({ length: Math.min(concurrency, tasks.length) }, async () => {
+                    while (cursor < tasks.length) {
+                        const task = tasks[cursor++];
+                        if (signal.aborted)
+                            throw abortReason(signal);
+                        const buffer = await options.source.page(task.family, task.page.file, { signal });
+                        await assertPageHash(buffer, task.page.file_sha256, task.family, task.page.file);
+                        await storage.putPage({
+                            key: pageKey(namespace, task.family, task.page.file, task.page.file_sha256),
+                            kind: "page",
+                            namespace,
+                            family: task.family,
+                            file: task.page.file,
+                            sha256: task.page.file_sha256,
+                            bytes: buffer,
+                        });
+                        completedPages += 1;
+                        storedBytes += buffer.byteLength;
+                        familyBytes.set(task.family, (familyBytes.get(task.family) ?? 0) + buffer.byteLength);
+                        installOptions.onProgress?.({
+                            family: task.family,
+                            completedPages,
+                            totalPages,
+                            storedBytes,
+                            totalBytes,
+                        });
+                    }
+                }));
+                await storage.putManifests([...manifests].map(([family, manifest]) => ({
+                    key: manifestKey(namespace, family),
+                    kind: "manifest",
+                    namespace,
+                    family,
+                    manifest,
+                    installedPages: manifest.pages.length,
+                    storedBytes: familyBytes.get(family) ?? 0,
+                    installedAtMs: Date.now(),
+                })));
+            }
+            catch (error) {
+                await storage.remove(namespace, missing).catch(() => undefined);
+                throw error;
+            }
+            return this.status(requested);
+        },
+        async remove(families) {
+            manifestCache.clear();
+            if (!storage.available)
+                return;
+            await storage.remove(namespace, families == null ? undefined : uniqueFamilies(families));
+        },
+        close() {
+            manifestCache.clear();
+            storage.close();
+        },
+    };
+}
+class OriginPrebuiltAtlasStorage {
+    databaseName;
+    databasePromise = null;
+    constructor(databaseName) {
+        this.databaseName = databaseName;
+    }
+    get available() { return typeof indexedDB !== "undefined"; }
+    async getManifest(namespace, family) {
+        const record = await this.get(manifestKey(namespace, family));
+        return record?.kind === "manifest" ? record : null;
+    }
+    async getPage(namespace, family, file, sha256) {
+        const record = await this.get(pageKey(namespace, family, file, sha256));
+        return record?.kind === "page" ? record : null;
+    }
+    async putPage(record) {
+        const database = await this.database();
+        const transaction = database.transaction(ENTRY_STORE, "readwrite", { durability: "relaxed" });
+        transaction.objectStore(ENTRY_STORE).put(record);
+        await transactionDone(transaction);
+    }
+    async putManifests(records) {
+        const database = await this.database();
+        const transaction = database.transaction(ENTRY_STORE, "readwrite");
+        const store = transaction.objectStore(ENTRY_STORE);
+        for (const record of records)
+            store.put(record);
+        await transactionDone(transaction);
+    }
+    async deleteManifest(namespace, family) {
+        const database = await this.database();
+        const transaction = database.transaction(ENTRY_STORE, "readwrite");
+        transaction.objectStore(ENTRY_STORE).delete(manifestKey(namespace, family));
+        await transactionDone(transaction);
+    }
+    async remove(namespace, families) {
+        const database = await this.database();
+        const transaction = database.transaction(ENTRY_STORE, "readwrite");
+        const store = transaction.objectStore(ENTRY_STORE);
+        const prefixes = (families?.length ? families : [""]).map((family) => familyPrefix(namespace, family));
+        await deletePrefixes(store, prefixes);
+        await transactionDone(transaction);
+    }
+    close() {
+        void this.databasePromise?.then((database) => database.close());
+        this.databasePromise = null;
+    }
+    async get(key) {
+        const database = await this.database();
+        const transaction = database.transaction(ENTRY_STORE, "readonly");
+        const record = await request(transaction.objectStore(ENTRY_STORE).get(key));
+        await transactionDone(transaction);
+        return record ?? null;
+    }
+    database() {
+        if (!this.available)
+            return Promise.reject(new Error("IndexedDB is unavailable"));
+        this.databasePromise ??= new Promise((resolve, reject) => {
+            const open = indexedDB.open(this.databaseName, DATABASE_VERSION);
+            open.onupgradeneeded = () => {
+                if (!open.result.objectStoreNames.contains(ENTRY_STORE)) {
+                    open.result.createObjectStore(ENTRY_STORE, { keyPath: "key" });
+                }
+            };
+            open.onerror = () => reject(open.error ?? new Error("open IndexedDB prebuilt atlas storage failed"));
+            open.onblocked = () => reject(new Error("IndexedDB prebuilt atlas storage upgrade was blocked"));
+            open.onsuccess = () => {
+                open.result.onversionchange = () => open.result.close();
+                resolve(open.result);
+            };
+        });
+        return this.databasePromise;
+    }
+}
+function emptyStatus(namespace, storageAvailable) {
+    return { namespace, storageAvailable, installedFamilies: [], installedPages: 0, storedBytes: 0 };
+}
+function uniqueFamilies(families) {
+    return [...new Set(families.map((family) => family.trim()).filter(Boolean))];
+}
+function familyPrefix(namespace, family) {
+    return family ? `${namespace}\0${family}\0` : `${namespace}\0`;
+}
+function manifestKey(namespace, family) {
+    return `${familyPrefix(namespace, family)}manifest`;
+}
+function pageKey(namespace, family, file, sha256) {
+    return `${familyPrefix(namespace, family)}page\0${file}\0${sha256}`;
+}
+function boundedConcurrency(value) {
+    if (!Number.isInteger(value) || value <= 0)
+        throw new TypeError("prebuilt atlas install concurrency must be positive");
+    return Math.min(8, value);
+}
+async function assertStorageQuota(requiredBytes) {
+    if (typeof navigator === "undefined" || !navigator.storage?.estimate)
+        return;
+    const estimate = await navigator.storage.estimate();
+    if (estimate.quota == null || estimate.usage == null)
+        return;
+    const available = Math.max(0, estimate.quota - estimate.usage);
+    if (requiredBytes > available) {
+        throw new PrebuiltSdfAtlasStorageError("PREBUILT_ATLAS_QUOTA", `prebuilt atlas requires ${requiredBytes} bytes but only ${available} bytes are available`);
+    }
+}
+async function requestOriginPersistence() {
+    if (typeof navigator === "undefined" || !navigator.storage?.persist)
+        return;
+    await navigator.storage.persist();
+}
+async function assertPageHash(buffer, expected, family, file) {
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", buffer.slice(0)));
+    const actual = [...digest].map((value) => value.toString(16).padStart(2, "0")).join("");
+    if (actual !== expected.toLowerCase()) {
+        throw new PrebuiltSdfAtlasStorageError("PREBUILT_ATLAS_PAGE_HASH", `prebuilt atlas page hash mismatch: ${family}/${file}`);
+    }
+}
+function abortReason(signal) {
+    return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}
+function request(value) {
+    return new Promise((resolve, reject) => {
+        value.onsuccess = () => resolve(value.result);
+        value.onerror = () => reject(value.error ?? new Error("IndexedDB prebuilt atlas request failed"));
+    });
+}
+function transactionDone(transaction) {
+    return new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB prebuilt atlas transaction failed"));
+        transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB prebuilt atlas transaction aborted"));
+    });
+}
+function deletePrefixes(store, prefixes) {
+    return new Promise((resolve, reject) => {
+        const cursor = store.openKeyCursor();
+        cursor.onerror = () => reject(cursor.error ?? new Error("IndexedDB prebuilt atlas cursor failed"));
+        cursor.onsuccess = () => {
+            const value = cursor.result;
+            if (!value) {
+                resolve();
+                return;
+            }
+            const key = String(value.primaryKey);
+            if (prefixes.some((prefix) => key.startsWith(prefix)))
+                store.delete(value.primaryKey);
+            value.continue();
+        };
+    });
+}

package/dist/prebuiltSdfAtlas.d.ts

@@ -0,0 +1,36 @@
+import { type GlyphRequest, type SdfAtlas } from "./fontSdfAtlas.js";
+export type PrebuiltSdfAtlasPage = {
+    file: string;
+    width: number;
+    height: number;
+    file_sha256: string;
+};
+export type PrebuiltSdfAtlasGlyph = {
+    codepoint: number;
+    page: number;
+    rect: [number, number, number, number];
+    plane_bearing: [number, number];
+    plane_size: [number, number];
+    plane_advance_x: number;
+};
+export type PrebuiltSdfAtlasManifest = {
+    schema: "allium.sdf-atlas-manifest.v1";
+    generator_contract: string;
+    font_family: string;
+    font_sha256: string;
+    point_size: number;
+    spread: number;
+    pages: PrebuiltSdfAtlasPage[];
+    glyphs: PrebuiltSdfAtlasGlyph[];
+};
+export interface PrebuiltSdfAtlasProvider {
+    manifest(family: string, context: {
+        signal: AbortSignal;
+    }): Promise<PrebuiltSdfAtlasManifest | null>;
+    page(family: string, file: string, context: {
+        signal: AbortSignal;
+    }): Promise<ArrayBuffer>;
+}
+export declare function createHttpPrebuiltSdfAtlasProvider(baseUrl: string): PrebuiltSdfAtlasProvider;
+export declare function buildPrebuiltSdfAtlas(provider: PrebuiltSdfAtlasProvider, requests: GlyphRequest[], signal: AbortSignal, maxPages?: number): Promise<SdfAtlas | null>;
+export declare function isValidPrebuiltSdfAtlasManifest(manifest: PrebuiltSdfAtlasManifest, family: string): boolean;