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

package/dist/gpu/semanticCommandPlanner.js

@@ -0,0 +1,203 @@
+/**
+ * Immutable authored-layer command ownership plus mutable render state.
+ * Visibility and dynamic deltas update only the dense state table; command
+ * order and resource identity remain stable for the plan lifetime.
+ */
+export class SemanticCommandPlan {
+    layerTableRevision;
+    commandRevision = 1;
+    resourceRevision = 1;
+    commands;
+    operationLayers;
+    stateByLayer = new Map();
+    resources;
+    commandVisible;
+    commandTransforms;
+    constructor(input) {
+        this.layerTableRevision = input.layerTableRevision;
+        this.commands = [...input.semanticCommands];
+        const stateBySlot = input.commandStates ?? this.commands.map((command, slot) => ({
+            command_id: command.id,
+            slot,
+            render_mask: true,
+            transform: { dx: 0, dy: 0 },
+        }));
+        if (stateBySlot.length !== this.commands.length)
+            throw new Error("command state table length mismatch");
+        this.commandVisible = new Array(this.commands.length);
+        this.commandTransforms = new Array(this.commands.length);
+        for (const state of stateBySlot) {
+            if (!Number.isInteger(state.slot) || state.slot < 0 || state.slot >= this.commands.length || this.commands[state.slot].id !== state.command_id) {
+                throw new Error(`command state identity mismatch at ${state.slot}`);
+            }
+            this.commandVisible[state.slot] = state.render_mask;
+            this.commandTransforms[state.slot] = { ...state.transform };
+        }
+        const tableByLayer = new Map();
+        const matrixByLayer = new Map(input.layerSources.map((layer) => [layer.layer_id, layer.matrix]));
+        for (const entry of input.layerTable) {
+            if (tableByLayer.has(entry.layer_id))
+                throw new Error(`duplicate layer table id ${entry.layer_id}`);
+            if (!Number.isInteger(entry.slot) || entry.slot < 0)
+                throw new Error(`invalid layer slot ${entry.slot}`);
+            tableByLayer.set(entry.layer_id, entry.slot);
+        }
+        const coverage = new Uint8Array(this.commands.length);
+        this.operationLayers = new Array(this.commands.length);
+        for (const layerCommand of input.layerCommands) {
+            const slot = tableByLayer.get(layerCommand.layer_id);
+            if (slot == null)
+                throw new Error(`layer command references unknown layer ${layerCommand.layer_id}`);
+            if (this.stateByLayer.has(layerCommand.layer_id)) {
+                throw new Error(`duplicate layer command ${layerCommand.layer_id}`);
+            }
+            const baseMatrix = matrixByLayer.get(layerCommand.layer_id);
+            if (!baseMatrix)
+                throw new Error(`missing authored layer matrix ${layerCommand.layer_id}`);
+            const start = layerCommand.command_start;
+            const end = start + layerCommand.command_count;
+            if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end > this.commands.length) {
+                throw new Error(`invalid command span for layer ${layerCommand.layer_id}`);
+            }
+            for (let index = start; index < end; index += 1) {
+                const command = this.commands[index];
+                if (coverage[index] !== 0 || command.layer_id !== layerCommand.layer_id) {
+                    throw new Error(`command span ownership mismatch at ${index}`);
+                }
+                coverage[index] = 1;
+                this.operationLayers[index] = { layerId: layerCommand.layer_id, slot };
+            }
+            this.stateByLayer.set(layerCommand.layer_id, {
+                slot,
+                baseMatrix: [...baseMatrix],
+                visible: layerCommand.render_mask,
+                transform: { ...layerCommand.transform },
+            });
+        }
+        const uncovered = coverage.findIndex((value) => value === 0);
+        if (uncovered >= 0)
+            throw new Error(`semantic command ${uncovered} is outside every authored layer span`);
+        this.resources = collectResourceRequests(this.commands);
+    }
+    operations() {
+        return this.commands.map((command, index) => {
+            const ownership = this.operationLayers[index];
+            const state = this.stateByLayer.get(ownership.layerId);
+            if (!state)
+                throw new Error(`missing runtime layer state ${ownership.layerId}`);
+            return {
+                command,
+                layerId: ownership.layerId,
+                layerSlot: ownership.slot,
+                baseMatrix: [...state.baseMatrix],
+                visible: state.visible,
+                transform: { ...state.transform },
+                commandSlot: index,
+                commandVisible: this.commandVisible[index],
+                commandTransform: { ...this.commandTransforms[index] },
+            };
+        });
+    }
+    resourceRequests() {
+        return this.resources.map((resource) => ({ ...resource }));
+    }
+    applyLayerPatches(patches) {
+        for (const patch of patches) {
+            const state = this.stateByLayer.get(patch.layer_id);
+            if (!state)
+                throw new Error(`unknown layer patch ${patch.layer_id}`);
+            if (patch.render_mask != null)
+                state.visible = patch.render_mask;
+            if (patch.transform != null)
+                state.transform = { ...patch.transform };
+        }
+    }
+    applyCommandPatches(patches) {
+        for (const patch of patches) {
+            if (!Number.isInteger(patch.slot) || patch.slot < 0 || patch.slot >= this.commands.length)
+                throw new Error(`invalid command slot ${patch.slot}`);
+            if (patch.render_mask != null)
+                this.commandVisible[patch.slot] = patch.render_mask;
+            if (patch.transform != null)
+                this.commandTransforms[patch.slot] = { ...patch.transform };
+        }
+    }
+}
+export function semanticCommandPlanFromCoreSnapshot(snapshot) {
+    return new SemanticCommandPlan({
+        layerTableRevision: snapshot.revisions.layer_table,
+        layerTable: snapshot.layer_table,
+        layerSources: snapshot.layer_sources.map((layer) => ({ layer_id: layer.id, matrix: layer.matrix })),
+        layerCommands: snapshot.commands,
+        semanticCommands: snapshot.semantic_commands,
+        commandStates: snapshot.command_states,
+    });
+}
+/** Adapts the native/server debug dump to the exact same immutable browser
+ * command plan used by a live WASM Scene. This is intentionally strict so a
+ * dump cannot silently reorder authored layers or command ownership. */
+export function semanticCommandPlanFromCoreDump(dump) {
+    const layerById = new Map(dump.layers.map((layer) => [layer.layer_id, layer]));
+    const semanticCommands = [];
+    const layerCommands = [];
+    const layerSources = [];
+    for (const entry of [...dump.layer_table].sort((left, right) => left.slot - right.slot)) {
+        const layer = layerById.get(entry.layer_id);
+        if (!layer)
+            throw new Error(`core dump missing layer ${entry.layer_id}`);
+        const commandStart = semanticCommands.length;
+        semanticCommands.push(...layer.commands);
+        layerSources.push({ layer_id: layer.layer_id, matrix: layer.matrix });
+        layerCommands.push({
+            layer_id: layer.layer_id,
+            render_mask: layer.render_mask,
+            transform: { dx: 0, dy: 0 },
+            command_start: commandStart,
+            command_count: layer.commands.length,
+        });
+    }
+    if (layerById.size !== dump.layer_table.length)
+        throw new Error("core dump contains layers outside the layer table");
+    return new SemanticCommandPlan({
+        layerTableRevision: dump.revisions.layer_table,
+        layerTable: dump.layer_table,
+        layerSources,
+        layerCommands,
+        semanticCommands,
+        commandStates: dump.command_states,
+    });
+}
+function collectResourceRequests(commands) {
+    const deduplicated = new Map();
+    for (const command of commands) {
+        const resource = commandResource(command.payload);
+        if (!resource)
+            continue;
+        deduplicated.set(`${resource.namespace}\0${resource.key}`, resource);
+        if (command.payload.kind === "image") {
+            const mask = asResourceKey(command.payload.alpha_mask);
+            if (mask)
+                deduplicated.set(`${mask.namespace}\0${mask.key}`, mask);
+        }
+    }
+    return [...deduplicated.values()].map((resource) => ({ ...resource }));
+}
+function commandResource(payload) {
+    if (payload.kind === "image")
+        return asResourceKey(payload.resource);
+    if (payload.kind !== "shape")
+        return null;
+    const primitive = payload.primitive;
+    if (!primitive || typeof primitive !== "object" || Array.isArray(primitive))
+        return null;
+    const assetMask = primitive.asset_mask;
+    if (!assetMask || typeof assetMask !== "object" || Array.isArray(assetMask))
+        return null;
+    return asResourceKey(assetMask.resource);
+}
+function asResourceKey(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const { namespace, key } = value;
+    return typeof namespace === "string" && typeof key === "string" ? { namespace, key } : null;
+}

package/dist/gpu/semanticTextGlyphBridge.d.ts

@@ -0,0 +1,3 @@
+import type { GlyphInstance } from "../types/glyph.js";
+import type { SemanticDrawOperation } from "./semanticCommandPlanner.js";
+export declare function compileSemanticTextGlyphBatches(instances: GlyphInstance[], textOperations: SemanticDrawOperation[]): Map<string, Float32Array>;

package/dist/gpu/semanticTextGlyphBridge.js

@@ -0,0 +1,22 @@
+import { buildSdfGlyphInstanceVertices } from "./webglSdfGlyphPipeline.js";
+export function compileSemanticTextGlyphBatches(instances, textOperations) {
+    const result = new Map();
+    for (const operation of textOperations) {
+        if (operation.command.payload.kind !== "text")
+            throw new Error(`non-text glyph bridge operation ${operation.command.id}`);
+        const commandInstances = instances.filter((instance) => instance.layerId === operation.command.id);
+        const clips = operation.command.clip == null
+            ? new Map()
+            : new Map([[operation.command.id, transformClip(operation.command.clip, operation.baseMatrix, operation.command.id)]]);
+        result.set(operation.command.id, buildSdfGlyphInstanceVertices(commandInstances, new Map([[operation.command.id, operation.layerSlot]]), clips, new Map([[operation.command.id, operation.commandSlot]])));
+    }
+    return result;
+}
+function transformClip(value, matrix, commandId) {
+    if (!Array.isArray(value) || value.length !== 4 || value.some((point) => !Array.isArray(point) || point.length !== 2))
+        throw new Error(`invalid text clip ${commandId}`);
+    return value.map((point) => [
+        matrix[0] * Number(point[0]) + matrix[2] * Number(point[1]) + matrix[4],
+        matrix[1] * Number(point[0]) + matrix[3] * Number(point[1]) + matrix[5],
+    ]);
+}

package/dist/gpu/semanticWebglSceneRenderer.d.ts

@@ -0,0 +1,70 @@
+import type { SdfAtlas } from "../fontSdfAtlas.js";
+import type { WasmLayoutBatch } from "../types/layout.js";
+import type { SemanticCommandPlan, SemanticCommandStatePatch, SemanticLayerPatch } from "./semanticCommandPlanner.js";
+import { type SemanticGpuMetrics } from "./webglSemanticCommandExecutor.js";
+import { type NumericTextRegion } from "../interaction/numericTextRegions.js";
+import type { BrowserImageSource } from "./browserSemanticResources.js";
+import type { GlyphInstance } from "../types/glyph.js";
+import type { SemanticDrawOperation } from "./semanticCommandPlanner.js";
+export type AuthoredTextHitGeometry = {
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    quad: [[number, number], [number, number], [number, number], [number, number]];
+};
+export declare class SemanticWebglSceneRenderer {
+    private executor;
+    private plan;
+    private numericRegions;
+    private textHitGeometry;
+    private contextLost;
+    private retainedScene;
+    constructor(gl: WebGL2RenderingContext);
+    setScene(input: {
+        plan: SemanticCommandPlan;
+        atlas: SdfAtlas | null;
+        layout: WasmLayoutBatch;
+        imageSources: Map<string, BrowserImageSource>;
+    }): Promise<{
+        textCommands: number;
+        glyphInstances: number;
+        atlasUploadBytes: number;
+        atlasUploadRects: number;
+    }>;
+    applyLayerPatches(patches: SemanticLayerPatch[]): {
+        stateUploadBytes: number;
+        maskUploadBytes: number;
+    };
+    applyCommandPatches(patches: SemanticCommandStatePatch[]): {
+        commandMaskUploadBytes: number;
+        commandStateUploadBytes: number;
+    };
+    applyCoreDelta(delta: {
+        patches: SemanticLayerPatch[];
+        command_patches: SemanticCommandStatePatch[];
+    }): {
+        commandMaskUploadBytes: number;
+        commandStateUploadBytes: number;
+        stateUploadBytes: number;
+        maskUploadBytes: number;
+    };
+    setLayerPreviewTransform(layerId: string, matrix: [number, number, number, number, number, number] | null): {
+        previewUploadBytes: number;
+    };
+    draw(): SemanticGpuMetrics;
+    notifyContextLost(): void;
+    restoreContext(gl: WebGL2RenderingContext): Promise<{
+        atlasUploadBytes: number;
+        atlasUploadRects: number;
+        textureUploads: number;
+        textureBytes: number;
+    }>;
+    interactionRegions(): NumericTextRegion[];
+    authoredTextHitGeometry(): Map<string, AuthoredTextHitGeometry>;
+    destroy(): void;
+    private assertContextReady;
+}
+export declare function buildAuthoredTextHitGeometry(operations: SemanticDrawOperation[], instances: GlyphInstance[]): Map<string, AuthoredTextHitGeometry>;

package/dist/gpu/semanticWebglSceneRenderer.js

@@ -0,0 +1,211 @@
+import { compileSemanticDrawBatches, semanticTextBatchKey } from "./semanticCommandGeometry.js";
+import { compileSemanticTextGlyphBatches } from "./semanticTextGlyphBridge.js";
+import { WebglSemanticCommandExecutor } from "./webglSemanticCommandExecutor.js";
+import { applyNumericRegionRuntimeState, buildNumericTextRegions } from "../interaction/numericTextRegions.js";
+import { placeGeneralTextInstances } from "./generalTextRenderPlacement.js";
+export class SemanticWebglSceneRenderer {
+    executor;
+    plan = null;
+    numericRegions = [];
+    textHitGeometry = new Map();
+    contextLost = false;
+    retainedScene = null;
+    constructor(gl) {
+        this.executor = new WebglSemanticCommandExecutor(gl);
+    }
+    async setScene(input) {
+        const operations = input.plan.operations();
+        this.plan = input.plan;
+        const batches = compileSemanticDrawBatches(operations);
+        this.executor.setScene(input.plan, batches, input.imageSources);
+        const atlasUpload = input.atlas
+            ? await this.executor.setSdfAtlas(input.atlas)
+            : { bytes: 0, rects: 0 };
+        const textOperations = operations.filter((operation) => operation.command.payload.kind === "text");
+        const placedInstances = placeGeneralTextInstances(input.layout.instances, textOperations);
+        this.textHitGeometry = buildAuthoredTextHitGeometry(textOperations, placedInstances);
+        this.numericRegions = textOperations.flatMap((operation) => buildNumericTextRegions(operation.command, placedInstances, operation.visible && operation.commandVisible));
+        const glyphsByCommand = compileSemanticTextGlyphBatches(placedInstances, textOperations);
+        const textGlyphBatches = new Map();
+        for (const batch of batches.filter((batch) => batch.kind === "text")) {
+            const vertices = concatenateFloat32(batch.commandIds.map((commandId) => glyphsByCommand.get(commandId) ?? new Float32Array()));
+            const key = semanticTextBatchKey(batch.commandIds);
+            textGlyphBatches.set(key, vertices);
+            this.executor.setTextGlyphBatch(key, vertices);
+        }
+        this.retainedScene = {
+            plan: input.plan,
+            atlas: input.atlas,
+            batches,
+            imageSources: input.imageSources,
+            textGlyphBatches,
+        };
+        this.contextLost = false;
+        return {
+            textCommands: textOperations.length,
+            glyphInstances: input.layout.instances.length,
+            atlasUploadBytes: atlasUpload.bytes,
+            atlasUploadRects: atlasUpload.rects,
+        };
+    }
+    applyLayerPatches(patches) {
+        this.assertContextReady();
+        return this.executor.applyLayerPatches(patches);
+    }
+    applyCommandPatches(patches) {
+        this.assertContextReady();
+        return this.executor.applyCommandPatches(patches);
+    }
+    applyCoreDelta(delta) {
+        this.assertContextReady();
+        const layer = this.executor.applyLayerPatches(delta.patches);
+        const command = this.executor.applyCommandPatches(delta.command_patches);
+        return { ...layer, ...command };
+    }
+    setLayerPreviewTransform(layerId, matrix) {
+        this.assertContextReady();
+        return this.executor.setLayerPreviewTransform(layerId, matrix);
+    }
+    draw() {
+        this.assertContextReady();
+        return this.executor.draw();
+    }
+    notifyContextLost() {
+        this.contextLost = true;
+    }
+    async restoreContext(gl) {
+        const retained = this.retainedScene;
+        if (!retained)
+            throw new Error("semantic GPU scene is not initialized");
+        const previous = this.executor;
+        const restored = new WebglSemanticCommandExecutor(gl);
+        try {
+            restored.setScene(retained.plan, retained.batches, retained.imageSources);
+            const atlasUpload = retained.atlas
+                ? await restored.setSdfAtlas(retained.atlas)
+                : { bytes: 0, rects: 0 };
+            for (const [key, vertices] of retained.textGlyphBatches)
+                restored.setTextGlyphBatch(key, vertices);
+            this.executor = restored;
+            this.contextLost = false;
+            previous.destroy();
+            return {
+                atlasUploadBytes: atlasUpload.bytes,
+                atlasUploadRects: atlasUpload.rects,
+                textureUploads: retained.imageSources.size,
+                textureBytes: imageSourceBytes(retained.imageSources.values()),
+            };
+        }
+        catch (error) {
+            restored.destroy();
+            this.contextLost = true;
+            throw error;
+        }
+    }
+    interactionRegions() {
+        const operations = new Map((this.plan?.operations() ?? []).map((operation) => [operation.command.id, operation]));
+        return this.numericRegions.map((region) => {
+            const operation = operations.get(region.id.split(":numeric:", 1)[0]);
+            if (!operation)
+                return region;
+            return {
+                ...applyNumericRegionRuntimeState(region, {
+                    layerTransform: operation.transform,
+                    commandTransform: operation.commandTransform,
+                }),
+                render_mask: operation.visible && operation.commandVisible,
+            };
+        });
+    }
+    authoredTextHitGeometry() {
+        const operations = this.plan?.operations() ?? [];
+        const runtimeByLayer = new Map(operations.map((operation) => [operation.layerId, operation]));
+        return new Map([...this.textHitGeometry].map(([layerId, geometry]) => {
+            const operation = runtimeByLayer.get(layerId);
+            const dx = (operation?.transform.dx ?? 0) + (operation?.commandTransform.dx ?? 0);
+            const dy = (operation?.transform.dy ?? 0) + (operation?.commandTransform.dy ?? 0);
+            const quad = geometry.quad.map(([x, y]) => [x + dx, y + dy]);
+            return [layerId, {
+                    bounds: { ...geometry.bounds, x: geometry.bounds.x + dx, y: geometry.bounds.y + dy },
+                    quad,
+                }];
+        }));
+    }
+    destroy() {
+        this.executor.destroy();
+        this.plan = null;
+        this.numericRegions = [];
+        this.textHitGeometry.clear();
+        this.retainedScene = null;
+        this.contextLost = false;
+    }
+    assertContextReady() {
+        if (this.contextLost)
+            throw new Error("WebGL context is lost");
+    }
+}
+export function buildAuthoredTextHitGeometry(operations, instances) {
+    const output = new Map();
+    for (const operation of operations) {
+        const quads = instances
+            .filter((instance) => instance.layerId === operation.command.id)
+            .map((instance) => instance.deviceCharQuad[1])
+            .filter((quad) => quad.length >= 4);
+        const points = quads.flat();
+        if (points.length === 0)
+            continue;
+        const basis = quads.find((quad) => (Math.hypot(quad[1][0] - quad[0][0], quad[1][1] - quad[0][1]) > 1e-4
+            && Math.hypot(quad[3][0] - quad[0][0], quad[3][1] - quad[0][1]) > 1e-4));
+        if (!basis)
+            continue;
+        const ux0 = basis[1][0] - basis[0][0];
+        const uy0 = basis[1][1] - basis[0][1];
+        const vx0 = basis[3][0] - basis[0][0];
+        const vy0 = basis[3][1] - basis[0][1];
+        const ul = Math.hypot(ux0, uy0);
+        const vl = Math.hypot(vx0, vy0);
+        const ux = ux0 / ul;
+        const uy = uy0 / ul;
+        const vx = vx0 / vl;
+        const vy = vy0 / vl;
+        const uValues = points.map(([x, y]) => x * ux + y * uy);
+        const vValues = points.map(([x, y]) => x * vx + y * vy);
+        const minU = Math.min(...uValues);
+        const maxU = Math.max(...uValues);
+        const minV = Math.min(...vValues);
+        const maxV = Math.max(...vValues);
+        const point = (u, v) => [ux * u + vx * v, uy * u + vy * v];
+        const quad = [
+            point(minU, minV),
+            point(maxU, minV),
+            point(maxU, maxV),
+            point(minU, maxV),
+        ];
+        const xs = quad.map(([x]) => x);
+        const ys = quad.map(([, y]) => y);
+        const minX = Math.min(...xs);
+        const maxX = Math.max(...xs);
+        const minY = Math.min(...ys);
+        const maxY = Math.max(...ys);
+        output.set(operation.layerId, {
+            bounds: { x: minX, y: minY, width: maxX - minX, height: maxY - minY },
+            quad,
+        });
+    }
+    return output;
+}
+function concatenateFloat32(values) {
+    const output = new Float32Array(values.reduce((sum, value) => sum + value.length, 0));
+    let offset = 0;
+    for (const value of values) {
+        output.set(value, offset);
+        offset += value.length;
+    }
+    return output;
+}
+function imageSourceBytes(values) {
+    let bytes = 0;
+    for (const source of values)
+        bytes += Math.max(0, source.width * source.height * 4);
+    return bytes;
+}

package/dist/gpu/slotRanges.d.ts

@@ -0,0 +1,5 @@
+export type SlotRange = {
+    start: number;
+    end: number;
+};
+export declare function contiguousSlotRanges(slots: number[]): SlotRange[];

package/dist/gpu/slotRanges.js

@@ -0,0 +1,14 @@
+export function contiguousSlotRanges(slots) {
+    const sorted = [...new Set(slots)].sort((left, right) => left - right);
+    const ranges = [];
+    for (const slot of sorted) {
+        const last = ranges.at(-1);
+        if (last && slot === last.end) {
+            last.end += 1;
+        }
+        else {
+            ranges.push({ start: slot, end: slot + 1 });
+        }
+    }
+    return ranges;
+}

package/dist/gpu/webglSdfAtlasTexture.d.ts

@@ -0,0 +1,17 @@
+import type { SdfAtlas } from "../fontSdfAtlas.js";
+export declare class WebglSdfAtlasTexture {
+    private readonly gl;
+    private readonly maxPages;
+    private textureValue;
+    private contractId;
+    private revisions;
+    private allocated;
+    constructor(gl: WebGL2RenderingContext, maxPages?: number);
+    texture(): WebGLTexture;
+    setAtlas(atlas: SdfAtlas): void;
+    uploadUpdates(atlas: SdfAtlas): Promise<{
+        bytes: number;
+        rects: number;
+    }>;
+    destroy(): void;
+}

package/dist/gpu/webglSdfAtlasTexture.js

@@ -0,0 +1,72 @@
+export class WebglSdfAtlasTexture {
+    gl;
+    maxPages;
+    textureValue;
+    contractId = null;
+    revisions = new Map();
+    allocated = false;
+    constructor(gl, maxPages = 6) {
+        this.gl = gl;
+        this.maxPages = maxPages;
+        const texture = gl.createTexture();
+        if (!texture)
+            throw new Error("SDF atlas texture allocation failed");
+        this.textureValue = texture;
+    }
+    texture() {
+        return this.textureValue;
+    }
+    setAtlas(atlas) {
+        if (this.contractId === atlas.contractId)
+            return;
+        this.contractId = atlas.contractId;
+        this.revisions.clear();
+        this.allocated = false;
+        this.gl.deleteTexture(this.textureValue);
+        const texture = this.gl.createTexture();
+        if (!texture)
+            throw new Error("SDF atlas texture reallocation failed");
+        this.textureValue = texture;
+    }
+    async uploadUpdates(atlas) {
+        this.setAtlas(atlas);
+        const updates = await atlas.pageUpdates(this.revisions);
+        if (updates.length === 0)
+            return { bytes: 0, rects: 0 };
+        const gl = this.gl;
+        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0);
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, this.textureValue);
+        gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+        if (!this.allocated) {
+            gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+            gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+            gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+            gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+            gl.texStorage3D(gl.TEXTURE_2D_ARRAY, 1, gl.R8, atlas.width, atlas.height, this.maxPages);
+            this.allocated = true;
+        }
+        let bytes = 0;
+        let rects = 0;
+        for (const update of updates) {
+            if (update.page >= this.maxPages)
+                throw new Error(`atlas page ${update.page} exceeds GPU hard budget`);
+            if (update.fullUpload) {
+                gl.texSubImage3D(gl.TEXTURE_2D_ARRAY, 0, 0, 0, update.page, atlas.width, atlas.height, 1, gl.RED, gl.UNSIGNED_BYTE, update.pixels);
+                bytes += update.pixels.byteLength;
+                rects += 1;
+            }
+            else {
+                for (const rect of update.dirtyRects) {
+                    gl.texSubImage3D(gl.TEXTURE_2D_ARRAY, 0, rect.x, rect.y, update.page, rect.width, rect.height, 1, gl.RED, gl.UNSIGNED_BYTE, rect.pixels);
+                    bytes += rect.pixels.byteLength;
+                    rects += 1;
+                }
+            }
+            this.revisions.set(update.page, update.revision);
+        }
+        return { bytes, rects };
+    }
+    destroy() {
+        this.gl.deleteTexture(this.textureValue);
+    }
+}

package/dist/gpu/webglSdfGlyphPipeline.d.ts

@@ -0,0 +1,26 @@
+import type { GlyphInstance } from "../types/glyph.js";
+export declare class WebglSdfGlyphPipeline {
+    private readonly gl;
+    private readonly program;
+    private readonly batches;
+    private atlasTexture;
+    private ownsAtlas;
+    private geometryBuilds;
+    constructor(gl: WebGL2RenderingContext);
+    setAtlas(texture: WebGLTexture): void;
+    upload(key: string, vertices: Float32Array): void;
+    draw(key: string, stateTexture: WebGLTexture, maskTexture: WebGLTexture, stateWidth: number, commandMaskTexture?: WebGLTexture, commandStateTexture?: WebGLTexture, commandWidth?: number, previewTransformTexture?: WebGLTexture): {
+        drawCalls: number;
+        instances: number;
+        bytes: number;
+    };
+    stats(): {
+        geometryBuilds: number;
+        batches: number;
+        bytes: number;
+    };
+    clearBatches(): void;
+    destroy(): void;
+    private deleteBatch;
+}
+export declare function buildSdfGlyphInstanceVertices(instances: GlyphInstance[], layerSlots: ReadonlyMap<string, number>, clips?: ReadonlyMap<string, [[number, number], [number, number], [number, number], [number, number]]>, commandSlots?: ReadonlyMap<string, number>): Float32Array;