@arcblock/did-connect-service 4.1.56 → 4.1.57

package/dist/og/tree.js

@@ -0,0 +1,921 @@
+/**
+ * Runtime-neutral half of the tree renderer (`renderOgTree`, ArcBlock/did#300).
+ *
+ * A caller hands in a plain satori object tree (the same `{ type, props }`
+ * shape `templates.ts` builds). Before anything is parsed or rasterized, this
+ * module walks the whole tree and enforces the image contract:
+ *
+ *  - every image reference (`src`, `href`, any `url(...)` in a style or other
+ *    prop) must be a `data:` URI — anything else rejects the WHOLE render and
+ *    no request is ever made (keeps did#220's no-remote-media stance);
+ *  - the bytes must be PNG / JPEG / SVG by magic bytes, matching the declared
+ *    MIME type;
+ *  - hard limits are read from the image headers (never by decoding):
+ *    PNG/JPEG ≤ 1.5 MP and ≤ 1 MB each, SVG ≤ 256 KB, the whole tree
+ *    ≤ 2.5 MP and ≤ 2 MB of raw image bytes. Nothing is resized; an
+ *    over-limit tree is refused with a code that names the reason.
+ *
+ * Both runtime entries (`worker.ts` → `og-worker`, `tree-node.ts` → `og-node`)
+ * call {@link validateOgTree} and share {@link createSerialQueue}.
+ */
+import { OgValidationError } from "./types.js";
+/** Font family name trees should use in `fontFamily` (same as the templates). */
+export const OG_TREE_FONT_FAMILY = "Noto";
+export const OG_TREE_LIMITS = {
+    /** PNG/JPEG: max pixels per image. */
+    maxImagePixels: 1_500_000,
+    /** PNG/JPEG: max raw bytes per image. */
+    maxImageBytes: 1_000_000,
+    /** SVG: max raw bytes per image. */
+    maxSvgBytes: 256 * 1024,
+    /** Sum of PNG/JPEG pixels over every image occurrence in the tree. */
+    maxTotalPixels: 2_500_000,
+    /** Sum of raw image bytes (all types) over every image occurrence. */
+    maxTotalBytes: 2_000_000,
+    /** Image occurrences per tree. */
+    maxImages: 32,
+    /** Output canvas. */
+    maxCanvasDimension: 2400,
+    maxCanvasPixels: 1_000_000,
+    /** Tree shape. */
+    maxDepth: 64,
+    maxNodes: 5000,
+    /** Characters per text string (satori lays out every glyph). */
+    maxStringChars: 2000,
+    /** Characters of text over the whole tree. */
+    maxTextChars: 10_000,
+    /** Characters per non-image prop string; inline `<svg>` props (path data) get more. */
+    maxPropStringChars: 2000,
+    maxSvgPropStringChars: 16_384,
+    /** Characters over all non-image prop strings in the tree. */
+    maxPropChars: 65_536,
+    /** box-shadow / text-shadow: entries per value; |offset| per entry, in px. */
+    maxShadows: 4,
+    maxShadowLengthPx: 100,
+    /** Blur radius and spread for shadows, drop-shadow() and blur(), in px — blur drives render cost. */
+    maxBlurPx: 16,
+    maxSpreadPx: 16,
+    /** CSS filter: functions per value. */
+    maxFilterFunctions: 4,
+    /**
+     * Tree-wide effect budget, in units. Render cost of a shadow or filter
+     * follows the AREA it covers, not its blur radius (measured on the Worker
+     * stack: a full-canvas box-shadow ≈ 0.4 s, a CSS filter on a full-canvas
+     * group ≈ 1.6 s at blur 4px and 16px alike). An element's area unit count
+     * is ceil(width × height / 250,000) from numeric px `width`/`height` in its
+     * style, or the whole canvas when either is not a number. Charges:
+     * - each boxShadow entry: 1 × area units;
+     * - each CSS filter function: 1 × area units, `blur()` 4 × area units (so a
+     *   blur fits only on an element ≤ 250,000 px); filters are allowed only on
+     *   elements without children (a filtered group rasterizes its whole,
+     *   possibly overflowing, subtree: 6–8 s measured);
+     * - each textShadow entry: 1 per started 250 characters of every text
+     *   string it reaches (textShadow is inherited, so a declaration on a
+     *   container is paid for every text node below it).
+     * `drop-shadow()` is refused (use boxShadow).
+     */
+    maxEffects: 4,
+    effectAreaUnitPx: 250_000,
+    effectCostBlur: 4,
+    textShadowCharsPerUnit: 250,
+    /** Inline <svg>: nodes and prop characters per tree (paths are costly to rasterize). */
+    maxSvgNodes: 500,
+    maxSvgChars: 16_384,
+};
+export const OG_TREE_ERROR_CODES = {
+    treeInvalid: "OG_TREE_INVALID",
+    canvasInvalid: "OG_TREE_CANVAS_INVALID",
+    weightsInvalid: "OG_TREE_WEIGHTS_INVALID",
+    imageNotDataUri: "OG_IMAGE_NOT_DATA_URI",
+    imageUnsupportedType: "OG_IMAGE_UNSUPPORTED_TYPE",
+    imageUnreadable: "OG_IMAGE_UNREADABLE",
+    imageTooManyPixels: "OG_IMAGE_TOO_MANY_PIXELS",
+    imageTooLarge: "OG_IMAGE_TOO_LARGE",
+    svgTooLarge: "OG_SVG_TOO_LARGE",
+    svgUnsafe: "OG_SVG_UNSAFE",
+    treeTooManyImages: "OG_TREE_TOO_MANY_IMAGES",
+    treeTooManyPixels: "OG_TREE_TOO_MANY_PIXELS",
+    treeTooManyBytes: "OG_TREE_TOO_MANY_BYTES",
+    svgFilterForbidden: "OG_SVG_FILTER_FORBIDDEN",
+    shadowLimit: "OG_TREE_SHADOW_LIMIT",
+    cssFilterLimit: "OG_TREE_FILTER_LIMIT",
+    textTooLong: "OG_TREE_TEXT_TOO_LONG",
+    /** satori/resvg failed on a tree that passed validation (generic; no input echoed). */
+    renderFailed: "OG_TREE_RENDER_FAILED",
+};
+/** Rejection of a tree render. `statusCode` 400 (inherited): the input is at fault. */
+export class OgTreeRenderError extends OgValidationError {
+    code;
+    constructor(code, message) {
+        super(`${code}: ${message}`);
+        this.name = "OgTreeRenderError";
+        this.code = code;
+    }
+}
+export const OG_RENDER_UNAVAILABLE_CODES = {
+    /** A font read did not finish within the timeout; the cached slot was dropped. */
+    fontTimeout: "OG_FONT_TIMEOUT",
+    /** The render waited in the isolate/process queue past its deadline. */
+    queueTimeout: "OG_QUEUE_TIMEOUT",
+};
+/** The renderer is temporarily unable to serve (font storage hung, queue backed up). Retryable: 503. */
+export class OgRenderUnavailableError extends Error {
+    statusCode = 503;
+    code;
+    constructor(code, message) {
+        super(`${code}: ${message}`);
+        this.name = "OgRenderUnavailableError";
+        this.code = code;
+    }
+}
+/** Rejects with `onTimeout()` if `promise` has not settled within `ms`. */
+export function withTimeout(promise, ms, onTimeout) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(onTimeout()), ms);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+const PNG_MAGIC = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+const JPEG_MAGIC = [0xff, 0xd8, 0xff];
+function bytesStartWith(bytes, magic) {
+    if (bytes.length < magic.length)
+        return false;
+    for (let i = 0; i < magic.length; i++) {
+        if (bytes[i] !== magic[i])
+            return false;
+    }
+    return true;
+}
+/** SVG has no binary magic number — sniff the head as trimmed XML/tag text. */
+function looksLikeSvg(bytes) {
+    const head = bytes.subarray(0, Math.min(bytes.length, 512));
+    const text = new TextDecoder("utf-8", { fatal: false }).decode(head).trimStart();
+    return text.startsWith("<?xml") || /^<svg[\s>]/i.test(text);
+}
+/** Detects PNG / JPEG / SVG from the bytes themselves; anything else is `undefined`. */
+export function sniffOgImageKind(bytes) {
+    if (bytesStartWith(bytes, PNG_MAGIC))
+        return "png";
+    if (bytesStartWith(bytes, JPEG_MAGIC))
+        return "jpeg";
+    if (looksLikeSvg(bytes))
+        return "svg";
+    return undefined;
+}
+const MIME_BY_KIND = {
+    png: "image/png",
+    jpeg: "image/jpeg",
+    svg: "image/svg+xml",
+};
+export function ogImageMime(kind) {
+    return MIME_BY_KIND[kind];
+}
+// ---------------------------------------------------------------------------
+// Header dimension readers
+// ---------------------------------------------------------------------------
+function pngDimensions(bytes) {
+    // signature(8) + length(4) + "IHDR"(4) + width(4) + height(4)
+    if (bytes.length < 24)
+        return undefined;
+    if (bytes[12] !== 0x49 || bytes[13] !== 0x48 || bytes[14] !== 0x44 || bytes[15] !== 0x52)
+        return undefined;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return { width: view.getUint32(16), height: view.getUint32(20) };
+}
+const JPEG_SOF = new Set([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf]);
+/**
+ * Walks every JPEG marker segment in the file — including after each SOS,
+ * skipping entropy-coded data — and returns the LARGEST frame dimensions any
+ * SOF declares. Taking the max (rather than the first SOF) means a file that
+ * declares a small frame first and a huge one later cannot slip a big decode
+ * past the limit. A frame with a 0 dimension (height deferred to a DNL
+ * marker) is treated as unreadable.
+ */
+function jpegDimensions(bytes) {
+    let width = 0;
+    let height = 0;
+    let sawFrame = false;
+    let i = 2;
+    const n = bytes.length;
+    while (i < n) {
+        if (bytes[i] !== 0xff) {
+            i += 1;
+            continue;
+        }
+        // Skip fill bytes.
+        while (i < n && bytes[i] === 0xff)
+            i += 1;
+        if (i >= n)
+            break;
+        const marker = bytes[i];
+        i += 1;
+        // Standalone markers: TEM, RSTn, SOI, EOI.
+        if (marker === 0x00 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd9)) {
+            if (marker === 0xd9)
+                break;
+            continue;
+        }
+        if (i + 1 >= n)
+            break;
+        const length = (bytes[i] << 8) | bytes[i + 1];
+        if (length < 2)
+            return undefined;
+        if (JPEG_SOF.has(marker)) {
+            if (i + 7 > n)
+                return undefined;
+            const h = (bytes[i + 3] << 8) | bytes[i + 4];
+            const w = (bytes[i + 5] << 8) | bytes[i + 6];
+            if (w === 0 || h === 0)
+                return undefined;
+            sawFrame = true;
+            width = Math.max(width, w);
+            height = Math.max(height, h);
+        }
+        i += length;
+        if (marker === 0xda) {
+            // Entropy-coded data follows SOS: advance to the next real marker
+            // (0xFF not followed by 0x00 stuffing or an RSTn).
+            while (i + 1 < n) {
+                if (bytes[i] === 0xff && bytes[i + 1] !== 0x00 && !(bytes[i + 1] >= 0xd0 && bytes[i + 1] <= 0xd7))
+                    break;
+                i += 1;
+            }
+        }
+    }
+    return sawFrame ? { width, height } : undefined;
+}
+// ---------------------------------------------------------------------------
+// SVG safety: no nested raster/remote content can hide inside an SVG
+// ---------------------------------------------------------------------------
+/** Local name of an XML/JSX name: everything after the last `:` (any prefix), lowercased. */
+function localName(name) {
+    return name.slice(name.lastIndexOf(":") + 1).toLowerCase();
+}
+/** Elements that load or embed content (or run script) — never allowed inside an SVG. */
+const SVG_FORBIDDEN_ELEMENTS = new Set(["image", "feimage", "foreignobject", "script", "iframe", "object", "embed"]);
+/**
+ * An SVG passes the byte limit but could still smuggle a pixel bomb (an
+ * embedded `<image href="data:image/png…">` decoded at full size) or point at
+ * external content. resvg-wasm has no network, but nested data images would
+ * bypass every pixel limit above — so they are refused outright. Internal
+ * fragment references (`href="#id"`, `url(#grad)`) stay allowed: logos use them.
+ *
+ * Names are matched by LOCAL name with any namespace prefix (`<a.b:image>`,
+ * `c.d:href`), and the whole text must not contain `data:` at all or a
+ * character reference (`&#…;` could spell `data:` after XML decoding).
+ */
+function svgUnsafeReason(text) {
+    const unsafe = (reason) => ({ code: OG_TREE_ERROR_CODES.svgUnsafe, reason });
+    const filter = { code: OG_TREE_ERROR_CODES.svgFilterForbidden, reason: "SVG filters and styles are not allowed" };
+    // Refuse whole classes by plain substring search (comments and escapes
+    // included): resvg runs CSS filter functions from <style>/style= without any
+    // <filter> element, so any filter/blur/shadow text and any style is out.
+    if (hasEffectWord(text) || hasStyleWord(text))
+        return filter;
+    if (/<!(?:DOCTYPE|ENTITY|\[CDATA\[)/i.test(text))
+        return unsafe("DOCTYPE/ENTITY/CDATA sections are not allowed");
+    if (/&#/.test(text))
+        return unsafe("character references are not allowed");
+    if (/data\s*:/i.test(text))
+        return unsafe("nested data: URIs are not allowed");
+    if (/@import/i.test(text))
+        return unsafe("@import is not allowed");
+    for (const match of text.matchAll(/<\s*([^\s/>!?<]+)/g)) {
+        const name = localName(match[1]);
+        // Filter primitives make render cost unbounded (feTurbulence numOctaves,
+        // feMorphology radius, chained blurs) — logos and avatars do not need them.
+        if (isFilterElement(name))
+            return filter;
+        if (SVG_FORBIDDEN_ELEMENTS.has(name))
+            return unsafe("embedded image/foreignObject/script elements are not allowed");
+    }
+    // Linear-time patterns only: an attribute name must follow whitespace (the
+    // lookbehind fails in O(1) inside long runs), and url() arguments stop at
+    // the next quote/paren — a 256 KB SVG must not cost quadratic time here.
+    for (const match of text.matchAll(/(?<=\s)([^\s=<>"'/]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)) {
+        const name = localName(match[1]);
+        if (name === "filter")
+            return filter;
+        const value = match[2] ?? match[3] ?? "";
+        if (name.endsWith("href") && !value.trim().startsWith("#"))
+            return unsafe("href must reference an in-document #fragment");
+    }
+    if (/(?:^|[\s;{"'])filter\s*:/i.test(text))
+        return filter;
+    for (const match of text.matchAll(/url\(\s*["']?([^"'()]*)/gi)) {
+        if (!match[1].trim().startsWith("#"))
+            return unsafe("url() must reference an in-document #fragment");
+    }
+    return undefined;
+}
+/** `filter`, `blur`, `shadow` (also `drop-shadow`) anywhere, case-insensitive. */
+function hasEffectWord(text) {
+    return /filter|blur|shadow/i.test(text);
+}
+/** `style` anywhere except inside the presentation attribute `font-style`. */
+function hasStyleWord(text) {
+    return /style/i.test(text.replace(/font-style/gi, ""));
+}
+function isFilterElement(name) {
+    return name === "filter" || /^fe[a-z]/.test(name);
+}
+function base64ToBytes(payload) {
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(payload))
+        return undefined;
+    let binary;
+    try {
+        binary = atob(payload);
+    }
+    catch {
+        return undefined;
+    }
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+        out[i] = binary.charCodeAt(i);
+    return out;
+}
+/**
+ * Same grammar satori uses to read a data: URI (`dist/standalone.js`, `xr`):
+ * lowercase `data:`, a `[a-z/+]` MIME type, optional `;k=v` params, an optional
+ * `;encoding`, then the payload. The payload must not contain whitespace —
+ * satori's `.*` stops at a newline — so both sides always read the same bytes.
+ */
+const DATA_URI = /^data:([a-z/+]+)((?:;[^;=,]+=[^;=,]+)*)(?:;([^;,=]+))?,([^\s]*)$/;
+function decodeDataUri(uri, budget) {
+    const match = DATA_URI.exec(uri);
+    if (!match)
+        return undefined;
+    const mime = match[1];
+    const encoding = match[3];
+    const payload = match[4];
+    const base64 = encoding === "base64";
+    // Upper bound on decoded size, checked BEFORE decoding so a huge string is never materialized.
+    const bound = base64 ? Math.ceil((payload.length * 3) / 4) : payload.length;
+    if (bound > budget * 2 + 1024)
+        return "too-large";
+    if (base64) {
+        const bytes = base64ToBytes(payload);
+        return bytes ? { mime, bytes } : undefined;
+    }
+    // satori only sizes non-base64 data URIs for SVG; rasters must be base64.
+    if (mime !== "image/svg+xml")
+        return undefined;
+    try {
+        return { mime, bytes: new TextEncoder().encode(decodeURIComponent(payload)) };
+    }
+    catch {
+        return undefined;
+    }
+}
+// ---------------------------------------------------------------------------
+// Tree walk
+// ---------------------------------------------------------------------------
+/** Prop keys whose value is itself an image reference (not a CSS value), besides any `*href`. */
+const IMAGE_REF_KEYS = new Set(["src", "srcset", "poster"]);
+function isImageRefKey(key) {
+    const name = localName(key);
+    return IMAGE_REF_KEYS.has(name) || name.endsWith("href");
+}
+/**
+ * satori serializes an inline `<svg>` subtree as markup WITHOUT escaping
+ * names, attribute values or text (`Na` / `Ui` in its dist), so names must be
+ * plain identifiers and values / text must not be able to break out.
+ */
+const SAFE_NAME = /^[A-Za-z_][A-Za-z0-9_.:-]*$/;
+const SVG_UNSAFE_TEXT = /[<>"&]/;
+const EMPTY_COUNTS = {
+    imageCount: 0,
+    totalPixels: 0,
+    totalBytes: 0,
+    nodes: 0,
+    textChars: 0,
+    propChars: 0,
+    effects: 0,
+    svgNodes: 0,
+    svgChars: 0,
+    canvasPixels: 0,
+};
+function fail(code, message) {
+    throw new OgTreeRenderError(code, message);
+}
+function checkImageRef(ref, state) {
+    if (!ref.startsWith("data:")) {
+        fail(OG_TREE_ERROR_CODES.imageNotDataUri, "image source must be a data: URI");
+    }
+    state.imageCount += 1;
+    if (state.imageCount > OG_TREE_LIMITS.maxImages) {
+        fail(OG_TREE_ERROR_CODES.treeTooManyImages, `tree has more than ${OG_TREE_LIMITS.maxImages} images`);
+    }
+    const decoded = decodeDataUri(ref, OG_TREE_LIMITS.maxImageBytes);
+    if (decoded === "too-large") {
+        fail(OG_TREE_ERROR_CODES.imageTooLarge, `image data: URI exceeds ${OG_TREE_LIMITS.maxImageBytes} bytes`);
+    }
+    if (!decoded || decoded.bytes.length === 0) {
+        fail(OG_TREE_ERROR_CODES.imageUnreadable, "image data: URI could not be decoded");
+    }
+    const { mime, bytes } = decoded;
+    const kind = sniffOgImageKind(bytes);
+    if (!kind)
+        fail(OG_TREE_ERROR_CODES.imageUnsupportedType, "image bytes are not PNG, JPEG or SVG");
+    if (mime !== MIME_BY_KIND[kind]) {
+        fail(OG_TREE_ERROR_CODES.imageUnsupportedType, `declared type does not match the ${kind} bytes`);
+    }
+    if (kind === "svg") {
+        if (bytes.length > OG_TREE_LIMITS.maxSvgBytes) {
+            fail(OG_TREE_ERROR_CODES.svgTooLarge, `SVG is ${bytes.length} bytes (max ${OG_TREE_LIMITS.maxSvgBytes})`);
+        }
+        const unsafe = svgUnsafeReason(new TextDecoder("utf-8", { fatal: false }).decode(bytes));
+        if (unsafe)
+            fail(unsafe.code, unsafe.reason);
+    }
+    else {
+        if (bytes.length > OG_TREE_LIMITS.maxImageBytes) {
+            fail(OG_TREE_ERROR_CODES.imageTooLarge, `${kind} is ${bytes.length} bytes (max ${OG_TREE_LIMITS.maxImageBytes})`);
+        }
+        const dims = kind === "png" ? pngDimensions(bytes) : jpegDimensions(bytes);
+        if (!dims || dims.width === 0 || dims.height === 0) {
+            fail(OG_TREE_ERROR_CODES.imageUnreadable, `${kind} header has no readable dimensions`);
+        }
+        const pixels = dims.width * dims.height;
+        if (pixels > OG_TREE_LIMITS.maxImagePixels) {
+            fail(OG_TREE_ERROR_CODES.imageTooManyPixels, `${kind} is ${dims.width}x${dims.height} (${pixels} px, max ${OG_TREE_LIMITS.maxImagePixels})`);
+        }
+        state.totalPixels += pixels;
+        if (state.totalPixels > OG_TREE_LIMITS.maxTotalPixels) {
+            fail(OG_TREE_ERROR_CODES.treeTooManyPixels, `tree images exceed ${OG_TREE_LIMITS.maxTotalPixels} px in total`);
+        }
+    }
+    state.totalBytes += bytes.length;
+    if (state.totalBytes > OG_TREE_LIMITS.maxTotalBytes) {
+        fail(OG_TREE_ERROR_CODES.treeTooManyBytes, `tree images exceed ${OG_TREE_LIMITS.maxTotalBytes} bytes in total`);
+    }
+}
+const URL_TOKEN = /url\s*\(/i;
+const URL_REF = /url\s*\(\s*(?:"([^"]*)"|'([^']*)'|([^"'()\s]*))\s*\)/gi;
+/**
+ * Finds every `url(...)` in a CSS-ish string and validates each target. After
+ * removing every reference this parser understood, neither `url(` nor `data:`
+ * may remain — so an argument it cannot delimit (e.g. an unquoted value with a
+ * stray `)`) or a data URI hiding in some other attribute is refused instead
+ * of being read differently by satori or resvg. The remainder (everything but
+ * validated image references) counts toward the prop-string budgets.
+ */
+function checkStringValue(value, state, inSvg) {
+    if (inSvg && SVG_UNSAFE_TEXT.test(value)) {
+        fail(OG_TREE_ERROR_CODES.treeInvalid, "inline <svg> values must not contain < > \" &");
+    }
+    if (inSvg && (hasEffectWord(value) || hasStyleWord(value))) {
+        fail(OG_TREE_ERROR_CODES.svgFilterForbidden, "SVG filters and styles are not allowed");
+    }
+    if (URL_TOKEN.test(value)) {
+        for (const match of value.matchAll(URL_REF)) {
+            const target = match[1] ?? match[2] ?? match[3] ?? "";
+            if (inSvg && target.startsWith("#"))
+                continue; // in-document paint server
+            checkImageRef(target, state);
+        }
+    }
+    const rest = value.replace(URL_REF, "");
+    if (URL_TOKEN.test(rest)) {
+        fail(OG_TREE_ERROR_CODES.imageNotDataUri, "could not parse a url() reference; quote data: URIs");
+    }
+    if (/data\s*:/i.test(rest)) {
+        fail(OG_TREE_ERROR_CODES.imageNotDataUri, "a data: URI is only accepted as an image src/href or inside url()");
+    }
+    if (inSvg) {
+        state.svgChars += rest.length;
+        if (state.svgChars > OG_TREE_LIMITS.maxSvgChars)
+            fail(OG_TREE_ERROR_CODES.textTooLong, "inline <svg> content is too large");
+    }
+    const cap = inSvg ? OG_TREE_LIMITS.maxSvgPropStringChars : OG_TREE_LIMITS.maxPropStringChars;
+    if (rest.length > cap)
+        fail(OG_TREE_ERROR_CODES.textTooLong, `a property value is longer than ${cap} characters`);
+    state.propChars += rest.length;
+    if (state.propChars > OG_TREE_LIMITS.maxPropChars) {
+        fail(OG_TREE_ERROR_CODES.textTooLong, `property values exceed ${OG_TREE_LIMITS.maxPropChars} characters in total`);
+    }
+}
+/** Splits a CSS list on top-level commas (not inside parentheses). */
+function splitCssList(value) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < value.length; i++) {
+        const ch = value[i];
+        if (ch === "(")
+            depth += 1;
+        else if (ch === ")")
+            depth = Math.max(0, depth - 1);
+        else if (ch === "," && depth === 0) {
+            parts.push(value.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(value.slice(start));
+    return parts.map((p) => p.trim()).filter(Boolean);
+}
+/** Every length in `text` outside parentheses (color functions), as px; non-px units are refused. */
+function cssLengthsPx(text, code) {
+    const outside = text.replace(/\([^()]*\)/g, " ").replace(/#[0-9a-f]+/gi, " ");
+    const lengths = [];
+    for (const match of outside.matchAll(/(-?\d*\.?\d+(?:e[+-]?\d+)?)([a-z%]*)/gi)) {
+        const unit = match[2].toLowerCase();
+        const n = Number(match[1]);
+        if (unit !== "" && unit !== "px")
+            fail(code, "only px lengths are allowed here");
+        lengths.push(Math.abs(n));
+    }
+    return lengths;
+}
+/**
+ * box-shadow / text-shadow become SVG blur filters whose cost grows with the
+ * blur and spread radius and the number of entries (200 × `0 0 2000px 2000px`
+ * took 80 s) — bound both.
+ */
+/** Length gate BEFORE any CSS parsing, so the parsers below only ever see short strings. */
+function checkCssLength(value) {
+    if (value.length > OG_TREE_LIMITS.maxPropStringChars) {
+        fail(OG_TREE_ERROR_CODES.textTooLong, `a property value is longer than ${OG_TREE_LIMITS.maxPropStringChars} characters`);
+    }
+}
+function refuseCssFunctions(value, code) {
+    if (/calc\s*\(|var\s*\(|env\s*\(|min\s*\(|max\s*\(|clamp\s*\(/i.test(value)) {
+        fail(code, "calc()/var()/min()/max()/clamp() are not allowed here");
+    }
+}
+/**
+ * Validates a box-shadow / text-shadow value and returns its entry count.
+ * Offsets ≤ 100px, blur ≤ 16px, spread ≤ 16px — blur radius drives render
+ * cost (one 100px blur measured 5.4 s; an 8px–24px card shadow is ~0.3 s).
+ */
+function checkShadow(value) {
+    const code = OG_TREE_ERROR_CODES.shadowLimit;
+    if (typeof value !== "string")
+        fail(code, "shadows must be CSS strings");
+    checkCssLength(value);
+    refuseCssFunctions(value, code);
+    if (/^\s*none\s*$/i.test(value))
+        return 0;
+    const entries = splitCssList(value);
+    if (entries.length > OG_TREE_LIMITS.maxShadows)
+        fail(code, `at most ${OG_TREE_LIMITS.maxShadows} shadows per value`);
+    for (const entry of entries) {
+        const [x = 0, y = 0, blur = 0, spread = 0, ...extra] = cssLengthsPx(entry, code);
+        if (extra.length)
+            fail(code, "a shadow has at most four lengths");
+        if (x > OG_TREE_LIMITS.maxShadowLengthPx || y > OG_TREE_LIMITS.maxShadowLengthPx) {
+            fail(code, `shadow offsets must be at most ${OG_TREE_LIMITS.maxShadowLengthPx}px`);
+        }
+        if (blur > OG_TREE_LIMITS.maxBlurPx)
+            fail(code, `shadow blur must be at most ${OG_TREE_LIMITS.maxBlurPx}px`);
+        if (spread > OG_TREE_LIMITS.maxSpreadPx)
+            fail(code, `shadow spread must be at most ${OG_TREE_LIMITS.maxSpreadPx}px`);
+    }
+    return entries.length;
+}
+/** CSS `filter`: few functions, `blur()` ≤ 16px, no `drop-shadow()`. Returns its effect units. */
+function checkCssFilter(value) {
+    const code = OG_TREE_ERROR_CODES.cssFilterLimit;
+    if (typeof value !== "string")
+        fail(code, "filter must be a CSS string");
+    checkCssLength(value);
+    refuseCssFunctions(value, code);
+    if (/^\s*none\s*$/i.test(value))
+        return 0;
+    // `\b` anchors the name to the start of a word: inside a long run of letters
+    // every other start position fails in O(1), keeping this linear.
+    const functions = [...value.matchAll(/\b([a-z-]+)\s*\(([^()]*(?:\([^()]*\)[^()]*)*)\)/gi)];
+    if (functions.length > OG_TREE_LIMITS.maxFilterFunctions) {
+        fail(code, `at most ${OG_TREE_LIMITS.maxFilterFunctions} filter functions`);
+    }
+    for (const [, name, args] of functions) {
+        const fn = name.toLowerCase();
+        if (fn === "url")
+            fail(code, "filter url() references are not allowed");
+        if (fn === "blur") {
+            for (const length of cssLengthsPx(args, code)) {
+                if (length > OG_TREE_LIMITS.maxBlurPx)
+                    fail(code, `blur radius must be at most ${OG_TREE_LIMITS.maxBlurPx}px`);
+            }
+        }
+        if (fn === "drop-shadow")
+            fail(code, "drop-shadow() is not allowed; use boxShadow");
+    }
+    return functions.reduce((units, [, name]) => units + (name.toLowerCase() === "blur" ? OG_TREE_LIMITS.effectCostBlur : 1), 0);
+}
+function hasContent(children) {
+    if (children === null || children === undefined || typeof children === "boolean")
+        return false;
+    if (typeof children === "string")
+        return children.length > 0;
+    if (Array.isArray(children))
+        return children.some(hasContent);
+    return true;
+}
+/** px number from a style length (number or "Npx"); undefined for anything else (%, auto, missing). */
+function pxValue(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return Math.abs(value);
+    if (typeof value === "string") {
+        const m = /^\s*(\d+(?:\.\d+)?)(?:px)?\s*$/i.exec(value);
+        if (m)
+            return Number(m[1]);
+    }
+    return undefined;
+}
+/** Area units of an element for the effect budget (whole canvas when its size is not numeric). */
+function areaUnits(style, state) {
+    const w = pxValue(style.width);
+    const h = pxValue(style.height);
+    const area = w !== undefined && h !== undefined ? Math.min(w * h, state.canvasPixels) : state.canvasPixels;
+    return Math.max(1, Math.ceil(area / OG_TREE_LIMITS.effectAreaUnitPx));
+}
+function addEffects(state, count) {
+    state.effects += count;
+    if (state.effects > OG_TREE_LIMITS.maxEffects) {
+        fail(OG_TREE_ERROR_CODES.shadowLimit, `shadow/filter effects exceed ${OG_TREE_LIMITS.maxEffects} units per tree`);
+    }
+}
+function checkPropValue(key, value, state, depth, inSvg) {
+    if (depth > OG_TREE_LIMITS.maxDepth)
+        fail(OG_TREE_ERROR_CODES.treeInvalid, "props nested too deeply");
+    const name = localName(key);
+    if (inSvg && name === "filter")
+        fail(OG_TREE_ERROR_CODES.svgFilterForbidden, "SVG filters are not allowed");
+    // Validation only; the budget is charged per element in walkNode.
+    if (name.includes("shadow"))
+        checkShadow(value);
+    else if (name.endsWith("filter"))
+        checkCssFilter(value);
+    if (typeof value === "string") {
+        checkStringValue(value, state, inSvg);
+        return;
+    }
+    if (typeof value === "function")
+        fail(OG_TREE_ERROR_CODES.treeInvalid, "functions are not allowed in a tree");
+    if (Array.isArray(value)) {
+        for (const item of value)
+            checkPropValue(key, item, state, depth + 1, inSvg);
+        return;
+    }
+    if (value && typeof value === "object") {
+        for (const [childKey, item] of Object.entries(value)) {
+            if (!SAFE_NAME.test(childKey))
+                fail(OG_TREE_ERROR_CODES.treeInvalid, "invalid property name");
+            checkPropValue(childKey, item, state, depth + 1, inSvg);
+        }
+    }
+}
+function checkText(text, state) {
+    if (text.length > OG_TREE_LIMITS.maxStringChars) {
+        fail(OG_TREE_ERROR_CODES.textTooLong, `a text string is longer than ${OG_TREE_LIMITS.maxStringChars} characters`);
+    }
+    state.textChars += text.length;
+    if (state.textChars > OG_TREE_LIMITS.maxTextChars) {
+        fail(OG_TREE_ERROR_CODES.textTooLong, `tree text exceeds ${OG_TREE_LIMITS.maxTextChars} characters in total`);
+    }
+}
+function walkNode(node, state, depth, inSvg, textShadow = 0) {
+    if (node === null || node === undefined || typeof node === "boolean")
+        return;
+    if (typeof node === "number") {
+        checkText(String(node), state);
+        if (!inSvg)
+            addEffects(state, textShadow);
+        return;
+    }
+    if (typeof node === "string") {
+        // Text is laid out by satori (turned into paths) — except inside an
+        // inline <svg>, where it is pasted into markup verbatim.
+        if (inSvg && SVG_UNSAFE_TEXT.test(node))
+            fail(OG_TREE_ERROR_CODES.treeInvalid, "inline <svg> text must not contain < > \" &");
+        if (inSvg && (hasEffectWord(node) || hasStyleWord(node))) {
+            fail(OG_TREE_ERROR_CODES.svgFilterForbidden, "SVG filters and styles are not allowed");
+        }
+        checkText(node, state);
+        if (!inSvg && node.trim()) {
+            addEffects(state, textShadow * Math.ceil(node.length / OG_TREE_LIMITS.textShadowCharsPerUnit));
+        }
+        if (inSvg) {
+            state.svgChars += node.length;
+            if (state.svgChars > OG_TREE_LIMITS.maxSvgChars)
+                fail(OG_TREE_ERROR_CODES.textTooLong, "inline <svg> content is too large");
+        }
+        return;
+    }
+    if (depth > OG_TREE_LIMITS.maxDepth)
+        fail(OG_TREE_ERROR_CODES.treeInvalid, `tree deeper than ${OG_TREE_LIMITS.maxDepth}`);
+    if (Array.isArray(node)) {
+        for (const child of node)
+            walkNode(child, state, depth + 1, inSvg, textShadow);
+        return;
+    }
+    if (typeof node !== "object")
+        fail(OG_TREE_ERROR_CODES.treeInvalid, "unsupported node value");
+    const { type, props } = node;
+    // A function `type` is a component satori would CALL — its output could not
+    // be validated here. Only plain element names are accepted.
+    if (typeof type !== "string" || !SAFE_NAME.test(type)) {
+        fail(OG_TREE_ERROR_CODES.treeInvalid, "every node needs a plain string `type`");
+    }
+    const svgScope = inSvg || type === "svg";
+    if (svgScope && isFilterElement(localName(type))) {
+        fail(OG_TREE_ERROR_CODES.svgFilterForbidden, "SVG filters are not allowed");
+    }
+    if (svgScope && localName(type) === "style") {
+        fail(OG_TREE_ERROR_CODES.svgFilterForbidden, "<style> is not allowed inside an inline <svg>");
+    }
+    if (svgScope && SVG_FORBIDDEN_ELEMENTS.has(localName(type))) {
+        fail(OG_TREE_ERROR_CODES.treeInvalid, "image/foreignObject/script nodes are not allowed inside an inline <svg>; use an <img> node");
+    }
+    state.nodes += 1;
+    if (svgScope) {
+        state.svgNodes += 1;
+        if (state.svgNodes > OG_TREE_LIMITS.maxSvgNodes) {
+            fail(OG_TREE_ERROR_CODES.treeInvalid, `inline <svg> content has more than ${OG_TREE_LIMITS.maxSvgNodes} nodes`);
+        }
+    }
+    if (state.nodes > OG_TREE_LIMITS.maxNodes)
+        fail(OG_TREE_ERROR_CODES.treeInvalid, `tree has more than ${OG_TREE_LIMITS.maxNodes} nodes`);
+    if (props === undefined || props === null)
+        return;
+    if (typeof props !== "object" || Array.isArray(props))
+        fail(OG_TREE_ERROR_CODES.treeInvalid, "`props` must be an object");
+    const record = props;
+    for (const [key, value] of Object.entries(record)) {
+        if (key === "children")
+            continue;
+        if (!SAFE_NAME.test(key))
+            fail(OG_TREE_ERROR_CODES.treeInvalid, "invalid property name");
+        // satori expands `tw` (Tailwind) classes into styles this walk would not see.
+        if (key === "tw")
+            fail(OG_TREE_ERROR_CODES.treeInvalid, "the `tw` prop is not supported; use `style`");
+        // Below the <svg> root, `style` would be serialized into markup resvg styles.
+        if (inSvg && localName(key) === "style")
+            fail(OG_TREE_ERROR_CODES.svgFilterForbidden, "styles are not allowed inside an inline <svg>");
+        if (svgScope && (hasEffectWord(key) || hasStyleWord(key)) && !(key === "style" && !inSvg)) {
+            fail(OG_TREE_ERROR_CODES.svgFilterForbidden, "SVG filters and styles are not allowed");
+        }
+        if (isImageRefKey(key)) {
+            if (value === undefined || value === null)
+                continue;
+            if (typeof value !== "string")
+                fail(OG_TREE_ERROR_CODES.imageNotDataUri, "image references must be data: URI strings");
+            if (svgScope) {
+                // Inside an inline <svg> only in-document references are allowed.
+                if (!value.startsWith("#") || SVG_UNSAFE_TEXT.test(value)) {
+                    fail(OG_TREE_ERROR_CODES.imageNotDataUri, "hrefs inside an inline <svg> must be #fragments");
+                }
+                continue;
+            }
+            checkImageRef(value, state);
+            continue;
+        }
+        checkPropValue(key, value, state, depth + 1, svgScope);
+    }
+    if (type === "img" && typeof record.src !== "string") {
+        fail(OG_TREE_ERROR_CODES.imageNotDataUri, "<img> needs a data: URI `src`");
+    }
+    const style = record.style && typeof record.style === "object" ? record.style : undefined;
+    let ownTextShadow;
+    if (style) {
+        for (const [key, value] of Object.entries(style)) {
+            const name = localName(key);
+            if (name === "textshadow")
+                ownTextShadow = checkShadow(value);
+            else if (name.includes("shadow"))
+                addEffects(state, checkShadow(value) * areaUnits(style, state));
+            else if (name.endsWith("filter")) {
+                const units = checkCssFilter(value);
+                // A filter rasterizes its whole subtree into a layer as large as the
+                // subtree's bounds (children can overflow a small box) — allow it only
+                // on leaves (an <img> or an empty box), whose area is their own size.
+                if (units > 0 && hasContent(record.children)) {
+                    fail(OG_TREE_ERROR_CODES.cssFilterLimit, "filter is only allowed on elements without children");
+                }
+                addEffects(state, units * areaUnits(style, state));
+            }
+        }
+    }
+    walkNode(record.children, state, depth + 1, svgScope, ownTextShadow ?? textShadow);
+}
+/**
+ * Snapshot of the caller's tree as plain data: getters are read once,
+ * non-enumerable / inherited props and prototypes are dropped. The renderer
+ * validates and renders THIS copy, so satori can never see a value the
+ * validator did not.
+ */
+function snapshotTree(tree) {
+    try {
+        return structuredClone(tree);
+    }
+    catch (error) {
+        return fail(OG_TREE_ERROR_CODES.treeInvalid, `tree must be plain data (${error instanceof Error ? error.name : "clone failed"})`);
+    }
+}
+function checkCanvas(options) {
+    const { width, height } = options;
+    if (!Number.isInteger(width) ||
+        !Number.isInteger(height) ||
+        width < 1 ||
+        height < 1 ||
+        width > OG_TREE_LIMITS.maxCanvasDimension ||
+        height > OG_TREE_LIMITS.maxCanvasDimension ||
+        width * height > OG_TREE_LIMITS.maxCanvasPixels) {
+        fail(OG_TREE_ERROR_CODES.canvasInvalid, `canvas must be integer sizes up to ${OG_TREE_LIMITS.maxCanvasDimension}px a side and ${OG_TREE_LIMITS.maxCanvasPixels} px`);
+    }
+    if (options.weights !== undefined && !Array.isArray(options.weights)) {
+        fail(OG_TREE_ERROR_CODES.weightsInvalid, "weights must be an array");
+    }
+    for (const weight of options.weights ?? []) {
+        if (weight !== 400 && weight !== 700)
+            fail(OG_TREE_ERROR_CODES.weightsInvalid, "weights may only be 400 or 700");
+    }
+}
+function checkTree(tree, canvasPixels) {
+    if (!tree || typeof tree !== "object" || Array.isArray(tree))
+        fail(OG_TREE_ERROR_CODES.treeInvalid, "tree must be a node object");
+    const state = { ...EMPTY_COUNTS, canvasPixels };
+    walkNode(tree, state, 0, false);
+    return { imageCount: state.imageCount, totalPixels: state.totalPixels, totalBytes: state.totalBytes };
+}
+/**
+ * Validates a tree render request without rendering. Throws an
+ * {@link OgTreeRenderError} naming the first violated rule; never performs I/O.
+ */
+export function validateOgTree(options) {
+    checkCanvas(options);
+    return checkTree(snapshotTree(options.tree), options.width * options.height);
+}
+/** Validation for the renderers: returns the snapshot that was validated — render exactly this. */
+export function prepareOgTree(options) {
+    checkCanvas(options);
+    const tree = snapshotTree(options.tree);
+    checkTree(tree, options.width * options.height);
+    return tree;
+}
+/**
+ * Checks ONE image data: URI against the per-image rules (type, bytes, pixels,
+ * SVG safety) without rendering, so a caller can drop an image before building
+ * a tree. `width`/`height` are null for SVG. Tree-wide totals are not applied.
+ */
+export function inspectOgImage(dataUri) {
+    const state = { ...EMPTY_COUNTS };
+    try {
+        checkImageRef(dataUri, state);
+    }
+    catch (error) {
+        if (error instanceof OgTreeRenderError)
+            return { code: error.code };
+        throw error;
+    }
+    const decoded = decodeDataUri(dataUri, OG_TREE_LIMITS.maxImageBytes);
+    const bytes = decoded && decoded !== "too-large" ? decoded.bytes : new Uint8Array();
+    const kind = sniffOgImageKind(bytes);
+    const dims = kind === "png" ? pngDimensions(bytes) : kind === "jpeg" ? jpegDimensions(bytes) : undefined;
+    return { kind, width: dims?.width ?? null, height: dims?.height ?? null, bytes: bytes.length };
+}
+export function wantsBold(weights) {
+    return (weights ?? []).includes(700);
+}
+/**
+ * A FIFO mutex: a task starts only after every previously queued task has
+ * settled (fulfilled or rejected). One queue per isolate/process keeps
+ * satori's per-render font parse and resvg's wasm heap from stacking.
+ *
+ * `maxWaitMs`: a task still waiting when the deadline passes is rejected with
+ * an {@link OgRenderUnavailableError} (`OG_QUEUE_TIMEOUT`) and never runs, so a
+ * wedged predecessor cannot pile up callers forever.
+ */
+export function createSerialQueue() {
+    let tail = Promise.resolve();
+    return (task, options = {}) => new Promise((resolve, reject) => {
+        const enqueuedAt = performance.now();
+        let expired = false;
+        const timer = options.maxWaitMs === undefined
+            ? undefined
+            : setTimeout(() => {
+                expired = true;
+                reject(new OgRenderUnavailableError(OG_RENDER_UNAVAILABLE_CODES.queueTimeout, "render queue wait exceeded"));
+            }, options.maxWaitMs);
+        tail = tail.then(async () => {
+            if (expired)
+                return;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            try {
+                resolve(await task({ queueMs: performance.now() - enqueuedAt }));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+}
+//# sourceMappingURL=tree.js.map