@slowclap/rezi-core 0.1.0-fork.1

package/dist/drawlist/builderBase.js

@@ -0,0 +1,879 @@
+import { ZRDL_MAGIC } from "../abi.js";
+export const HEADER_SIZE = 64;
+export const DEFAULT_MAX_DRAWLIST_BYTES = 2 * 1024 * 1024;
+export const DEFAULT_MAX_CMD_COUNT = 100_000;
+export const DEFAULT_MAX_BLOB_BYTES = 512 * 1024;
+export const DEFAULT_MAX_BLOBS = 10_000;
+export const DEFAULT_MAX_STRING_BYTES = 512 * 1024;
+export const DEFAULT_MAX_STRINGS = 10_000;
+const ENCODED_STRING_CACHE_MAX_KEY_LENGTH = 96;
+export const INT32_MIN = -2147483648;
+export const INT32_MAX = 2147483647;
+export const OP_CLEAR = 1;
+export const OP_FILL_RECT = 2;
+export const OP_DRAW_TEXT = 3;
+export const OP_PUSH_CLIP = 4;
+export const OP_POP_CLIP = 5;
+export const OP_DRAW_TEXT_RUN = 6;
+export const OP_SET_CURSOR = 7;
+export function align4(n) {
+    const remainder = n % 4;
+    return remainder === 0 ? n : n + (4 - remainder);
+}
+export function isObject(v) {
+    return typeof v === "object" && v !== null;
+}
+export function isTextRunSegment(v) {
+    if (typeof v !== "object" || v === null)
+        return false;
+    if (typeof v.text !== "string")
+        return false;
+    return true;
+}
+export class DrawlistBuilderBase {
+    builderName;
+    maxDrawlistBytes;
+    maxCmdCount;
+    maxBlobBytes;
+    maxBlobs;
+    maxStringBytes;
+    maxStrings;
+    validateParams;
+    reuseOutputBuffer;
+    encodedStringCacheCap;
+    encoder;
+    cmdBuf;
+    cmdDv;
+    cmdLen = 0;
+    cmdCount = 0;
+    stringIndexByValue = new Map();
+    stringSpanOffs = [];
+    stringSpanLens = [];
+    stringBytesBuf;
+    stringBytesLen = 0;
+    blobSpanOffs = [];
+    blobSpanLens = [];
+    blobBytesBuf;
+    blobBytesLen = 0;
+    outBuf = null;
+    encodedStringCache;
+    textEncoderCalls = 0;
+    error;
+    constructor(opts, builderName) {
+        this.builderName = builderName;
+        const maxDrawlistBytes = opts.maxDrawlistBytes ?? DEFAULT_MAX_DRAWLIST_BYTES;
+        const maxCmdCount = opts.maxCmdCount ?? DEFAULT_MAX_CMD_COUNT;
+        const maxBlobBytes = opts.maxBlobBytes ?? DEFAULT_MAX_BLOB_BYTES;
+        const maxBlobs = opts.maxBlobs ?? DEFAULT_MAX_BLOBS;
+        const maxStringBytes = opts.maxStringBytes ?? DEFAULT_MAX_STRING_BYTES;
+        const maxStrings = opts.maxStrings ?? DEFAULT_MAX_STRINGS;
+        const validateParams = opts.validateParams ?? true;
+        const reuseOutputBuffer = opts.reuseOutputBuffer === true;
+        const encodedStringCacheCap = opts.encodedStringCacheCap ?? 0;
+        this.maxDrawlistBytes = this.requirePositiveInt("maxDrawlistBytes", maxDrawlistBytes);
+        this.maxCmdCount = this.requirePositiveInt("maxCmdCount", maxCmdCount);
+        this.maxBlobBytes = this.requirePositiveInt("maxBlobBytes", maxBlobBytes);
+        this.maxBlobs = this.requirePositiveInt("maxBlobs", maxBlobs);
+        this.maxStringBytes = this.requirePositiveInt("maxStringBytes", maxStringBytes);
+        this.maxStrings = this.requirePositiveInt("maxStrings", maxStrings);
+        this.validateParams = validateParams !== false;
+        this.reuseOutputBuffer = reuseOutputBuffer;
+        this.encodedStringCacheCap = this.requireNonNegativeInt("encodedStringCacheCap", encodedStringCacheCap);
+        this.encodedStringCache = this.encodedStringCacheCap > 0 ? new Map() : null;
+        const initialCmdCap = Math.min(4096, this.maxDrawlistBytes);
+        this.cmdBuf = new Uint8Array(initialCmdCap);
+        this.cmdDv = new DataView(this.cmdBuf.buffer, this.cmdBuf.byteOffset, this.cmdBuf.byteLength);
+        const initialStrCap = Math.min(1024, this.maxStringBytes);
+        this.stringBytesBuf = new Uint8Array(initialStrCap);
+        const initialBlobCap = Math.min(1024, this.maxBlobBytes);
+        this.blobBytesBuf = new Uint8Array(initialBlobCap);
+        this.encoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : undefined;
+        if (!this.encoder) {
+            this.fail("ZRDL_INTERNAL", "TextEncoder is not available in this environment");
+        }
+    }
+    clear() {
+        if (this.error)
+            return;
+        this.appendClearCommand();
+        this.maybeFailTooLargeAfterWrite();
+    }
+    clearTo(cols, rows, style) {
+        if (this.error)
+            return;
+        const wi = this.validateParams ? this.requireI32NonNeg("clearTo", "cols", cols) : cols | 0;
+        const hi = this.validateParams ? this.requireI32NonNeg("clearTo", "rows", rows) : rows | 0;
+        if (this.error)
+            return;
+        if (wi === null || hi === null)
+            return;
+        const w = wi < 0 ? 0 : wi;
+        const h = hi < 0 ? 0 : hi;
+        this.clear();
+        this.fillRect(0, 0, w, h, style);
+    }
+    fillRect(x, y, w, h, style) {
+        if (this.error)
+            return;
+        const xi = this.validateParams ? this.requireI32("fillRect", "x", x) : x | 0;
+        const yi = this.validateParams ? this.requireI32("fillRect", "y", y) : y | 0;
+        const wi = this.validateParams ? this.requireI32NonNeg("fillRect", "w", w) : w | 0;
+        const hi = this.validateParams ? this.requireI32NonNeg("fillRect", "h", h) : h | 0;
+        if (this.error)
+            return;
+        if (xi === null || yi === null || wi === null || hi === null)
+            return;
+        const w0 = wi < 0 ? 0 : wi;
+        const h0 = hi < 0 ? 0 : hi;
+        const encodedStyle = this.encodeFillRectStyle(style);
+        this.appendFillRectCommand(xi, yi, w0, h0, encodedStyle);
+        this.maybeFailTooLargeAfterWrite();
+    }
+    drawText(x, y, text, style) {
+        if (this.error)
+            return;
+        const xi = this.validateParams ? this.requireI32("drawText", "x", x) : x | 0;
+        const yi = this.validateParams ? this.requireI32("drawText", "y", y) : y | 0;
+        if (this.error)
+            return;
+        if (xi === null || yi === null)
+            return;
+        if (typeof text !== "string") {
+            this.fail("ZRDL_BAD_PARAMS", `drawText: text must be a string (got ${typeof text})`);
+            return;
+        }
+        const stringIndex = this.internString(text);
+        if (this.error)
+            return;
+        if (stringIndex === null)
+            return;
+        const byteLen = this.stringSpanLens[stringIndex];
+        if (byteLen === undefined) {
+            this.fail("ZRDL_INTERNAL", "drawText: interned string has no recorded span length");
+            return;
+        }
+        const encodedStyle = this.encodeDrawTextStyle(style);
+        this.appendDrawTextCommand(xi, yi, stringIndex, byteLen, encodedStyle);
+        this.maybeFailTooLargeAfterWrite();
+    }
+    pushClip(x, y, w, h) {
+        if (this.error)
+            return;
+        const xi = this.validateParams ? this.requireI32("pushClip", "x", x) : x | 0;
+        const yi = this.validateParams ? this.requireI32("pushClip", "y", y) : y | 0;
+        const wi = this.validateParams ? this.requireI32NonNeg("pushClip", "w", w) : w | 0;
+        const hi = this.validateParams ? this.requireI32NonNeg("pushClip", "h", h) : h | 0;
+        if (this.error)
+            return;
+        if (xi === null || yi === null || wi === null || hi === null)
+            return;
+        const w0 = wi < 0 ? 0 : wi;
+        const h0 = hi < 0 ? 0 : hi;
+        this.appendPushClipCommand(xi, yi, w0, h0);
+        this.maybeFailTooLargeAfterWrite();
+    }
+    popClip() {
+        if (this.error)
+            return;
+        this.appendPopClipCommand();
+        this.maybeFailTooLargeAfterWrite();
+    }
+    addBlob(bytes) {
+        if (this.error)
+            return null;
+        if (!(bytes instanceof Uint8Array)) {
+            this.fail("ZRDL_BAD_PARAMS", "addBlob: bytes must be a Uint8Array");
+            return null;
+        }
+        const byteLen = bytes.byteLength;
+        if (!Number.isInteger(byteLen) || byteLen < 0) {
+            this.fail("ZRDL_BAD_PARAMS", "addBlob: bytes.byteLength must be a non-negative integer");
+            return null;
+        }
+        const nextIndex = this.blobSpanOffs.length;
+        if (nextIndex + 1 > this.maxBlobs) {
+            this.fail("ZRDL_TOO_LARGE", `addBlob: maxBlobs exceeded (count=${nextIndex + 1}, max=${this.maxBlobs})`);
+            return null;
+        }
+        const nextBytesLen = this.blobBytesLen + byteLen;
+        if (nextBytesLen > this.maxBlobBytes) {
+            this.fail("ZRDL_TOO_LARGE", `addBlob: maxBlobBytes exceeded (bytes=${nextBytesLen}, max=${this.maxBlobBytes})`);
+            return null;
+        }
+        this.ensureBlobBytesCapacity(nextBytesLen);
+        if (this.error)
+            return null;
+        const off = this.blobBytesLen;
+        this.blobBytesBuf.set(bytes, off);
+        this.blobBytesLen = nextBytesLen;
+        this.blobSpanOffs.push(off);
+        this.blobSpanLens.push(byteLen);
+        this.maybeFailTooLargeAfterWrite();
+        return nextIndex;
+    }
+    addTextRunBlob(segments) {
+        if (this.error)
+            return null;
+        if (!Array.isArray(segments)) {
+            this.fail("ZRDL_BAD_PARAMS", "addTextRunBlob: segments must be an array");
+            return null;
+        }
+        if (segments.length === 0) {
+            this.fail("ZRDL_BAD_PARAMS", "addTextRunBlob: segments must be non-empty");
+            return null;
+        }
+        if (segments.length > 0xffff_ffff) {
+            this.fail("ZRDL_BAD_PARAMS", "addTextRunBlob: segments length exceeds u32");
+            return null;
+        }
+        const segmentSize = this.textRunBlobSegmentSize();
+        const blobLen = 4 + segments.length * segmentSize;
+        const blob = new Uint8Array(blobLen);
+        const dv = new DataView(blob.buffer, blob.byteOffset, blob.byteLength);
+        dv.setUint32(0, segments.length >>> 0, true);
+        let off = 4;
+        for (const seg0 of segments) {
+            if (!isTextRunSegment(seg0)) {
+                this.fail("ZRDL_BAD_PARAMS", "addTextRunBlob: each segment must be an object with { text: string, style?: TextStyle }");
+                return null;
+            }
+            const stringIndex = this.internString(seg0.text);
+            if (this.error)
+                return null;
+            if (stringIndex === null)
+                return null;
+            const byteLen = this.stringSpanLens[stringIndex];
+            if (byteLen === undefined) {
+                this.fail("ZRDL_INTERNAL", "addTextRunBlob: interned string has no recorded span length");
+                return null;
+            }
+            const encodedStyle = this.encodeTextRunStyle(seg0.style);
+            off = this.writeTextRunBlobSegment(dv, off, encodedStyle, stringIndex, byteLen);
+        }
+        return this.addBlob(blob);
+    }
+    drawTextRun(x, y, blobIndex) {
+        if (this.error)
+            return;
+        const xi = this.validateParams ? this.requireI32("drawTextRun", "x", x) : x | 0;
+        const yi = this.validateParams ? this.requireI32("drawTextRun", "y", y) : y | 0;
+        if (this.error)
+            return;
+        if (xi === null || yi === null)
+            return;
+        const bi = this.validateParams ? blobIndex : blobIndex >>> 0;
+        if (this.validateParams) {
+            if (!Number.isFinite(bi) || !Number.isInteger(bi) || bi < 0 || bi > 0xffff_ffff) {
+                this.fail("ZRDL_BAD_PARAMS", "drawTextRun: blobIndex must be a u32");
+                return;
+            }
+        }
+        if (bi >= this.blobSpanOffs.length) {
+            this.fail("ZRDL_BAD_PARAMS", `drawTextRun: blobIndex out of range (blobIndex=${bi}, blobsCount=${this.blobSpanOffs.length})`);
+            return;
+        }
+        this.appendDrawTextRunCommand(xi, yi, bi);
+        this.maybeFailTooLargeAfterWrite();
+    }
+    reset() {
+        this.error = undefined;
+        if (!this.encoder) {
+            this.fail("ZRDL_INTERNAL", "TextEncoder is not available in this environment");
+            return;
+        }
+        this.cmdLen = 0;
+        this.cmdCount = 0;
+        this.stringIndexByValue.clear();
+        this.stringSpanOffs.length = 0;
+        this.stringSpanLens.length = 0;
+        this.stringBytesLen = 0;
+        this.textEncoderCalls = 0;
+        this.blobSpanOffs.length = 0;
+        this.blobSpanLens.length = 0;
+        this.blobBytesLen = 0;
+    }
+    encodeTextRunStyle(style) {
+        return this.encodeDrawTextStyle(style);
+    }
+    buildWithVersion(version) {
+        if (this.error) {
+            return { ok: false, error: this.error };
+        }
+        const estimatedTotal = this.estimateTotalSize();
+        if (estimatedTotal > this.maxDrawlistBytes) {
+            return {
+                ok: false,
+                error: {
+                    code: "ZRDL_TOO_LARGE",
+                    detail: `build: maxDrawlistBytes exceeded (total=${estimatedTotal}, max=${this.maxDrawlistBytes})`,
+                },
+            };
+        }
+        const outBuf = this.reuseOutputBuffer
+            ? this.ensureOutputCapacity(estimatedTotal)
+            : new Uint8Array(estimatedTotal);
+        if (this.error) {
+            return { ok: false, error: this.error };
+        }
+        return this.buildIntoWithVersion(version, outBuf);
+    }
+    buildIntoWithVersion(version, dst) {
+        if (this.error) {
+            return { ok: false, error: this.error };
+        }
+        if (!(dst instanceof Uint8Array)) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_BAD_PARAMS", detail: "buildInto: dst must be a Uint8Array" },
+            };
+        }
+        const prepared = this.prepareBuildLayout();
+        if ("ok" in prepared)
+            return prepared;
+        const layout = prepared;
+        if (dst.byteLength < layout.totalSize) {
+            return {
+                ok: false,
+                error: {
+                    code: "ZRDL_TOO_LARGE",
+                    detail: `buildInto: dst is too small (required=${layout.totalSize}, got=${dst.byteLength})`,
+                },
+            };
+        }
+        return this.writeBuildInto(version, layout, dst);
+    }
+    prepareBuildLayout() {
+        if ((this.cmdLen & 3) !== 0) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_INTERNAL", detail: "build: command stream is not 4-byte aligned" },
+            };
+        }
+        const cmdCount = this.cmdCount;
+        let cursor = HEADER_SIZE;
+        const cmdBytes = cmdCount === 0 ? 0 : this.cmdLen;
+        const cmdOffset = cmdCount === 0 ? 0 : cursor;
+        cursor += cmdBytes;
+        const stringsCount = this.stringSpanOffs.length;
+        const stringsSpanBytes = stringsCount * 8;
+        const stringsSpanOffset = stringsCount === 0 ? 0 : cursor;
+        cursor += stringsSpanBytes;
+        const stringsBytesOffset = stringsCount === 0 ? 0 : cursor;
+        const stringsBytesLen = stringsCount === 0 ? 0 : align4(this.stringBytesLen);
+        cursor += stringsBytesLen;
+        const blobsCount = this.blobSpanOffs.length;
+        const blobsSpanBytes = blobsCount * 8;
+        const blobsSpanOffset = blobsCount === 0 ? 0 : cursor;
+        cursor += blobsSpanBytes;
+        const blobsBytesOffset = blobsCount === 0 ? 0 : cursor;
+        const blobsBytesLen = blobsCount === 0 ? 0 : align4(this.blobBytesLen);
+        cursor += blobsBytesLen;
+        const totalSize = cursor;
+        const layout = {
+            cmdOffset,
+            cmdBytes,
+            cmdCount,
+            stringsSpanOffset,
+            stringsCount,
+            stringsSpanBytes,
+            stringsBytesOffset,
+            stringsBytesLen,
+            blobsSpanOffset,
+            blobsCount,
+            blobsBytesOffset,
+            blobsBytesLen,
+            totalSize,
+        };
+        const formatFail = this.validateLayout(layout);
+        if (formatFail)
+            return formatFail;
+        if (totalSize > this.maxDrawlistBytes) {
+            return {
+                ok: false,
+                error: {
+                    code: "ZRDL_TOO_LARGE",
+                    detail: `build: maxDrawlistBytes exceeded (total=${totalSize}, max=${this.maxDrawlistBytes})`,
+                },
+            };
+        }
+        return layout;
+    }
+    writeBuildInto(version, layout, dst) {
+        const out = dst.subarray(0, layout.totalSize);
+        const dv = new DataView(out.buffer, out.byteOffset, out.byteLength);
+        dv.setUint32(0, ZRDL_MAGIC, true);
+        dv.setUint32(4, version >>> 0, true);
+        dv.setUint32(8, HEADER_SIZE, true);
+        dv.setUint32(12, layout.totalSize, true);
+        dv.setUint32(16, layout.cmdOffset, true);
+        dv.setUint32(20, layout.cmdBytes, true);
+        dv.setUint32(24, layout.cmdCount, true);
+        dv.setUint32(28, layout.stringsSpanOffset, true);
+        dv.setUint32(32, layout.stringsCount, true);
+        dv.setUint32(36, layout.stringsBytesOffset, true);
+        dv.setUint32(40, layout.stringsBytesLen, true);
+        dv.setUint32(44, layout.blobsSpanOffset, true);
+        dv.setUint32(48, layout.blobsCount, true);
+        dv.setUint32(52, layout.blobsBytesOffset, true);
+        dv.setUint32(56, layout.blobsBytesLen, true);
+        dv.setUint32(60, 0, true);
+        out.set(this.cmdBuf.subarray(0, layout.cmdBytes), layout.cmdOffset);
+        let spanOff = layout.stringsSpanOffset;
+        for (let i = 0; i < layout.stringsCount; i++) {
+            const off = this.stringSpanOffs[i];
+            const len = this.stringSpanLens[i];
+            if (off === undefined || len === undefined) {
+                return {
+                    ok: false,
+                    error: { code: "ZRDL_INTERNAL", detail: "build: string span table is inconsistent" },
+                };
+            }
+            dv.setUint32(spanOff, off >>> 0, true);
+            dv.setUint32(spanOff + 4, len >>> 0, true);
+            spanOff += 8;
+        }
+        const stringsBytesLenRaw = this.stringBytesLen;
+        out.set(this.stringBytesBuf.subarray(0, stringsBytesLenRaw), layout.stringsBytesOffset);
+        if (layout.stringsBytesLen > stringsBytesLenRaw) {
+            out.fill(0, layout.stringsBytesOffset + stringsBytesLenRaw, layout.stringsBytesOffset + layout.stringsBytesLen);
+        }
+        spanOff = layout.blobsSpanOffset;
+        for (let i = 0; i < layout.blobsCount; i++) {
+            const off = this.blobSpanOffs[i];
+            const len = this.blobSpanLens[i];
+            if (off === undefined || len === undefined) {
+                return {
+                    ok: false,
+                    error: { code: "ZRDL_INTERNAL", detail: "build: blob span table is inconsistent" },
+                };
+            }
+            dv.setUint32(spanOff, off >>> 0, true);
+            dv.setUint32(spanOff + 4, len >>> 0, true);
+            spanOff += 8;
+        }
+        const blobsBytesLenRaw = this.blobBytesLen;
+        out.set(this.blobBytesBuf.subarray(0, blobsBytesLenRaw), layout.blobsBytesOffset);
+        if (layout.blobsBytesLen > blobsBytesLenRaw) {
+            out.fill(0, layout.blobsBytesOffset + blobsBytesLenRaw, layout.blobsBytesOffset + layout.blobsBytesLen);
+        }
+        return { ok: true, bytes: out };
+    }
+    requirePositiveInt(name, v) {
+        if (!Number.isFinite(v) || !Number.isInteger(v) || v <= 0) {
+            this.fail("ZRDL_BAD_PARAMS", `${this.builderName}: ${name} must be a positive integer (got ${String(v)})`);
+            return 1;
+        }
+        if (v > 0x7fff_ffff) {
+            this.fail("ZRDL_BAD_PARAMS", `${this.builderName}: ${name} must be <= 2147483647 (got ${String(v)})`);
+            return 1;
+        }
+        return v;
+    }
+    requireNonNegativeInt(name, v) {
+        if (!Number.isFinite(v) || !Number.isInteger(v) || v < 0) {
+            this.fail("ZRDL_BAD_PARAMS", `${this.builderName}: ${name} must be a non-negative integer (got ${String(v)})`);
+            return 0;
+        }
+        if (v > 0x7fff_ffff) {
+            this.fail("ZRDL_BAD_PARAMS", `${this.builderName}: ${name} must be <= 2147483647 (got ${String(v)})`);
+            return 0;
+        }
+        return v;
+    }
+    requireI32(method, name, v) {
+        if (!Number.isFinite(v)) {
+            this.fail("ZRDL_BAD_PARAMS", `${method}: ${name} must be finite (got ${String(v)})`);
+            return null;
+        }
+        if (!Number.isInteger(v) || v < INT32_MIN || v > INT32_MAX) {
+            this.fail("ZRDL_BAD_PARAMS", `${method}: ${name} must be an int32 (got ${String(v)})`);
+            return null;
+        }
+        return v | 0;
+    }
+    requireI32NonNeg(method, name, v) {
+        const iv = this.requireI32(method, name, v);
+        if (iv === null)
+            return null;
+        if (iv < 0) {
+            this.fail("ZRDL_BAD_PARAMS", `${method}: ${name} must be >= 0 (got ${String(v)})`);
+            return null;
+        }
+        return iv;
+    }
+    fail(code, detail) {
+        if (this.error)
+            return;
+        this.error = { code, detail };
+    }
+    getTextEncoderCallCount() {
+        return this.textEncoderCalls;
+    }
+    internString(text) {
+        const existing = this.stringIndexByValue.get(text);
+        if (existing !== undefined)
+            return existing;
+        if (!this.encoder) {
+            this.fail("ZRDL_INTERNAL", "drawText: TextEncoder is not available");
+            return null;
+        }
+        const nextIndex = this.stringSpanOffs.length;
+        if (nextIndex + 1 > this.maxStrings) {
+            this.fail("ZRDL_TOO_LARGE", `drawText: maxStrings exceeded (count=${nextIndex + 1}, max=${this.maxStrings})`);
+            return null;
+        }
+        const cacheEligible = text.length <= ENCODED_STRING_CACHE_MAX_KEY_LENGTH;
+        const cache = cacheEligible ? this.encodedStringCache : null;
+        const cached = cache?.get(text);
+        const encoded = cached ?? this.encodeUtf8(text);
+        if (!cached && cache) {
+            if (cache.size >= this.encodedStringCacheCap) {
+                cache.clear();
+            }
+            cache.set(text, encoded);
+        }
+        const byteLen = encoded.byteLength;
+        const nextBytesLen = this.stringBytesLen + byteLen;
+        if (nextBytesLen > this.maxStringBytes) {
+            this.fail("ZRDL_TOO_LARGE", `drawText: maxStringBytes exceeded (bytes=${nextBytesLen}, max=${this.maxStringBytes})`);
+            return null;
+        }
+        this.ensureStringBytesCapacity(nextBytesLen);
+        if (this.error)
+            return null;
+        const off = this.stringBytesLen;
+        this.stringBytesBuf.set(encoded, off);
+        this.stringBytesLen = nextBytesLen;
+        this.stringSpanOffs.push(off);
+        this.stringSpanLens.push(byteLen);
+        this.stringIndexByValue.set(text, nextIndex);
+        this.maybeFailTooLargeAfterWrite();
+        return nextIndex;
+    }
+    encodeUtf8(text) {
+        let asciiOnly = true;
+        for (let i = 0; i < text.length; i++) {
+            if (text.charCodeAt(i) > 0x7f) {
+                asciiOnly = false;
+                break;
+            }
+        }
+        if (asciiOnly) {
+            const out = new Uint8Array(text.length);
+            for (let i = 0; i < text.length; i++) {
+                out[i] = text.charCodeAt(i) & 0x7f;
+            }
+            return out;
+        }
+        this.textEncoderCalls += 1;
+        return this.encoder ? this.encoder.encode(text) : new Uint8Array();
+    }
+    ensureCmdCapacity(required) {
+        if (required <= this.cmdBuf.byteLength)
+            return;
+        const minTotal = HEADER_SIZE + required;
+        if (minTotal > this.maxDrawlistBytes) {
+            this.fail("ZRDL_TOO_LARGE", `command stream exceeds maxDrawlistBytes (minTotal=${minTotal}, max=${this.maxDrawlistBytes})`);
+            return;
+        }
+        let nextCap = this.cmdBuf.byteLength;
+        while (nextCap < required)
+            nextCap = Math.min(nextCap * 2, this.maxDrawlistBytes);
+        if (nextCap < required) {
+            this.fail("ZRDL_TOO_LARGE", `command stream exceeds maxDrawlistBytes (required=${required}, max=${this.maxDrawlistBytes})`);
+            return;
+        }
+        const next = new Uint8Array(nextCap);
+        next.set(this.cmdBuf.subarray(0, this.cmdLen));
+        this.cmdBuf = next;
+        this.cmdDv = new DataView(this.cmdBuf.buffer, this.cmdBuf.byteOffset, this.cmdBuf.byteLength);
+    }
+    ensureOutputCapacity(required) {
+        const existing = this.outBuf;
+        if (existing && existing.byteLength >= required)
+            return existing;
+        let nextCap = existing ? existing.byteLength : 0;
+        if (nextCap === 0)
+            nextCap = Math.min(4096, this.maxDrawlistBytes);
+        while (nextCap < required)
+            nextCap = Math.min(nextCap * 2, this.maxDrawlistBytes);
+        if (nextCap < required) {
+            this.fail("ZRDL_TOO_LARGE", `output buffer exceeds maxDrawlistBytes (required=${required}, max=${this.maxDrawlistBytes})`);
+            return existing ?? new Uint8Array(required);
+        }
+        const next = new Uint8Array(nextCap);
+        this.outBuf = next;
+        return next;
+    }
+    ensureStringBytesCapacity(required) {
+        if (required <= this.stringBytesBuf.byteLength)
+            return;
+        if (required > this.maxStringBytes) {
+            this.fail("ZRDL_TOO_LARGE", `string bytes exceed maxStringBytes (required=${required}, max=${this.maxStringBytes})`);
+            return;
+        }
+        let nextCap = this.stringBytesBuf.byteLength;
+        while (nextCap < required)
+            nextCap = Math.min(nextCap * 2, this.maxStringBytes);
+        if (nextCap < required) {
+            this.fail("ZRDL_TOO_LARGE", `string bytes exceed maxStringBytes (required=${required}, max=${this.maxStringBytes})`);
+            return;
+        }
+        const next = new Uint8Array(nextCap);
+        next.set(this.stringBytesBuf.subarray(0, this.stringBytesLen));
+        this.stringBytesBuf = next;
+    }
+    ensureBlobBytesCapacity(required) {
+        if (required <= this.blobBytesBuf.byteLength)
+            return;
+        if (required > this.maxBlobBytes) {
+            this.fail("ZRDL_TOO_LARGE", `blob bytes exceed maxBlobBytes (required=${required}, max=${this.maxBlobBytes})`);
+            return;
+        }
+        let nextCap = this.blobBytesBuf.byteLength;
+        while (nextCap < required)
+            nextCap = Math.min(nextCap * 2, this.maxBlobBytes);
+        if (nextCap < required) {
+            this.fail("ZRDL_TOO_LARGE", `blob bytes exceed maxBlobBytes (required=${required}, max=${this.maxBlobBytes})`);
+            return;
+        }
+        const next = new Uint8Array(nextCap);
+        next.set(this.blobBytesBuf.subarray(0, this.blobBytesLen));
+        this.blobBytesBuf = next;
+    }
+    writeCommandHeader(opcode, size) {
+        if (this.error)
+            return;
+        if (this.cmdCount + 1 > this.maxCmdCount) {
+            this.fail("ZRDL_TOO_LARGE", `maxCmdCount exceeded (count=${this.cmdCount + 1}, max=${this.maxCmdCount})`);
+            return;
+        }
+        const expected = this.expectedCmdSize(opcode);
+        if (expected !== size) {
+            this.fail("ZRDL_FORMAT", `writeCommandHeader: size mismatch for opcode ${opcode} (expected=${expected}, got=${size})`);
+            return;
+        }
+        if ((this.cmdLen & 3) !== 0) {
+            this.fail("ZRDL_INTERNAL", "writeCommandHeader: cmd cursor is not 4-byte aligned");
+            return;
+        }
+        const alignedSize = align4(size);
+        const start = this.cmdLen;
+        const end = start + alignedSize;
+        this.ensureCmdCapacity(end);
+        if (this.error)
+            return;
+        this.cmdDv.setUint16(start + 0, opcode & 0xffff, true);
+        this.cmdDv.setUint16(start + 2, 0, true);
+        this.cmdDv.setUint32(start + 4, size >>> 0, true);
+        if (alignedSize !== size) {
+            this.cmdBuf.fill(0x00, start + size, end);
+        }
+        this.cmdLen = start + 8;
+        this.cmdCount += 1;
+    }
+    expectedCmdSize(_opcode) {
+        return -1;
+    }
+    writeI32(v) {
+        const off = this.cmdLen;
+        this.cmdDv.setInt32(off, v | 0, true);
+        this.cmdLen = off + 4;
+    }
+    writeU32(v) {
+        const off = this.cmdLen;
+        this.cmdDv.setUint32(off, v >>> 0, true);
+        this.cmdLen = off + 4;
+    }
+    writeU8(v) {
+        const off = this.cmdLen;
+        this.cmdBuf[off] = v & 0xff;
+        this.cmdLen = off + 1;
+    }
+    padCmdTo4() {
+        const aligned = align4(this.cmdLen);
+        if (aligned === this.cmdLen)
+            return;
+        this.cmdBuf.fill(0x00, this.cmdLen, aligned);
+        this.cmdLen = aligned;
+    }
+    beginCommandWrite(method, size) {
+        if (this.error)
+            return false;
+        if (this.cmdCount + 1 > this.maxCmdCount) {
+            this.fail("ZRDL_TOO_LARGE", `maxCmdCount exceeded (count=${this.cmdCount + 1}, max=${this.maxCmdCount})`);
+            return false;
+        }
+        if ((this.cmdLen & 3) !== 0) {
+            this.fail("ZRDL_INTERNAL", "writeCommandHeader: cmd cursor is not 4-byte aligned");
+            return false;
+        }
+        const required = this.cmdLen + size;
+        this.ensureCmdCapacity(required);
+        if (this.error)
+            return false;
+        if (required > this.cmdBuf.byteLength) {
+            this.failCapacity(method, size);
+            return false;
+        }
+        return true;
+    }
+    failCapacity(method, size) {
+        const required = this.cmdLen + size;
+        this.fail("ZRDL_TOO_LARGE", `${method}: command stream exceeds maxDrawlistBytes (required=${required}, max=${this.maxDrawlistBytes})`);
+    }
+    maybeFailTooLargeAfterWrite() {
+        if (this.error)
+            return;
+        const estimate = this.estimateTotalSize();
+        if (estimate > this.maxDrawlistBytes) {
+            this.fail("ZRDL_TOO_LARGE", `maxDrawlistBytes exceeded (estimatedTotal=${estimate}, max=${this.maxDrawlistBytes})`);
+        }
+    }
+    estimateTotalSize() {
+        const cmdOffset = HEADER_SIZE;
+        const cmdBytes = this.cmdLen;
+        const stringsCount = this.stringSpanOffs.length;
+        const stringsSpanBytes = stringsCount * 8;
+        const stringsSpanOffset = cmdOffset + cmdBytes;
+        const stringsBytesOffset = stringsSpanOffset + stringsSpanBytes;
+        const stringsBytesAligned = align4(this.stringBytesLen);
+        const blobsCount = this.blobSpanOffs.length;
+        const blobsSpanBytes = blobsCount * 8;
+        const blobsSpanOffset = stringsBytesOffset + stringsBytesAligned;
+        const blobsBytesOffset = blobsSpanOffset + blobsSpanBytes;
+        const blobsBytesAligned = align4(this.blobBytesLen);
+        return blobsBytesOffset + blobsBytesAligned;
+    }
+    validateLayout(layout) {
+        const { cmdOffset, cmdBytes, cmdCount, stringsSpanOffset, stringsCount, stringsSpanBytes, stringsBytesOffset, stringsBytesLen, blobsSpanOffset, blobsCount, blobsBytesOffset, blobsBytesLen, totalSize, } = layout;
+        if (cmdCount === 0) {
+            if (cmdOffset !== 0 || cmdBytes !== 0) {
+                return {
+                    ok: false,
+                    error: {
+                        code: "ZRDL_FORMAT",
+                        detail: "build: cmdOffset/cmdBytes must be 0 when cmdCount is 0",
+                    },
+                };
+            }
+        }
+        else if (cmdOffset !== HEADER_SIZE) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_FORMAT", detail: `build: cmdOffset must be ${HEADER_SIZE}` },
+            };
+        }
+        if ((cmdOffset & 3) !== 0) {
+            return { ok: false, error: { code: "ZRDL_FORMAT", detail: "build: cmdOffset misaligned" } };
+        }
+        if ((cmdBytes & 3) !== 0) {
+            return { ok: false, error: { code: "ZRDL_FORMAT", detail: "build: cmdBytes misaligned" } };
+        }
+        if (cmdCount !== this.cmdCount) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_INTERNAL", detail: "build: cmdCount mismatch" },
+            };
+        }
+        if ((stringsSpanOffset & 3) !== 0) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_FORMAT", detail: "build: stringsSpanOffset misaligned" },
+            };
+        }
+        if (stringsCount !== this.stringSpanOffs.length) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_INTERNAL", detail: "build: stringsCount mismatch" },
+            };
+        }
+        if (stringsSpanBytes !== stringsCount * 8) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_INTERNAL", detail: "build: stringsSpanBytes mismatch" },
+            };
+        }
+        if (stringsCount === 0) {
+            if (stringsSpanOffset !== 0 || stringsBytesOffset !== 0 || stringsBytesLen !== 0) {
+                return {
+                    ok: false,
+                    error: {
+                        code: "ZRDL_FORMAT",
+                        detail: "build: strings offsets/len must be 0 when stringsCount is 0",
+                    },
+                };
+            }
+        }
+        if ((stringsBytesOffset & 3) !== 0) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_FORMAT", detail: "build: stringsBytesOffset misaligned" },
+            };
+        }
+        if ((stringsBytesLen & 3) !== 0) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_FORMAT", detail: "build: stringsBytesLen misaligned" },
+            };
+        }
+        if (stringsBytesLen !== align4(this.stringBytesLen)) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_INTERNAL", detail: "build: stringsBytesLen mismatch" },
+            };
+        }
+        if ((blobsSpanOffset & 3) !== 0) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_FORMAT", detail: "build: blobsSpanOffset misaligned" },
+            };
+        }
+        if (blobsCount !== this.blobSpanOffs.length) {
+            return { ok: false, error: { code: "ZRDL_INTERNAL", detail: "build: blobsCount mismatch" } };
+        }
+        if (blobsCount === 0) {
+            if (blobsSpanOffset !== 0 || blobsBytesOffset !== 0 || blobsBytesLen !== 0) {
+                return {
+                    ok: false,
+                    error: {
+                        code: "ZRDL_FORMAT",
+                        detail: "build: blobs offsets/len must be 0 when blobsCount is 0",
+                    },
+                };
+            }
+        }
+        if ((blobsBytesOffset & 3) !== 0) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_FORMAT", detail: "build: blobsBytesOffset misaligned" },
+            };
+        }
+        if ((blobsBytesLen & 3) !== 0) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_FORMAT", detail: "build: blobsBytesLen misaligned" },
+            };
+        }
+        if (blobsBytesLen !== align4(this.blobBytesLen)) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_INTERNAL", detail: "build: blobsBytesLen mismatch" },
+            };
+        }
+        if ((totalSize & 3) !== 0) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_FORMAT", detail: "build: totalSize must be 4-byte aligned" },
+            };
+        }
+        if (totalSize < HEADER_SIZE) {
+            return {
+                ok: false,
+                error: { code: "ZRDL_INTERNAL", detail: "build: totalSize underflow" },
+            };
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=builderBase.js.map