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

package/dist/prebuiltSdfAtlas.js

@@ -0,0 +1,261 @@
+import { glyphKey } from "./fontSdfAtlas.js";
+const MAX_DECODED_PAGES_PER_PROVIDER = 6;
+const providerCaches = new WeakMap();
+export function createHttpPrebuiltSdfAtlasProvider(baseUrl) {
+    const root = baseUrl.replace(/\/+$/, "");
+    const familyPath = (family) => encodeURIComponent(family);
+    return {
+        async manifest(family, { signal }) {
+            const response = await fetch(`${root}/${familyPath(family)}/manifest.json`, { signal, cache: "force-cache" });
+            if (response.status === 404)
+                return null;
+            if (!response.ok)
+                throw new Error(`prebuilt atlas manifest ${family}: HTTP ${response.status}`);
+            return response.json();
+        },
+        async page(family, file, { signal }) {
+            if (!/^page-\d{3}\.r8swz\.br$/.test(file))
+                throw new Error(`invalid prebuilt atlas page path ${file}`);
+            const response = await fetch(`${root}/${familyPath(family)}/${file}`, { signal, cache: "force-cache" });
+            if (!response.ok)
+                throw new Error(`prebuilt atlas page ${family}/${file}: HTTP ${response.status}`);
+            return response.arrayBuffer();
+        },
+    };
+}
+export async function buildPrebuiltSdfAtlas(provider, requests, signal, maxPages = 6) {
+    const families = [...new Set(requests.map((request) => request.family))];
+    const manifests = new Map();
+    for (const family of families) {
+        const manifest = await cachedManifest(provider, family, signal);
+        if (!manifest || !isValidPrebuiltSdfAtlasManifest(manifest, family))
+            return null;
+        manifests.set(family, manifest);
+    }
+    const glyphByFamily = new Map([...manifests].map(([family, manifest]) => [
+        family,
+        new Map(manifest.glyphs.map((glyph) => [glyph.codepoint, glyph])),
+    ]));
+    const resolved = requests.map((request) => {
+        const codepoint = singleCodepoint(request.char);
+        const glyph = codepoint == null ? undefined : glyphByFamily.get(request.family)?.get(codepoint);
+        return glyph ? { request, glyph } : null;
+    });
+    if (resolved.some((entry) => entry == null))
+        return null;
+    const sourcePages = [...new Map(resolved.map((entry) => {
+            const value = entry;
+            const key = `${value.request.family}\0${value.glyph.page}`;
+            return [key, { family: value.request.family, sourcePage: value.glyph.page }];
+        })).values()];
+    if (sourcePages.length > maxPages)
+        return null;
+    const compactPage = new Map(sourcePages.map((page, index) => [`${page.family}\0${page.sourcePage}`, index]));
+    const pagePromises = new Map();
+    const controller = new AbortController();
+    const combined = combineSignals(signal, controller.signal);
+    let released = false;
+    const pagePixels = (page) => {
+        const cached = pagePromises.get(page);
+        if (cached)
+            return cached;
+        const source = sourcePages[page];
+        const manifest = manifests.get(source.family);
+        const descriptor = manifest.pages[source.sourcePage];
+        const promise = cachedDecodedPage(provider, source.family, descriptor, combined.signal);
+        pagePromises.set(page, promise);
+        return promise;
+    };
+    const glyphs = new Map(resolved.map((entry) => {
+        const { request, glyph } = entry;
+        const manifest = manifests.get(request.family);
+        const descriptor = manifest.pages[glyph.page];
+        const page = compactPage.get(`${request.family}\0${glyph.page}`);
+        const [x, y, width, height] = glyph.rect;
+        const key = glyphKey(request.region, request.fontSourceHash, request.family, request.char);
+        return [key, {
+                key,
+                resourceId: `prebuilt:${manifest.font_sha256}:${glyph.codepoint}`,
+                glyphIndex: glyph.codepoint,
+                page,
+                pageEpoch: 1,
+                region: request.region,
+                family: request.family,
+                fontSourceHash: request.fontSourceHash,
+                char: request.char,
+                u0: x / descriptor.width,
+                v0: y / descriptor.height,
+                u1: (x + width) / descriptor.width,
+                v1: (y + height) / descriptor.height,
+                width,
+                height,
+                advance: glyph.plane_advance_x,
+                xOffset: glyph.plane_bearing[0],
+                yOffset: glyph.plane_bearing[1],
+                planeBearingX: glyph.plane_bearing[0],
+                planeBearingY: glyph.plane_bearing[1],
+                planeWidth: glyph.plane_size[0],
+                planeHeight: glyph.plane_size[1],
+                drawable: width > 0 && height > 0,
+            }];
+    }));
+    const first = manifests.values().next().value;
+    const contractId = `prebuilt:${[...manifests.values()].map((manifest) => manifest.font_sha256).join(":")}:${sourcePages.map((page) => `${page.family}:${page.sourcePage}`).join(",")}`;
+    return {
+        width: 2048,
+        height: 2048,
+        depth: sourcePages.length,
+        baseSize: first.point_size,
+        spread: first.spread,
+        glyphs,
+        missing: [],
+        backend: "freetype-wasm",
+        sdfBackend: "edt",
+        contractId,
+        fontEngineFingerprint: first.generator_contract,
+        perf: {
+            backend: "edt",
+            fontBatches: [],
+            totalGlyphMs: 0,
+            totalFaceLoadMs: 0,
+            totalGlyphCount: 0,
+            totalPixelCount: 0,
+            worker: emptyWorkerStats(),
+            cache: {
+                hits: glyphs.size, misses: 0, generations: 0, bytes: sourcePages.length * 2048 * 2048,
+                sessionHits: glyphs.size, persistentHits: 0, persistentMisses: 0,
+                persistentWritesQueued: 0, pages: sourcePages.length, pinnedPages: sourcePages.length, pageEvictions: 0,
+            },
+        },
+        async pageUpdates(revisions) {
+            const updates = [];
+            for (let page = 0; page < sourcePages.length; page += 1) {
+                if ((revisions.get(page) ?? 0) >= 1)
+                    continue;
+                updates.push({
+                    page, pageWidth: 2048, pageEpoch: 1, revision: 1, fullUpload: true,
+                    pixels: await pagePixels(page), dirtyRects: [],
+                });
+            }
+            return updates;
+        },
+        async release() {
+            if (released)
+                return;
+            released = true;
+            controller.abort();
+            combined.dispose();
+            pagePromises.clear();
+        },
+    };
+}
+function providerCache(provider) {
+    let cache = providerCaches.get(provider);
+    if (!cache) {
+        cache = { manifests: new Map(), decodedPages: new Map() };
+        providerCaches.set(provider, cache);
+    }
+    return cache;
+}
+async function cachedManifest(provider, family, signal) {
+    if (signal.aborted)
+        throw abortReason(signal);
+    const cache = providerCache(provider).manifests;
+    if (cache.has(family))
+        return cache.get(family) ?? null;
+    const manifest = await provider.manifest(family, { signal });
+    if (!signal.aborted)
+        cache.set(family, manifest);
+    return manifest;
+}
+async function cachedDecodedPage(provider, family, descriptor, signal) {
+    if (signal.aborted)
+        throw abortReason(signal);
+    const cache = providerCache(provider).decodedPages;
+    const key = `${family}\0${descriptor.file}\0${descriptor.file_sha256}`;
+    const cached = cache.get(key);
+    if (cached) {
+        cache.delete(key);
+        cache.set(key, cached);
+        return cached;
+    }
+    const buffer = await provider.page(family, descriptor.file, { signal });
+    const bytes = new Uint8Array(buffer);
+    await verifySha256(bytes, descriptor.file_sha256);
+    if (signal.aborted)
+        throw abortReason(signal);
+    const decoded = unswizzleR8(bytes, descriptor.width, descriptor.height);
+    cache.set(key, decoded);
+    while (cache.size > MAX_DECODED_PAGES_PER_PROVIDER) {
+        const oldest = cache.keys().next().value;
+        if (oldest == null)
+            break;
+        cache.delete(oldest);
+    }
+    return decoded;
+}
+function abortReason(signal) {
+    return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+}
+export function isValidPrebuiltSdfAtlasManifest(manifest, family) {
+    return manifest.schema === "allium.sdf-atlas-manifest.v1"
+        && manifest.font_family === family
+        && manifest.font_sha256.length === 64
+        && Number.isFinite(manifest.point_size) && manifest.point_size > 0
+        && Number.isFinite(manifest.spread) && manifest.spread > 0
+        && manifest.pages.length > 0
+        && manifest.pages.every((page) => page.width === 2048 && page.height === 2048 && /^page-\d{3}\.r8swz\.br$/.test(page.file));
+}
+function singleCodepoint(value) {
+    const values = [...value];
+    return values.length === 1 ? values[0].codePointAt(0) ?? null : null;
+}
+function unswizzleR8(bytes, width, height) {
+    const header = 64;
+    const payloadLength = width * height;
+    if (bytes.byteLength !== header + payloadLength)
+        throw new Error(`invalid R8SWZ page length ${bytes.byteLength}`);
+    if (new TextDecoder().decode(bytes.subarray(0, 10)) !== "ALLIUMSWZ8")
+        throw new Error("invalid R8SWZ page magic");
+    const output = new Uint8Array(payloadLength);
+    const blocksPerRow = width / 8;
+    for (let y = 0; y < height; y += 1) {
+        const blockY = Math.floor(y / 8);
+        const inY = y % 8;
+        for (let x = 0; x < width; x += 1) {
+            const block = blockY * blocksPerRow + Math.floor(x / 8);
+            output[y * width + x] = bytes[header + block * 64 + inY * 8 + (x % 8)];
+        }
+    }
+    return output;
+}
+async function verifySha256(bytes, expected) {
+    const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes.slice().buffer));
+    const actual = [...digest].map((value) => value.toString(16).padStart(2, "0")).join("");
+    if (actual !== expected.toLowerCase())
+        throw new Error(`prebuilt atlas page hash mismatch: expected ${expected}, got ${actual}`);
+}
+function combineSignals(first, second) {
+    const controller = new AbortController();
+    const abort = (event) => controller.abort(event.target.reason);
+    first.addEventListener("abort", abort, { once: true });
+    second.addEventListener("abort", abort, { once: true });
+    if (first.aborted)
+        controller.abort(first.reason);
+    else if (second.aborted)
+        controller.abort(second.reason);
+    return {
+        signal: controller.signal,
+        dispose() {
+            first.removeEventListener("abort", abort);
+            second.removeEventListener("abort", abort);
+        },
+    };
+}
+function emptyWorkerStats() {
+    return {
+        protocol: "allium.renderer-worker/2",
+        initialized: true, scenes: 0, masterDataSessions: 0, atlasSessions: 0,
+        authoringSessions: 0, fonts: 0, requests: 0, failures: 0, wasmMs: 0, bridgeBytes: 0,
+    };
+}

package/dist/protocol.d.ts

@@ -0,0 +1,456 @@
+import type { CoreSceneCreateResponse, CoreSceneDelta, CoreSceneDump, StableId } from "./types/core.js";
+import type { FreeTypeGlyphBatch, FreeTypeGlyphMapBatch } from "./types/freeType.js";
+import type { WasmGlyphDemandBatch, WasmLayoutBatch } from "./types/layout.js";
+import type { AtlasGenerateRequest, AtlasGlyphRecord, AtlasPageUpdate, GlyphRasterPlan, AtlasResolveResult, AtlasStats } from "./types/atlas.js";
+import type { AuthoringCheckpoint, AuthoringCommand, AuthoringDelta, AuthoringSelection, GameProfileDocument } from "./types/authoring.js";
+export declare const RENDERER_WORKER_PROTOCOL: "allium.renderer-worker/2";
+export type RendererWorkerInit = {
+    moduleUrl: string;
+    wasmUrl?: string;
+};
+export type RegisteredFont = {
+    region: string;
+    family: string;
+    sourceHash: string;
+    bytes: ArrayBuffer;
+};
+export type GlyphBatchRequest = {
+    region: string;
+    family: string;
+    sourceHash: string;
+    chars: string[];
+    backend?: "edt" | "analytic";
+    supersample?: number;
+};
+export type RendererFontContract = {
+    font_engine_fingerprint: string;
+    freetype_version: string;
+    modules: string[];
+    load_contract: string;
+};
+export type LayerMaskOverride = {
+    layerId: StableId;
+    visible: boolean | null;
+};
+export type RendererWorkerStats = {
+    protocol: typeof RENDERER_WORKER_PROTOCOL;
+    initialized: boolean;
+    scenes: number;
+    masterDataSessions: number;
+    atlasSessions: number;
+    authoringSessions: number;
+    fonts: number;
+    requests: number;
+    failures: number;
+    wasmMs: number;
+    bridgeBytes: number;
+};
+export type RendererWorkerRequest = {
+    id: number;
+    kind: "init";
+    payload: RendererWorkerInit;
+} | {
+    id: number;
+    kind: "contract";
+    payload: Record<string, never>;
+} | {
+    id: number;
+    kind: "registerFont";
+    payload: RegisteredFont;
+} | {
+    id: number;
+    kind: "mapGlyphs";
+    payload: GlyphBatchRequest;
+} | {
+    id: number;
+    kind: "planGlyphs";
+    payload: GlyphBatchRequest;
+} | {
+    id: number;
+    kind: "buildGlyphs";
+    payload: GlyphBatchRequest;
+} | {
+    id: number;
+    kind: "createAtlas";
+    payload: {
+        pageWidth?: number;
+        pageHeight?: number;
+        softPages?: number;
+        hardPages?: number;
+    };
+} | {
+    id: number;
+    kind: "resolveAtlas";
+    payload: {
+        atlasId: string;
+        keys: string[];
+        cached: AtlasGlyphRecord[];
+        generate: AtlasGenerateRequest[];
+    };
+} | {
+    id: number;
+    kind: "atlasPages";
+    payload: {
+        atlasId: string;
+        revisions: Array<{
+            page: number;
+            revision: number;
+        }>;
+    };
+} | {
+    id: number;
+    kind: "releaseAtlas";
+    payload: {
+        atlasId: string;
+        lease: number;
+    };
+} | {
+    id: number;
+    kind: "destroyAtlas";
+    payload: {
+        atlasId: string;
+    };
+} | {
+    id: number;
+    kind: "createAuthoringBlank";
+    payload: Record<string, never>;
+} | {
+    id: number;
+    kind: "importAuthoringProfile";
+    payload: {
+        profile: unknown;
+    };
+} | {
+    id: number;
+    kind: "restoreAuthoringCheckpoint";
+    payload: {
+        checkpoint: AuthoringCheckpoint;
+    };
+} | {
+    id: number;
+    kind: "applyAuthoring";
+    payload: {
+        authoringId: string;
+        command: AuthoringCommand;
+    };
+} | {
+    id: number;
+    kind: "selectAuthoring";
+    payload: {
+        authoringId: string;
+        id: number | null;
+    };
+} | {
+    id: number;
+    kind: "elementsAuthoring";
+    payload: {
+        authoringId: string;
+    };
+} | {
+    id: number;
+    kind: "beginAuthoringGesture";
+    payload: {
+        authoringId: string;
+        id: number;
+    };
+} | {
+    id: number;
+    kind: "previewAuthoringGesture";
+    payload: {
+        authoringId: string;
+        command: AuthoringCommand;
+    };
+} | {
+    id: number;
+    kind: "commitAuthoringGesture";
+    payload: {
+        authoringId: string;
+    };
+} | {
+    id: number;
+    kind: "cancelAuthoringGesture";
+    payload: {
+        authoringId: string;
+    };
+} | {
+    id: number;
+    kind: "appendAuthoringPage";
+    payload: {
+        authoringId: string;
+    };
+} | {
+    id: number;
+    kind: "duplicateAuthoringPage";
+    payload: {
+        authoringId: string;
+        page: number;
+    };
+} | {
+    id: number;
+    kind: "deleteAuthoringPage";
+    payload: {
+        authoringId: string;
+        page: number;
+    };
+} | {
+    id: number;
+    kind: "moveAuthoringPage";
+    payload: {
+        authoringId: string;
+        fromPage: number;
+        page: number;
+    };
+} | {
+    id: number;
+    kind: "undoAuthoring";
+    payload: {
+        authoringId: string;
+    };
+} | {
+    id: number;
+    kind: "redoAuthoring";
+    payload: {
+        authoringId: string;
+    };
+} | {
+    id: number;
+    kind: "exportAuthoring";
+    payload: {
+        authoringId: string;
+    };
+} | {
+    id: number;
+    kind: "checkpointAuthoring";
+    payload: {
+        authoringId: string;
+    };
+} | {
+    id: number;
+    kind: "destroyAuthoring";
+    payload: {
+        authoringId: string;
+    };
+} | {
+    id: number;
+    kind: "layoutText";
+    payload: {
+        request: unknown;
+    };
+} | {
+    id: number;
+    kind: "glyphDemand";
+    payload: {
+        request: unknown;
+    };
+} | {
+    id: number;
+    kind: "createMasterData";
+    payload: {
+        region: string;
+        revision: string;
+    };
+} | {
+    id: number;
+    kind: "putMasterDataTable";
+    payload: {
+        masterDataId: string;
+        name: string;
+        table: unknown;
+    };
+} | {
+    id: number;
+    kind: "sealMasterData";
+    payload: {
+        masterDataId: string;
+    };
+} | {
+    id: number;
+    kind: "prepareProfile";
+    payload: {
+        masterDataId: string;
+        request: unknown;
+    };
+} | {
+    id: number;
+    kind: "createProfileScene";
+    payload: {
+        masterDataId: string;
+        request: unknown;
+        layoutRequest: unknown;
+    };
+} | {
+    id: number;
+    kind: "destroyMasterData";
+    payload: {
+        masterDataId: string;
+    };
+} | {
+    id: number;
+    kind: "createScene";
+    payload: {
+        request: unknown;
+    };
+} | {
+    id: number;
+    kind: "advance";
+    payload: {
+        sceneId: string;
+        tick: number;
+    };
+} | {
+    id: number;
+    kind: "setLayerMask";
+    payload: {
+        sceneId: string;
+        layerId: StableId;
+        visible: boolean;
+    };
+} | {
+    id: number;
+    kind: "setLayerMasks";
+    payload: {
+        sceneId: string;
+        expectedLayerTableRevision: number;
+        overrides: LayerMaskOverride[];
+    };
+} | {
+    id: number;
+    kind: "setTab";
+    payload: {
+        sceneId: string;
+        controlId: StableId;
+        value: string;
+    };
+} | {
+    id: number;
+    kind: "scroll";
+    payload: {
+        sceneId: string;
+        controlId: StableId;
+        offset?: number;
+        delta?: number;
+    };
+} | {
+    id: number;
+    kind: "dumpScene";
+    payload: {
+        sceneId: string;
+    };
+} | {
+    id: number;
+    kind: "destroyScene";
+    payload: {
+        sceneId: string;
+    };
+} | {
+    id: number;
+    kind: "stats";
+    payload: Record<string, never>;
+};
+export type RendererWorkerResult = {
+    kind: "init";
+    protocol: typeof RENDERER_WORKER_PROTOCOL;
+} | {
+    kind: "contract";
+    contract: RendererFontContract;
+} | {
+    kind: "registerFont";
+    registered: boolean;
+} | {
+    kind: "mapGlyphs";
+    batch: FreeTypeGlyphMapBatch;
+} | {
+    kind: "planGlyphs";
+    plan: GlyphRasterPlan;
+} | {
+    kind: "buildGlyphs";
+    batch: FreeTypeGlyphBatch;
+} | {
+    kind: "createAtlas";
+    atlasId: string;
+    stats: AtlasStats;
+} | {
+    kind: "resolveAtlas";
+    result: AtlasResolveResult;
+} | {
+    kind: "atlasPages";
+    updates: AtlasPageUpdate[];
+} | {
+    kind: "releaseAtlas";
+    released: boolean;
+} | {
+    kind: "destroyAtlas";
+    destroyed: boolean;
+} | {
+    kind: "createAuthoring";
+    authoringId: string;
+    document: GameProfileDocument;
+    revision: number;
+} | {
+    kind: "authoringDelta";
+    delta: AuthoringDelta | null;
+} | {
+    kind: "elementsAuthoring";
+    elements: AuthoringSelection[];
+} | {
+    kind: "exportAuthoring";
+    document: GameProfileDocument;
+} | {
+    kind: "checkpointAuthoring";
+    checkpoint: AuthoringCheckpoint;
+} | {
+    kind: "destroyAuthoring";
+    destroyed: boolean;
+} | {
+    kind: "layoutText";
+    batch: WasmLayoutBatch;
+} | {
+    kind: "glyphDemand";
+    batch: WasmGlyphDemandBatch;
+} | {
+    kind: "createMasterData";
+    masterDataId: string;
+    report: Record<string, unknown>;
+} | {
+    kind: "masterDataReport";
+    report: Record<string, unknown>;
+} | {
+    kind: "prepareProfile";
+    preparation: Record<string, unknown>;
+} | {
+    kind: "destroyMasterData";
+    destroyed: boolean;
+} | {
+    kind: "createProfileScene";
+    sceneId: string;
+    response: CoreSceneCreateResponse;
+    layout: WasmLayoutBatch;
+} | {
+    kind: "createScene";
+    sceneId: string;
+    response: CoreSceneCreateResponse;
+} | {
+    kind: "delta";
+    delta: CoreSceneDelta;
+} | {
+    kind: "dumpScene";
+    dump: CoreSceneDump;
+} | {
+    kind: "destroyScene";
+    destroyed: boolean;
+} | {
+    kind: "stats";
+    stats: RendererWorkerStats;
+};
+export type RendererWorkerResponse = {
+    id: number;
+    ok: true;
+    result: RendererWorkerResult;
+} | {
+    id: number;
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};

package/dist/protocol.js

@@ -0,0 +1 @@
+export const RENDERER_WORKER_PROTOCOL = "allium.renderer-worker/2";