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

package/dist/types/authoring.d.ts

@@ -0,0 +1,81 @@
+export type AuthoringElementId = number;
+export declare const AUTHORING_CHECKPOINT_SCHEMA: "allium.renderer-authoring-checkpoint/v1";
+export type AuthoringCategory = "bondsHonors" | "cardMembers" | "collections" | "generalBackgrounds" | "generals" | "honors" | "others" | "shapes" | "stamps" | "standMembers" | "storyBackgrounds" | "texts";
+export type AuthoringCommand = {
+    kind: "create";
+    page: number;
+    category: AuthoringCategory;
+    element: Record<string, unknown>;
+} | {
+    kind: "duplicate";
+    id: AuthoringElementId;
+} | {
+    kind: "delete";
+    id: AuthoringElementId;
+} | {
+    kind: "set_transform";
+    id: AuthoringElementId;
+    position?: [number, number, number] | null;
+    scale?: [number, number, number] | null;
+    rotation?: [number, number, number, number] | null;
+} | {
+    kind: "set_lock";
+    id: AuthoringElementId;
+    lock: boolean;
+} | {
+    kind: "set_visible";
+    id: AuthoringElementId;
+    visible: boolean;
+} | {
+    kind: "set_parameters";
+    id: AuthoringElementId;
+    values: Record<string, unknown>;
+} | {
+    kind: "change_layer";
+    id: AuthoringElementId;
+    layer: number;
+};
+export type AuthoringChangeKind = "inserted" | "updated" | "removed";
+export type AuthoringElementChange = {
+    id: AuthoringElementId;
+    page: number;
+    category: AuthoringCategory;
+    kind: AuthoringChangeKind;
+    element: Record<string, unknown> | null;
+};
+export type AuthoringSelection = {
+    id: AuthoringElementId;
+    page: number;
+    category: AuthoringCategory;
+    index: number;
+    element: Record<string, unknown>;
+};
+export type AuthoringDelta = {
+    revision: number;
+    changes: AuthoringElementChange[];
+    canUndo: boolean;
+    canRedo: boolean;
+    selectedId: AuthoringElementId | null;
+    selected: AuthoringSelection | null;
+    pageChanges: AuthoringPageChange[];
+};
+export type AuthoringPageChangeKind = "inserted" | "removed" | "moved";
+export type AuthoringPageChange = {
+    kind: AuthoringPageChangeKind;
+    page: number;
+    fromPage: number | null;
+};
+export type GameProfileDocument = {
+    userCustomProfileCards: Array<Record<string, unknown>>;
+};
+/** Opaque renderer-owned history payload. Callers may persist it but must not edit its internals. */
+export type AuthoringCheckpoint = {
+    schema: typeof AUTHORING_CHECKPOINT_SCHEMA;
+    document: GameProfileDocument;
+    ids: unknown[];
+    nextId: number;
+    revision: number;
+    undo: unknown[];
+    redo: unknown[];
+    selectedId: AuthoringElementId | null;
+};

package/dist/types/authoring.js

@@ -0,0 +1 @@
+export const AUTHORING_CHECKPOINT_SCHEMA = "allium.renderer-authoring-checkpoint/v1";

package/dist/types/core.d.ts

@@ -0,0 +1,128 @@
+export type StableId = string;
+export type CoreControlBinding = {
+    kind: "tab_option";
+    control_id: StableId;
+    value: string;
+} | {
+    kind: "scroll_content";
+    control_id: StableId;
+} | {
+    kind: "scroll_thumb";
+    control_id: StableId;
+} | {
+    kind: "scroll_viewport";
+    control_id: StableId;
+};
+export type CoreLayerPatch = {
+    layer_id: StableId;
+    render_mask: boolean | null;
+    transform: {
+        dx: number;
+        dy: number;
+    } | null;
+};
+export type CoreCommandPatch = {
+    command_id: StableId;
+    slot: number;
+    render_mask: boolean | null;
+    transform: {
+        dx: number;
+        dy: number;
+    } | null;
+};
+export type CoreSceneDelta = {
+    schema_major: number;
+    schema_minor: number;
+    scene_id: StableId;
+    base_revision: number;
+    revision: number;
+    tick: number;
+    dirty: {
+        mask: boolean;
+        transform: boolean;
+        material: boolean;
+        layout: boolean;
+        command: boolean;
+        atlas: boolean;
+        control: boolean;
+    };
+    patches: CoreLayerPatch[];
+    command_patches: CoreCommandPatch[];
+    error?: string;
+};
+export type CoreInteractionRegion = {
+    id: StableId;
+    layer_id: StableId;
+    role: string;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    quad: Array<[number, number]>;
+    matrix: [number, number, number, number, number, number];
+    hit_geometry: Array<[number, number]>;
+    clip: Array<[number, number]> | null;
+    control_bindings: CoreControlBinding[];
+    resolved_data: Record<string, unknown>;
+    capabilities: string[];
+    render_mask: boolean;
+};
+export type CoreLayerTableEntry = {
+    layer_id: StableId;
+    parent_id: StableId | null;
+    slot: number;
+    subtree_start: number;
+    subtree_end: number;
+};
+export type CoreSceneDump = {
+    schema: "allium.scene-dump";
+    schema_major: number;
+    schema_minor: number;
+    coordinate_space: "card-device-v1";
+    scene_id: StableId;
+    tick: number;
+    revisions: Record<string, number>;
+    layer_table: CoreLayerTableEntry[];
+    layer_tree: Array<[StableId, StableId | null]>;
+    layers: Array<Record<string, unknown>>;
+    interaction_regions: CoreInteractionRegion[];
+    component_controls: Array<Record<string, unknown>>;
+    command_states: Array<Record<string, unknown>>;
+    telemetry: Record<string, number>;
+    error?: string;
+};
+export type CoreSceneCreateResponse = {
+    handle: number;
+    layer_bindings: Array<{
+        source_key: string;
+        layer_id: StableId;
+    }>;
+    snapshot: {
+        schema_major: number;
+        schema_minor: number;
+        scene_id: StableId;
+        revisions: Record<string, number>;
+        layer_table: CoreLayerTableEntry[];
+        layer_sources: Array<{
+            id: StableId;
+            matrix: [number, number, number, number, number, number];
+        } & Record<string, unknown>>;
+        commands: Array<{
+            layer_id: StableId;
+            render_mask: boolean;
+            transform: {
+                dx: number;
+                dy: number;
+            };
+            command_start: number;
+            command_count: number;
+        }>;
+        semantic_commands: Array<Record<string, unknown>>;
+        interaction_regions: CoreInteractionRegion[];
+        component_controls: Array<Record<string, unknown>>;
+        command_states: Array<Record<string, unknown>>;
+    };
+    error?: string;
+};

package/dist/types/core.js

@@ -0,0 +1 @@
+export {};

package/dist/types/freeType.d.ts

@@ -0,0 +1,54 @@
+export type FreeTypeGlyph = {
+    key: string;
+    region: string;
+    family: string;
+    font_source_hash: string;
+    ch: string;
+    glyph_index: number;
+    width: number;
+    height: number;
+    bearing_x: number;
+    bearing_y: number;
+    x_offset: number;
+    y_offset: number;
+    advance: number;
+    plane_bearing_x: number;
+    plane_bearing_y: number;
+    plane_width: number;
+    plane_height: number;
+    drawable: boolean;
+    pixels?: number[] | Uint8Array;
+    pixels_base64?: string;
+};
+export type FreeTypeGlyphMapBatch = {
+    region: string;
+    family: string;
+    font_source_hash: string;
+    glyphs: Array<{
+        ch: string;
+        glyph_index: number;
+    }>;
+    missing: string[];
+    error?: string;
+};
+export type FreeTypeGlyphBatchPerf = {
+    total_ms: number;
+    face_load_ms: number;
+    glyph_total_ms: number;
+    glyph_count: number;
+    per_glyph_avg_ms: number;
+    total_pixel_count: number;
+    avg_pixels_per_glyph: number;
+};
+export type FreeTypeGlyphBatch = {
+    region: string;
+    family: string;
+    font_source_hash: string;
+    base_size: number;
+    spread: number;
+    glyphs: FreeTypeGlyph[];
+    missing: string[];
+    perf?: FreeTypeGlyphBatchPerf;
+    error?: string;
+};
+export declare function decodeFreeTypePixels(glyph: FreeTypeGlyph): Uint8Array;

package/dist/types/freeType.js

@@ -0,0 +1,13 @@
+export function decodeFreeTypePixels(glyph) {
+    if (glyph.pixels instanceof Uint8Array)
+        return glyph.pixels;
+    if (Array.isArray(glyph.pixels))
+        return new Uint8Array(glyph.pixels);
+    if (!glyph.pixels_base64)
+        return new Uint8Array(glyph.width * glyph.height);
+    const raw = atob(glyph.pixels_base64);
+    const pixels = new Uint8Array(raw.length);
+    for (let index = 0; index < raw.length; index += 1)
+        pixels[index] = raw.charCodeAt(index);
+    return pixels;
+}

package/dist/types/glyph.d.ts

@@ -0,0 +1,33 @@
+/** A glyph instance produced by the shared Rust layout engine. */
+export type GlyphInstance = {
+    layerId: string;
+    plainTextIndex: number;
+    char: string;
+    drawable: boolean;
+    glyphKey: string;
+    atlasPage: number;
+    z: number;
+    quad: Array<[number, number, number, number, number]>;
+    charPosition: [string, number, number, number, number, number];
+    charOp: [string, number, number, number, number, number, number];
+    charQuad: [string, Array<[number, number]>];
+    deviceCharPosition: [string, number, number];
+    deviceCharQuad: [string, Array<[number, number]>];
+    deviceGlyphQuad: [string, Array<[number, number]>];
+    layoutMetrics: {
+        lineWidths: number[];
+        rectWidths: number[];
+        boxW: number;
+        anchorBase: number;
+        lineOffsets: number[];
+    };
+    fill: [number, number, number, number];
+    outline: [number, number, number, number];
+    outlineWidth: number;
+    shaderFontSize: number;
+    shaderFaceScale: number;
+    shaderFaceBias: number;
+    shaderUnderlayScale: number;
+    shaderUnderlayBias: number;
+    shaderVertexAlpha: number;
+};

package/dist/types/glyph.js

@@ -0,0 +1 @@
+export {};

package/dist/types/layout.d.ts

@@ -0,0 +1,25 @@
+import type { GlyphInstance } from "./glyph.js";
+export type CoreDynamicProgramDescriptor = {
+    layerId: string;
+    percent: number;
+    lineAdvancesTmp: number[][];
+    rotationDeg: number;
+    scaleX: number;
+};
+export type WasmLayoutBatch = {
+    version: number;
+    source: string;
+    instances: GlyphInstance[];
+    dynamicPrograms: CoreDynamicProgramDescriptor[];
+    error?: string;
+};
+export type WasmGlyphDemandBatch = {
+    version: number;
+    source: "wasm-tmp-glyph-demand";
+    requests: Array<{
+        region: string;
+        family: string;
+        font_source_hash: string;
+        char: string;
+    }>;
+};

package/dist/types/layout.js

@@ -0,0 +1 @@
+export {};

package/dist/types/text.d.ts

@@ -0,0 +1,28 @@
+/** Text command input consumed by the shared Rust TMP layout engine. */
+export type TextLayer = {
+    id: string;
+    parentId?: string | null;
+    documentKey: string;
+    z: number;
+    text: string;
+    authoredVisible: boolean;
+    region: string;
+    fontId: number;
+    fontFamily: string;
+    fontSourceHash: string;
+    x: number;
+    y: number;
+    rotationDeg: number;
+    scaleX: number;
+    scaleY: number;
+    skewX: number;
+    fontSize: number;
+    color: [number, number, number, number];
+    outlineColor: [number, number, number, number];
+    colorRgb: [number, number, number];
+    colorId: number;
+    outlineColorId: number;
+    outlineWidth: number;
+    lineSpacing: number;
+    textType: number;
+};

package/dist/types/text.js

@@ -0,0 +1 @@
+export {};

package/dist/worker/glyphWorkScheduler.d.ts

@@ -0,0 +1,29 @@
+export type KeyedGlyphJob = {
+    key: string;
+};
+export type KeyedGlyphResult = {
+    key: string;
+};
+export type GlyphWorkSchedulerStats = {
+    dispatches: number;
+    dispatchedJobs: number;
+    cacheHits: number;
+    coalesced: number;
+    failures: number;
+    pending: number;
+    cached: number;
+};
+export declare class GlyphWorkScheduler<Job extends KeyedGlyphJob, Result extends KeyedGlyphResult> {
+    private readonly dispatch;
+    private readonly cache;
+    private readonly pending;
+    private readonly counters;
+    constructor(dispatch: (jobs: readonly Job[]) => Promise<readonly Result[]>);
+    run(jobs: readonly Job[]): Promise<Result[]>;
+    get(key: string): Result | undefined;
+    prime(results: readonly Result[]): void;
+    delete(key: string): boolean;
+    clear(): void;
+    stats(): GlyphWorkSchedulerStats;
+    private dispatchFresh;
+}

package/dist/worker/glyphWorkScheduler.js

@@ -0,0 +1,107 @@
+export class GlyphWorkScheduler {
+    dispatch;
+    cache = new Map();
+    pending = new Map();
+    counters = {
+        dispatches: 0,
+        dispatchedJobs: 0,
+        cacheHits: 0,
+        coalesced: 0,
+        failures: 0,
+    };
+    constructor(dispatch) {
+        this.dispatch = dispatch;
+    }
+    run(jobs) {
+        const ordered = [];
+        const fresh = [];
+        const freshKeys = new Set();
+        for (const job of jobs) {
+            const cached = this.cache.get(job.key);
+            if (cached) {
+                this.counters.cacheHits += 1;
+                ordered.push(Promise.resolve(cached));
+                continue;
+            }
+            const inFlight = this.pending.get(job.key);
+            if (inFlight) {
+                this.counters.coalesced += 1;
+                ordered.push(inFlight.promise);
+                continue;
+            }
+            const deferred = createDeferred();
+            this.pending.set(job.key, deferred);
+            ordered.push(deferred.promise);
+            if (!freshKeys.has(job.key)) {
+                freshKeys.add(job.key);
+                fresh.push(job);
+            }
+        }
+        if (fresh.length > 0)
+            void this.dispatchFresh(fresh);
+        return Promise.all(ordered);
+    }
+    get(key) {
+        const value = this.cache.get(key);
+        if (value)
+            this.counters.cacheHits += 1;
+        return value;
+    }
+    prime(results) {
+        for (const result of results) {
+            if (!this.pending.has(result.key))
+                this.cache.set(result.key, result);
+        }
+    }
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    stats() {
+        return {
+            ...this.counters,
+            pending: this.pending.size,
+            cached: this.cache.size,
+        };
+    }
+    async dispatchFresh(jobs) {
+        this.counters.dispatches += 1;
+        this.counters.dispatchedJobs += jobs.length;
+        try {
+            const results = await this.dispatch(jobs);
+            const byKey = new Map(results.map((result) => [result.key, result]));
+            for (const job of jobs) {
+                const deferred = this.pending.get(job.key);
+                if (!deferred)
+                    continue;
+                const result = byKey.get(job.key);
+                this.pending.delete(job.key);
+                if (!result) {
+                    deferred.reject(new Error(`glyph worker omitted result for ${job.key}`));
+                    continue;
+                }
+                this.cache.set(job.key, result);
+                deferred.resolve(result);
+            }
+        }
+        catch (error) {
+            this.counters.failures += 1;
+            for (const job of jobs) {
+                const deferred = this.pending.get(job.key);
+                this.pending.delete(job.key);
+                deferred?.reject(error);
+            }
+        }
+    }
+}
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+    });
+    return { promise, resolve, reject };
+}

package/dist/worker-client.d.ts

@@ -0,0 +1,114 @@
+import { type GlyphBatchRequest, type LayerMaskOverride, type RegisteredFont, type RendererFontContract, type RendererWorkerRequest, type RendererWorkerResult, type RendererWorkerStats } from "./protocol.js";
+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, AtlasResolveResult, AtlasStats, GlyphRasterPlan } from "./types/atlas.js";
+import type { AuthoringCheckpoint, AuthoringCommand, AuthoringDelta, AuthoringSelection, GameProfileDocument } from "./types/authoring.js";
+export type RendererWorkerClientOptions = {
+    workerUrl?: string | URL;
+    moduleUrl?: string | URL;
+    wasmUrl?: string | URL;
+    workerFactory?: (url: string | URL) => Worker;
+};
+export declare class RendererWorkerClient {
+    private readonly worker;
+    private readonly pending;
+    private sequence;
+    private closed;
+    private constructor();
+    static create(options?: RendererWorkerClientOptions): Promise<RendererWorkerClient>;
+    registerFont(font: RegisteredFont): Promise<void>;
+    contract(): Promise<RendererFontContract>;
+    mapGlyphs(request: GlyphBatchRequest): Promise<FreeTypeGlyphMapBatch>;
+    planGlyphs(request: GlyphBatchRequest): Promise<GlyphRasterPlan>;
+    buildGlyphs(request: GlyphBatchRequest): Promise<FreeTypeGlyphBatch>;
+    layoutText(request: unknown): Promise<WasmLayoutBatch>;
+    glyphDemand(request: unknown): Promise<WasmGlyphDemandBatch>;
+    createAtlas(): Promise<RendererAtlas>;
+    createAuthoringDocument(profile?: unknown): Promise<RendererAuthoringDocument>;
+    restoreAuthoringDocument(checkpoint: AuthoringCheckpoint): Promise<RendererAuthoringDocument>;
+    createMasterData(region: string, revision: string): Promise<RendererMasterData>;
+    stats(): Promise<RendererWorkerStats>;
+    terminate(): void;
+    sceneRequest(kind: RendererWorkerRequest["kind"], payload: unknown): Promise<RendererWorkerResult>;
+    private request;
+    private receive;
+    private failAll;
+}
+export declare class RendererAuthoringDocument {
+    private readonly client;
+    readonly id: string;
+    readonly initialDocument: GameProfileDocument;
+    readonly initialRevision: number;
+    private destroyed;
+    constructor(client: RendererWorkerClient, id: string, initialDocument: GameProfileDocument, initialRevision: number);
+    apply(command: AuthoringCommand): Promise<AuthoringDelta>;
+    select(id: number | null): Promise<AuthoringDelta>;
+    elements(): Promise<AuthoringSelection[]>;
+    beginGesture(id: number): Promise<AuthoringDelta>;
+    previewGesture(command: Extract<AuthoringCommand, {
+        kind: "set_transform" | "set_parameters";
+    }>): Promise<AuthoringDelta>;
+    commitGesture(): Promise<AuthoringDelta>;
+    cancelGesture(): Promise<AuthoringDelta>;
+    appendPage(): Promise<AuthoringDelta>;
+    duplicatePage(page: number): Promise<AuthoringDelta>;
+    deletePage(page: number): Promise<AuthoringDelta>;
+    movePage(fromPage: number, page: number): Promise<AuthoringDelta>;
+    undo(): Promise<AuthoringDelta | null>;
+    redo(): Promise<AuthoringDelta | null>;
+    export(): Promise<GameProfileDocument>;
+    checkpoint(): Promise<AuthoringCheckpoint>;
+    destroy(): Promise<void>;
+    private history;
+    private delta;
+    private assertAlive;
+}
+export declare class RendererAtlas {
+    private readonly client;
+    readonly id: string;
+    readonly initialStats: AtlasStats;
+    private destroyed;
+    constructor(client: RendererWorkerClient, id: string, initialStats: AtlasStats);
+    resolve(keys: string[], cached: AtlasGlyphRecord[], generate: AtlasGenerateRequest[]): Promise<AtlasResolveResult>;
+    pages(revisions: ReadonlyMap<number, number>): Promise<AtlasPageUpdate[]>;
+    release(lease: number): Promise<void>;
+    destroy(): Promise<void>;
+    private assertAlive;
+}
+export declare class RendererMasterData {
+    private readonly client;
+    readonly id: string;
+    readonly region: string;
+    readonly revision: string;
+    readonly requiredTables: readonly string[];
+    private destroyed;
+    constructor(client: RendererWorkerClient, id: string, region: string, revision: string, requiredTables: readonly string[]);
+    putTable(name: string, table: unknown): Promise<Record<string, unknown>>;
+    seal(): Promise<Record<string, unknown>>;
+    prepareProfile(request: unknown): Promise<Record<string, unknown>>;
+    destroy(): Promise<void>;
+    private report;
+    private assertAlive;
+}
+export declare class RendererScene {
+    private readonly client;
+    readonly id: string;
+    readonly initial: CoreSceneCreateResponse;
+    private destroyed;
+    constructor(client: RendererWorkerClient, id: string, initial: CoreSceneCreateResponse);
+    advance(tick: number): Promise<CoreSceneDelta>;
+    setLayerVisible(layerId: StableId, visible: boolean): Promise<CoreSceneDelta>;
+    setLayerMasks(expectedLayerTableRevision: number, overrides: LayerMaskOverride[]): Promise<CoreSceneDelta>;
+    setTab(controlId: StableId, value: string): Promise<CoreSceneDelta>;
+    setScrollOffset(controlId: StableId, offset: number): Promise<CoreSceneDelta>;
+    scrollBy(controlId: StableId, delta: number): Promise<CoreSceneDelta>;
+    dump(): Promise<CoreSceneDump>;
+    destroy(): Promise<void>;
+    private delta;
+    private assertAlive;
+}
+export declare class RendererWorkerError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}