npm - @agent-scope/render - Versions diffs - 1.0.1 - Mend

@agent-scope/render 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1523 @@
+import { chromium } from 'playwright';
+import { existsSync, readdirSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import React from 'react';
+import { Resvg } from '@resvg/resvg-js';
+import satori from 'satori';
+import sharp from 'sharp';
+// src/browser-pool.ts
+var CHROMIUM_ARGS = [
+  "--headless=new",
+  "--disable-gpu",
+  "--disable-dev-shm-usage",
+  "--no-sandbox",
+  "--no-zygote",
+  "--disable-extensions",
+  "--disable-background-networking",
+  "--disable-sync",
+  "--hide-scrollbars",
+  "--mute-audio",
+  "--font-render-hinting=none"
+];
+var PRESET_SIZES = {
+  local: { browsers: 1, pagesPerBrowser: 5 },
+  "ci-standard": { browsers: 3, pagesPerBrowser: 15 },
+  "ci-large": { browsers: 6, pagesPerBrowser: 20 }
+};
+function buildSkeletonHtml(viewportWidth, _viewportHeight) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=${viewportWidth}, initial-scale=1.0" />
+  <style>
+    *, *::before, *::after { box-sizing: border-box; }
+    body { margin: 0; padding: 0; font-family: system-ui, sans-serif; }
+    #scope-root { display: inline-block; }
+  </style>
+</head>
+<body>
+  <div id="scope-root" data-reactscope-root></div>
+  <script>
+    // Component registry \u2014 populated lazily by inject calls
+    window.__componentRegistry = {};
+    // Render state
+    window.__renderReady = false;
+    window.__renderError = null;
+    /**
+     * Swap in a component by name.
+     * @param {string} name - component name key in __componentRegistry
+     * @param {object} props - serialised props object
+     */
+    window.__renderComponent = function(name, props) {
+      window.__renderReady = false;
+      window.__renderError = null;
+      var root = document.getElementById("scope-root");
+      if (!root) {
+        window.__renderError = "scope-root element not found";
+        window.__renderReady = true;
+        return;
+      }
+      var factory = window.__componentRegistry[name];
+      if (!factory) {
+        // Fallback: render a placeholder div so screenshots still work
+        root.innerHTML = "<div data-placeholder=\\"" + name + "\\" style=\\"padding:8px;border:1px dashed #ccc\\">" + name + "</div>";
+        window.__renderReady = true;
+        return;
+      }
+      try {
+        factory(root, props || {});
+      } catch (err) {
+        window.__renderError = err instanceof Error ? err.message : String(err);
+        root.innerHTML = "<div data-render-error style=\\"color:red\\">" + window.__renderError + "</div>";
+        window.__renderReady = true;
+      }
+    };
+    /**
+     * Register a component factory.
+     * @param {string} name
+     * @param {function(HTMLElement, object): void} factory
+     */
+    window.__registerComponent = function(name, factory) {
+      window.__componentRegistry[name] = factory;
+    };
+    // Signal that the skeleton is ready (not a component render yet)
+    window.__skeletonReady = true;
+  </script>
+</body>
+</html>`;
+}
+async function extractDomTree(page, selector) {
+  const result = await page.evaluate((sel) => {
+    let count = 0;
+    function walk(node) {
+      if (node.nodeType === Node.TEXT_NODE) {
+        const text = node.textContent?.trim();
+        return { tag: "#text", attrs: {}, text: text ?? "", children: [] };
+      }
+      const el = node;
+      count++;
+      const attrs = {};
+      for (const attr of Array.from(el.attributes)) {
+        attrs[attr.name] = attr.value;
+      }
+      const children = Array.from(el.childNodes).filter(
+        (n) => n.nodeType === Node.ELEMENT_NODE || n.nodeType === Node.TEXT_NODE && (n.textContent?.trim() ?? "").length > 0
+      ).map(walk);
+      return { tag: el.tagName.toLowerCase(), attrs, children };
+    }
+    const root = document.querySelector(sel);
+    if (!root) {
+      return { tree: { tag: "div", attrs: {}, children: [] }, elementCount: 0 };
+    }
+    const tree = walk(root);
+    return { tree, elementCount: count };
+  }, selector);
+  return result;
+}
+var BrowserPool = class {
+  config;
+  sizeConfig;
+  browsers = [];
+  slots = [];
+  waiters = [];
+  closed = false;
+  initialized = false;
+  constructor(config = {}) {
+    const viewportWidth = config.viewportWidth ?? 1440;
+    const viewportHeight = config.viewportHeight ?? 900;
+    const acquireTimeoutMs = config.acquireTimeoutMs ?? 3e4;
+    const preset = config.preset ?? "local";
+    this.config = {
+      preset,
+      size: config.size ?? { browsers: 1, pagesPerBrowser: 5 },
+      viewportWidth,
+      viewportHeight,
+      acquireTimeoutMs
+    };
+    if (config.size) {
+      this.sizeConfig = config.size;
+    } else {
+      this.sizeConfig = PRESET_SIZES[preset] ?? PRESET_SIZES.local ?? { browsers: 1, pagesPerBrowser: 5 };
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Initialisation
+  // -------------------------------------------------------------------------
+  /**
+   * Launch all browser instances and pre-load every page with the skeleton HTML.
+   * Must be called before `render()`.
+   */
+  async init() {
+    if (this.initialized) return;
+    this.initialized = true;
+    const { browsers: browserCount, pagesPerBrowser } = this.sizeConfig;
+    const skeleton = buildSkeletonHtml(this.config.viewportWidth, this.config.viewportHeight);
+    for (let b = 0; b < browserCount; b++) {
+      const browser = await chromium.launch({ args: CHROMIUM_ARGS });
+      this.browsers.push(browser);
+      for (let p = 0; p < pagesPerBrowser; p++) {
+        const page = await browser.newPage({
+          viewport: { width: this.config.viewportWidth, height: this.config.viewportHeight }
+        });
+        await page.setContent(skeleton, { waitUntil: "load" });
+        const index = this.slots.length;
+        this.slots.push({ page, inUse: false, index });
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Slot management
+  // -------------------------------------------------------------------------
+  /**
+   * Acquire a free page slot.  Blocks until one is available or
+   * `acquireTimeoutMs` is exceeded.
+   */
+  async acquire() {
+    if (this.closed) throw new Error("BrowserPool is closed");
+    const free = this.slots.find((s) => !s.inUse);
+    if (free) {
+      free.inUse = true;
+      return free;
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const idx = this.waiters.indexOf(wakeUp);
+        if (idx !== -1) this.waiters.splice(idx, 1);
+        reject(
+          new Error(`BrowserPool.acquire() timed out after ${this.config.acquireTimeoutMs}ms`)
+        );
+      }, this.config.acquireTimeoutMs);
+      const wakeUp = (slot) => {
+        clearTimeout(timer);
+        resolve(slot);
+      };
+      this.waiters.push(wakeUp);
+    });
+  }
+  /**
+   * Return a page slot to the pool.  Wakes the next queued waiter, if any.
+   */
+  release(slot) {
+    if (!slot.inUse) return;
+    slot.inUse = false;
+    const next = this.waiters.shift();
+    if (next) {
+      slot.inUse = true;
+      next(slot);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Render
+  // -------------------------------------------------------------------------
+  /**
+   * Render a component by name with the given props and return a `RenderResult`.
+   *
+   * The inject-don't-navigate pattern is used:
+   *  1. Acquire a warm page slot.
+   *  2. Call `window.__renderComponent(name, props)` — no navigation.
+   *  3. Wait for `window.__renderReady`.
+   *  4. Clip screenshot to the component bounding box.
+   *  5. Optionally capture DOM, styles, console output, and a11y info.
+   *  6. Release the slot.
+   */
+  async render(componentName, props = {}, options = {}) {
+    if (!this.initialized) {
+      throw new Error("BrowserPool.init() must be called before render()");
+    }
+    if (this.closed) {
+      throw new Error("BrowserPool is closed");
+    }
+    const captureStyles = options.captureStyles ?? true;
+    const captureConsole = options.captureConsole ?? false;
+    const captureDom = options.captureDom ?? false;
+    const captureA11y = options.captureA11y ?? false;
+    const timeoutMs = options.timeoutMs ?? 1e4;
+    const consoleErrors = [];
+    const consoleWarnings = [];
+    const consoleLogs = [];
+    const slot = await this.acquire();
+    const { page } = slot;
+    const consoleHandler = captureConsole ? (msg) => {
+      const text = msg.text();
+      if (msg.type() === "error") consoleErrors.push(text);
+      else if (msg.type() === "warning") consoleWarnings.push(text);
+      else consoleLogs.push(text);
+    } : null;
+    if (consoleHandler) page.on("console", consoleHandler);
+    const startTime = Date.now();
+    try {
+      await page.evaluate(
+        ({ name, componentProps }) => {
+          window.__renderComponent?.(name, componentProps);
+        },
+        { name: componentName, componentProps: props }
+      );
+      await page.waitForFunction(
+        () => {
+          return window.__renderReady === true;
+        },
+        { timeout: timeoutMs }
+      );
+      const renderError = await page.evaluate(() => {
+        return window.__renderError ?? null;
+      });
+      if (renderError) {
+        throw new Error(`Component render error: ${renderError}`);
+      }
+      const renderTimeMs = Date.now() - startTime;
+      const rootLocator = page.locator("[data-reactscope-root]");
+      const boundingBox = await rootLocator.boundingBox();
+      if (!boundingBox || boundingBox.width === 0 || boundingBox.height === 0) {
+        throw new Error(`Component "${componentName}" rendered with zero bounding box`);
+      }
+      const screenshot = await page.screenshot({
+        clip: {
+          x: boundingBox.x,
+          y: boundingBox.y,
+          width: boundingBox.width,
+          height: boundingBox.height
+        },
+        type: "png"
+      });
+      const computedStyles = {};
+      if (captureStyles) {
+        const styles = await page.evaluate((sel) => {
+          const el = document.querySelector(sel);
+          if (!el) return {};
+          const computed = window.getComputedStyle(el);
+          const snapshot = {};
+          const PROPS = [
+            "display",
+            "flexDirection",
+            "flexWrap",
+            "alignItems",
+            "justifyContent",
+            "gridTemplateColumns",
+            "gridTemplateRows",
+            "position",
+            "width",
+            "height",
+            "margin",
+            "padding",
+            "color",
+            "backgroundColor",
+            "fontSize",
+            "fontFamily",
+            "fontWeight",
+            "lineHeight",
+            "borderRadius",
+            "boxShadow",
+            "opacity",
+            "transform",
+            "animation",
+            "transition",
+            "overflow"
+          ];
+          for (const prop of PROPS) {
+            snapshot[prop] = computed.getPropertyValue(prop);
+          }
+          return snapshot;
+        }, "[data-reactscope-root] > *");
+        computedStyles["[data-reactscope-root] > *"] = styles;
+      }
+      let dom;
+      if (captureDom) {
+        const { tree, elementCount } = await extractDomTree(page, "[data-reactscope-root]");
+        dom = {
+          tree,
+          elementCount,
+          boundingBox: {
+            x: boundingBox.x,
+            y: boundingBox.y,
+            width: boundingBox.width,
+            height: boundingBox.height
+          }
+        };
+      }
+      let accessibility;
+      if (captureA11y) {
+        const violations = [];
+        const a11yInfo = await page.evaluate((sel) => {
+          const el = document.querySelector(sel);
+          if (!el) return { role: "generic", name: "" };
+          return {
+            role: el.getAttribute("role") ?? el.tagName.toLowerCase() ?? "generic",
+            name: el.getAttribute("aria-label") ?? el.getAttribute("aria-labelledby") ?? el.textContent?.trim().slice(0, 100) ?? ""
+          };
+        }, "[data-reactscope-root]");
+        const imgViolations = await page.evaluate((sel) => {
+          const container = document.querySelector(sel);
+          if (!container) return [];
+          const imgs = container.querySelectorAll("img");
+          const issues = [];
+          imgs.forEach((img) => {
+            if (!img.alt) issues.push("Image missing accessible name");
+          });
+          return issues;
+        }, "[data-reactscope-root]");
+        violations.push(...imgViolations);
+        accessibility = {
+          role: a11yInfo.role,
+          name: a11yInfo.name,
+          violations
+        };
+      }
+      const consoleOutput = captureConsole ? { errors: [...consoleErrors], warnings: [...consoleWarnings], logs: [...consoleLogs] } : void 0;
+      return {
+        screenshot,
+        width: boundingBox.width,
+        height: boundingBox.height,
+        renderTimeMs,
+        computedStyles,
+        dom,
+        console: consoleOutput,
+        accessibility
+      };
+    } finally {
+      if (consoleHandler) page.off("console", consoleHandler);
+      this.release(slot);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Shutdown
+  // -------------------------------------------------------------------------
+  /**
+   * Gracefully shut down the pool.
+   *
+   * Waits for all in-use slots to be released, then closes every browser.
+   * Subsequent `acquire()` or `render()` calls will throw.
+   */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    const drainPromises = this.slots.filter((s) => s.inUse).map(
+      (s) => new Promise((resolve) => {
+        const poll = setInterval(() => {
+          if (!s.inUse) {
+            clearInterval(poll);
+            resolve();
+          }
+        }, 50);
+      })
+    );
+    await Promise.all(drainPromises);
+    this.waiters = [];
+    await Promise.all(this.browsers.map((b) => b.close()));
+    this.browsers = [];
+    this.slots = [];
+  }
+  // -------------------------------------------------------------------------
+  // Introspection helpers
+  // -------------------------------------------------------------------------
+  /** Total number of page slots in the pool. */
+  get totalSlots() {
+    return this.slots.length;
+  }
+  /** Number of currently available (free) slots. */
+  get freeSlots() {
+    return this.slots.filter((s) => !s.inUse).length;
+  }
+  /** Number of currently in-use slots. */
+  get activeSlots() {
+    return this.slots.filter((s) => s.inUse).length;
+  }
+  /** Number of callers waiting for a free slot. */
+  get queueDepth() {
+    return this.waiters.length;
+  }
+  /** Whether the pool has been initialised. */
+  get isInitialized() {
+    return this.initialized;
+  }
+  /** Whether the pool is closed. */
+  get isClosed() {
+    return this.closed;
+  }
+};
+// src/contexts.ts
+var COMPOSITION_CONTEXTS = {
+  centered: {
+    id: "centered",
+    label: "Centered",
+    description: "Component centered both horizontally and vertically inside the viewport.",
+    containerStyle: {
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      width: "100%",
+      height: "100%"
+    }
+  },
+  "flex-row": {
+    id: "flex-row",
+    label: "Flex Row",
+    description: "Component placed inside a flex row with placeholder siblings on either side.",
+    containerStyle: {
+      display: "flex",
+      flexDirection: "row",
+      alignItems: "flex-start",
+      gap: "8px",
+      width: "100%"
+    }
+  },
+  "flex-col": {
+    id: "flex-col",
+    label: "Flex Col",
+    description: "Component placed inside a flex column with placeholder siblings.",
+    containerStyle: {
+      display: "flex",
+      flexDirection: "column",
+      alignItems: "flex-start",
+      gap: "8px",
+      width: "100%"
+    }
+  },
+  grid: {
+    id: "grid",
+    label: "Grid",
+    description: "Component placed inside a CSS grid cell (3-column auto-fill).",
+    containerStyle: {
+      display: "grid",
+      gridTemplateColumns: "repeat(3, 1fr)",
+      gap: "8px",
+      width: "100%"
+    }
+  },
+  sidebar: {
+    id: "sidebar",
+    label: "Sidebar",
+    description: "Narrow 240 px sidebar layout \u2014 tests constrained-width rendering.",
+    containerStyle: {
+      display: "flex",
+      flexDirection: "column",
+      width: "240px",
+      minHeight: "100%",
+      padding: "8px",
+      overflow: "hidden"
+    }
+  },
+  scroll: {
+    id: "scroll",
+    label: "Scroll",
+    description: "Component inside a vertically scrollable container with fixed height.",
+    containerStyle: {
+      display: "block",
+      overflowY: "auto",
+      height: "300px",
+      width: "100%"
+    }
+  },
+  "full-width": {
+    id: "full-width",
+    label: "Full Width",
+    description: "Component stretched to full viewport width with no padding.",
+    containerStyle: {
+      display: "block",
+      width: "100%"
+    }
+  },
+  constrained: {
+    id: "constrained",
+    label: "Constrained",
+    description: "Component inside a centered max-width container (1024 px).",
+    containerStyle: {
+      display: "block",
+      maxWidth: "1024px",
+      width: "100%",
+      marginLeft: "auto",
+      marginRight: "auto",
+      padding: "0 16px"
+    }
+  },
+  rtl: {
+    id: "rtl",
+    label: "RTL",
+    description: "Right-to-left text direction \u2014 tests bidi layout behaviour.",
+    containerStyle: {
+      direction: "rtl",
+      display: "flex",
+      flexDirection: "row",
+      width: "100%"
+    },
+    containerAttrs: {
+      dir: "rtl",
+      lang: "ar"
+    }
+  },
+  "nested-flex": {
+    id: "nested-flex",
+    label: "Nested Flex",
+    description: "Component inside three levels of nested flex containers.",
+    containerStyle: {
+      display: "flex",
+      flexDirection: "row",
+      width: "100%"
+    }
+  }
+};
+var ALL_CONTEXTS = Object.values(COMPOSITION_CONTEXTS);
+var ALL_CONTEXT_IDS = Object.keys(
+  COMPOSITION_CONTEXTS
+);
+function getContext(id) {
+  const ctx = COMPOSITION_CONTEXTS[id];
+  if (!ctx) throw new Error(`Unknown composition context: "${id}"`);
+  return ctx;
+}
+function getContexts(ids) {
+  return ids.map((id) => getContext(id));
+}
+function contextAxis(ids = ALL_CONTEXT_IDS) {
+  return {
+    name: "context",
+    values: ids.map((id) => getContext(id))
+  };
+}
+// src/errors.ts
+var RenderError = class _RenderError extends Error {
+  componentStack;
+  sourceLocation;
+  propsAtCrash;
+  errorMessage;
+  errorType;
+  heuristicFlags;
+  constructor(fields) {
+    super(fields.errorMessage);
+    this.name = "RenderError";
+    this.componentStack = fields.componentStack;
+    this.sourceLocation = fields.sourceLocation;
+    this.propsAtCrash = fields.propsAtCrash;
+    this.errorMessage = fields.errorMessage;
+    this.errorType = fields.errorType;
+    this.heuristicFlags = fields.heuristicFlags;
+  }
+  /**
+   * Construct a `RenderError` from an arbitrary caught value.
+   *
+   * Extracts `componentStack` from React error boundaries when present,
+   * and runs heuristic analysis on the error message.
+   */
+  static from(caught, context = {}) {
+    const err = caught instanceof Error ? caught : new Error(String(caught));
+    const errorMessage = err.message;
+    const errorType = err.constructor.name !== "Error" ? err.constructor.name : "Error";
+    const componentStack = err.componentStack ?? err.stack ?? "";
+    const sourceLocation = context.sourceLocation ?? {
+      file: "<unknown>",
+      line: 0,
+      column: 0
+    };
+    const propsAtCrash = context.props ?? {};
+    const heuristicFlags = detectHeuristicFlags(errorMessage, componentStack);
+    return new _RenderError({
+      componentStack,
+      sourceLocation,
+      propsAtCrash,
+      errorMessage,
+      errorType,
+      heuristicFlags
+    });
+  }
+  /** Serialise to a plain object (useful for JSON output). */
+  toJSON() {
+    return {
+      name: this.name,
+      componentStack: this.componentStack,
+      sourceLocation: this.sourceLocation,
+      propsAtCrash: this.propsAtCrash,
+      errorMessage: this.errorMessage,
+      errorType: this.errorType,
+      heuristicFlags: this.heuristicFlags
+    };
+  }
+};
+function detectHeuristicFlags(errorMessage, componentStack) {
+  const flags = /* @__PURE__ */ new Set();
+  const msg = errorMessage.toLowerCase();
+  const stack = componentStack.toLowerCase();
+  const combined = msg + " " + stack;
+  if (combined.includes("must be used within") || combined.includes("no provider") || combined.includes("provider") && combined.includes("context") || combined.includes("context") && combined.includes("undefined") || combined.includes("provider") && combined.includes("undefined")) {
+    flags.add("MISSING_PROVIDER");
+  }
+  if (combined.includes("cannot read propert") || combined.includes("undefined is not an object") || combined.includes("undefined") && (combined.includes("prop") || combined.includes("null"))) {
+    flags.add("UNDEFINED_PROP");
+  }
+  if (msg.includes("typeerror") || combined.includes("is not a function") || combined.includes("is not iterable") || combined.includes("cannot set propert")) {
+    flags.add("TYPE_MISMATCH");
+  }
+  if (combined.includes("fetch") || combined.includes("network") || combined.includes("http") || combined.includes("xhr")) {
+    flags.add("NETWORK_REQUIRED");
+  }
+  if (combined.includes("suspend") || combined.includes("promise")) {
+    flags.add("ASYNC_NOT_SUSPENDED");
+  }
+  if (combined.includes("invalid hook call") || combined.includes("hooks can only be called") || combined.includes("rendered more hooks") || combined.includes("rendered fewer hooks")) {
+    flags.add("HOOK_CALL_VIOLATION");
+  }
+  if (combined.includes("element type is invalid") || combined.includes("react.createelement") || combined.includes("expected a string") && combined.includes("class/function")) {
+    flags.add("ELEMENT_TYPE_INVALID");
+  }
+  if (combined.includes("hydrat") || combined.includes("did not match") || combined.includes("server rendered html")) {
+    flags.add("HYDRATION_MISMATCH");
+  }
+  if (combined.includes("circular") || combined.includes("maximum call stack") || combined.includes("stack overflow")) {
+    flags.add("CIRCULAR_DEPENDENCY");
+  }
+  if (flags.size === 0) {
+    flags.add("UNKNOWN_ERROR");
+  }
+  return Array.from(flags);
+}
+async function safeRender(renderFn, context = {}) {
+  const start = performance.now();
+  try {
+    const result = await renderFn();
+    return { crashed: false, result };
+  } catch (err) {
+    const renderTimeMs = performance.now() - start;
+    const renderError = RenderError.from(err, context);
+    return { crashed: true, error: renderError, renderTimeMs };
+  }
+}
+var fontCache = /* @__PURE__ */ new Map();
+var NO_FONT_SENTINEL = "__none__";
+var DEFAULT_FAMILY = "Inter";
+function resolveBundledFontPath() {
+  const fontFile = join("@fontsource", "inter", "files", "inter-latin-400-normal.woff");
+  const roots = [
+    join("node_modules"),
+    join(__dirname, "..", "node_modules"),
+    join(__dirname, "..", "..", "node_modules"),
+    join(__dirname, "..", "..", "..", "node_modules")
+  ];
+  for (const root of roots) {
+    const candidate = join(root, fontFile);
+    if (existsSync(candidate)) return candidate;
+  }
+  const bunCacheRoot = join("node_modules", ".bun");
+  if (existsSync(bunCacheRoot)) {
+    try {
+      const entries = readdirSync(bunCacheRoot);
+      for (const entry of entries) {
+        if (entry.startsWith("@fontsource+inter@")) {
+          const candidate = join(bunCacheRoot, entry, "node_modules", fontFile);
+          if (existsSync(candidate)) return candidate;
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function loadFont(fontPath, fontFamily = DEFAULT_FAMILY) {
+  const resolvedPath = fontPath ?? resolveBundledFontPath() ?? NO_FONT_SENTINEL;
+  const cached = fontCache.get(resolvedPath);
+  if (cached !== void 0) return cached;
+  if (resolvedPath === NO_FONT_SENTINEL) {
+    const empty = [];
+    fontCache.set(NO_FONT_SENTINEL, empty);
+    return empty;
+  }
+  try {
+    const buffer = await readFile(resolvedPath);
+    const arrayBuffer = buffer.buffer.slice(
+      buffer.byteOffset,
+      buffer.byteOffset + buffer.byteLength
+    );
+    const entries = [
+      { name: fontFamily, data: arrayBuffer, weight: 400, style: "normal" },
+      { name: fontFamily, data: arrayBuffer, weight: 700, style: "normal" }
+    ];
+    fontCache.set(resolvedPath, entries);
+    return entries;
+  } catch {
+    const empty = [];
+    fontCache.set(resolvedPath, empty);
+    return empty;
+  }
+}
+function clearFontCache() {
+  fontCache.clear();
+}
+function fontCacheSize() {
+  return fontCache.size;
+}
+// src/matrix.ts
+function cartesianProduct(axes) {
+  if (axes.length === 0) return [[]];
+  const result = [];
+  function recurse(axisIndex, current) {
+    if (axisIndex === axes.length) {
+      result.push([...current]);
+      return;
+    }
+    const axis = axes[axisIndex];
+    if (!axis) return;
+    for (const value of axis) {
+      current.push(value);
+      recurse(axisIndex + 1, current);
+      current.pop();
+    }
+  }
+  recurse(0, []);
+  return result;
+}
+function labelForValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return value;
+  if (typeof value === "number") {
+    if (Number.isNaN(value)) return "NaN";
+    if (!Number.isFinite(value)) return value > 0 ? "+Infinity" : "-Infinity";
+    return String(value);
+  }
+  if (typeof value === "boolean") return String(value);
+  return JSON.stringify(value);
+}
+var RenderMatrix = class {
+  renderer;
+  axes;
+  complexityClass;
+  /** Maximum number of cells to render in parallel. @default 8 */
+  concurrency;
+  constructor(renderer, axes, options = {}) {
+    if (axes.length === 0) {
+      throw new Error("RenderMatrix requires at least one axis");
+    }
+    for (const axis of axes) {
+      if (axis.values.length === 0) {
+        throw new Error(`Axis "${axis.name}" must have at least one value`);
+      }
+    }
+    this.renderer = renderer;
+    this.axes = axes;
+    this.complexityClass = options.complexityClass ?? "simple";
+    this.concurrency = options.concurrency ?? 8;
+  }
+  // ---------------------------------------------------------------------------
+  // Grid dimensions
+  // ---------------------------------------------------------------------------
+  /** Total number of cells (product of all axis cardinalities). */
+  get cellCount() {
+    return this.axes.reduce((acc, axis) => acc * axis.values.length, 1);
+  }
+  /** Axis labels indexed [axisIndex][valueIndex]. */
+  get axisLabels() {
+    return this.axes.map((axis) => axis.values.map((v) => labelForValue(v)));
+  }
+  // ---------------------------------------------------------------------------
+  // Main render
+  // ---------------------------------------------------------------------------
+  /**
+   * Render all cells of the matrix.
+   *
+   * Cells are dispatched with bounded parallelism (up to `concurrency` at once)
+   * and returned in row-major order (first axis iterates slowest).
+   */
+  async render() {
+    const wallStart = performance.now();
+    const axisValueArrays = this.axes.map((a) => a.values);
+    const combinations = cartesianProduct(axisValueArrays);
+    const cells = new Array(combinations.length);
+    await this._renderWithConcurrency(combinations, cells);
+    const wallEnd = performance.now();
+    const stats = this._computeStats(cells, wallEnd - wallStart);
+    const lastAxis = this.axes[this.axes.length - 1];
+    const rows = lastAxis !== void 0 ? lastAxis.values.length : 1;
+    const cols = this.cellCount / rows;
+    return {
+      cells,
+      axes: this.axes,
+      axisLabels: this.axisLabels,
+      stats,
+      rows,
+      cols
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  async _renderWithConcurrency(combinations, cells) {
+    let nextIndex = 0;
+    const worker = async () => {
+      while (nextIndex < combinations.length) {
+        const i = nextIndex++;
+        const combo = combinations[i];
+        if (!combo) continue;
+        const props = {};
+        for (let axisIdx = 0; axisIdx < this.axes.length; axisIdx++) {
+          const axis = this.axes[axisIdx];
+          if (axis) {
+            props[axis.name] = combo[axisIdx];
+          }
+        }
+        const axisIndices = [];
+        for (let axisIdx = 0; axisIdx < this.axes.length; axisIdx++) {
+          const axis = this.axes[axisIdx];
+          const val = combo[axisIdx];
+          axisIndices.push(axis ? axis.values.indexOf(val) : -1);
+        }
+        const result = await this.renderer.renderCell(props, this.complexityClass);
+        cells[i] = { props, result, index: i, axisIndices };
+      }
+    };
+    const workerCount = Math.min(this.concurrency, combinations.length);
+    const workers = [];
+    for (let w = 0; w < workerCount; w++) {
+      workers.push(worker());
+    }
+    await Promise.all(workers);
+  }
+  _computeStats(cells, wallClockTimeMs) {
+    const totalCells = cells.length;
+    if (totalCells === 0) {
+      return {
+        totalCells: 0,
+        totalRenderTimeMs: 0,
+        avgRenderTimeMs: 0,
+        minRenderTimeMs: 0,
+        maxRenderTimeMs: 0,
+        wallClockTimeMs
+      };
+    }
+    let total = 0;
+    let min = Infinity;
+    let max = -Infinity;
+    for (const cell of cells) {
+      const t = cell.result.renderTimeMs;
+      total += t;
+      if (t < min) min = t;
+      if (t > max) max = t;
+    }
+    return {
+      totalCells,
+      totalRenderTimeMs: total,
+      avgRenderTimeMs: total / totalCells,
+      minRenderTimeMs: min === Infinity ? 0 : min,
+      maxRenderTimeMs: max === -Infinity ? 0 : max,
+      wallClockTimeMs
+    };
+  }
+};
+var MOCK_CONTEXT_VALUE = Object.freeze({});
+var KNOWN_PROVIDERS = {
+  ThemeContext: (children, theme = "light") => React.createElement(
+    React.createContext({ theme }).Provider,
+    { value: { theme } },
+    children
+  ),
+  LocaleContext: (children, _theme, locale = "en-US") => React.createElement(
+    React.createContext({ locale }).Provider,
+    { value: { locale } },
+    children
+  )
+};
+function wrapWithProviders(element, requiredContexts, options = {}) {
+  if (requiredContexts.length === 0) return element;
+  return [...requiredContexts].reverse().reduce((child, ctxName) => {
+    const factory = KNOWN_PROVIDERS[ctxName];
+    if (factory) {
+      return factory(child, options.theme, options.locale);
+    }
+    const GenericCtx = React.createContext(MOCK_CONTEXT_VALUE);
+    return React.createElement(GenericCtx.Provider, { value: MOCK_CONTEXT_VALUE }, child);
+  }, element);
+}
+function extractInlineStyles(element, path = "root") {
+  const result = {};
+  if (!React.isValidElement(element)) return result;
+  const props = element.props;
+  if (props.style && typeof props.style === "object" && props.style !== null) {
+    const style = props.style;
+    const stringified = {};
+    for (const [k, v] of Object.entries(style)) {
+      if (v !== void 0 && v !== null) {
+        stringified[k] = String(v);
+      }
+    }
+    if (Object.keys(stringified).length > 0) {
+      result[path] = stringified;
+    }
+  }
+  const children = props.children;
+  if (children === void 0 || children === null) return result;
+  const childArray = Array.isArray(children) ? children : [children];
+  childArray.forEach((child, idx) => {
+    const childPath = `${path}.${idx}`;
+    const childStyles = extractInlineStyles(child, childPath);
+    Object.assign(result, childStyles);
+  });
+  return result;
+}
+// src/satori.ts
+var DEFAULT_VIEWPORT = { width: 375, height: 812 };
+var DEFAULT_CONTAINER = {
+  type: "centered",
+  padding: 16,
+  background: "#ffffff"
+};
+var DEFAULT_CAPTURE = {
+  screenshot: true,
+  styles: true,
+  timing: true
+};
+function buildContainerStyle(viewport, container) {
+  const base = {
+    width: viewport.width,
+    height: viewport.height,
+    padding: container.padding,
+    backgroundColor: container.background ?? "#ffffff",
+    display: "flex",
+    overflow: "hidden"
+  };
+  const typeStyles = {
+    centered: {
+      alignItems: "center",
+      justifyContent: "center",
+      flexDirection: "column"
+    },
+    "flex-row": {
+      alignItems: "flex-start",
+      justifyContent: "flex-start",
+      flexDirection: "row"
+    },
+    "flex-col": {
+      alignItems: "flex-start",
+      justifyContent: "flex-start",
+      flexDirection: "column"
+    },
+    none: {}
+  };
+  return { ...base, ...typeStyles[container.type] ?? {} };
+}
+var SatoriRenderer = class {
+  config;
+  fontsPromise = null;
+  constructor(config = {}) {
+    this.config = {
+      fontPath: config.fontPath ?? "",
+      fontFamily: config.fontFamily ?? "Inter",
+      defaultViewport: config.defaultViewport ?? DEFAULT_VIEWPORT
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Font loading (lazy, cached)
+  // ---------------------------------------------------------------------------
+  /**
+   * Pre-load and cache the configured font. Calling this before `render()`
+   * ensures the first render isn't slowed by font I/O.
+   */
+  async preloadFont() {
+    await this._getFonts();
+  }
+  _getFonts() {
+    if (!this.fontsPromise) {
+      const fontPath = this.config.fontPath || void 0;
+      this.fontsPromise = loadFont(fontPath, this.config.fontFamily);
+    }
+    return this.fontsPromise;
+  }
+  // ---------------------------------------------------------------------------
+  // Core render
+  // ---------------------------------------------------------------------------
+  /**
+   * Render a React element tree to PNG via Satori (SVG) → resvg-js (PNG).
+   *
+   * @param element   - The React element to render (pre-built, not a component class).
+   * @param options   - Viewport, container, capture, and environment overrides.
+   * @param descriptor - Optional ComponentDescriptor for provider wrapping.
+   *                    When provided, `requiredContexts` are used to inject
+   *                    mock providers around the element.
+   */
+  async render(element, options = {}, descriptor) {
+    const startMs = performance.now();
+    const viewport = {
+      ...this.config.defaultViewport,
+      ...options.environment?.viewport,
+      ...options.viewport
+    };
+    const container = {
+      ...DEFAULT_CONTAINER,
+      ...options.container
+    };
+    const capture = {
+      ...DEFAULT_CAPTURE,
+      ...options.capture
+    };
+    const requiredContexts = descriptor?.requiredContexts ?? [];
+    const wrappedElement = wrapWithProviders(element, requiredContexts, {
+      theme: options.environment?.theme,
+      locale: options.environment?.locale
+    });
+    const computedStyles = capture.styles ? extractInlineStyles(wrappedElement) : {};
+    const containerStyle = buildContainerStyle(viewport, container);
+    const rootElement = React.createElement("div", { style: containerStyle }, wrappedElement);
+    const fonts = await this._getFonts();
+    const svg = await satori(rootElement, {
+      width: viewport.width,
+      height: viewport.height,
+      fonts: fonts.map((f) => ({
+        name: f.name,
+        data: f.data,
+        weight: f.weight,
+        style: f.style
+      }))
+    });
+    let screenshot = Buffer.alloc(0);
+    if (capture.screenshot) {
+      const resvg = new Resvg(svg, {
+        fitTo: { mode: "width", value: viewport.width }
+      });
+      const rendered = resvg.render();
+      screenshot = Buffer.from(rendered.asPng());
+    }
+    const renderTimeMs = capture.timing ? performance.now() - startMs : 0;
+    return {
+      screenshot,
+      width: viewport.width,
+      height: viewport.height,
+      renderTimeMs,
+      computedStyles
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Convenience: render with explicit viewport
+  // ---------------------------------------------------------------------------
+  /**
+   * Render at a specific viewport size. Shorthand for `render(el, { viewport })`.
+   */
+  async renderAt(element, width, height, descriptor) {
+    return this.render(element, { viewport: { width, height } }, descriptor);
+  }
+};
+function resolveOptions(opts) {
+  return {
+    cellPadding: opts.cellPadding ?? 8,
+    borderWidth: opts.borderWidth ?? 1,
+    background: opts.background ?? "#f5f5f5",
+    borderColor: opts.borderColor ?? "#cccccc",
+    labelHeight: opts.labelHeight ?? 32,
+    labelWidth: opts.labelWidth ?? 80,
+    labelDpi: opts.labelDpi ?? 72,
+    labelBackground: opts.labelBackground ?? "#e8e8e8"
+  };
+}
+function hexToRgb(hex) {
+  const cleaned = hex.replace(/^#/, "");
+  const full = cleaned.length === 3 ? cleaned.split("").map((c) => c + c).join("") : cleaned;
+  const r = parseInt(full.slice(0, 2), 16);
+  const g = parseInt(full.slice(2, 4), 16);
+  const b = parseInt(full.slice(4, 6), 16);
+  return {
+    r: Number.isNaN(r) ? 0 : r,
+    g: Number.isNaN(g) ? 0 : g,
+    b: Number.isNaN(b) ? 0 : b,
+    alpha: 1
+  };
+}
+async function makeRect(width, height, color) {
+  const bg = hexToRgb(color);
+  return sharp({
+    create: { width: Math.max(1, width), height: Math.max(1, height), channels: 4, background: bg }
+  }).png().toBuffer();
+}
+async function makeLabelPng(text, width, height, dpi, bgColor) {
+  const w = Math.max(1, width);
+  const h = Math.max(1, height);
+  const bg = await makeRect(w, h, bgColor);
+  const maxChars = Math.max(1, Math.floor(w / 7));
+  const displayText = text.length > maxChars ? `${text.slice(0, maxChars - 1)}\u2026` : text;
+  let textBuf = null;
+  try {
+    textBuf = await sharp({
+      text: {
+        text: displayText,
+        font: "Sans",
+        width: w - 4,
+        height: h - 4,
+        dpi,
+        rgba: true,
+        align: "centre"
+      }
+    }).png().toBuffer();
+  } catch {
+    return bg;
+  }
+  const textMeta = await sharp(textBuf).metadata();
+  const textW = textMeta.width ?? 0;
+  const textH = textMeta.height ?? 0;
+  const left = Math.max(0, Math.floor((w - textW) / 2));
+  const top = Math.max(0, Math.floor((h - textH) / 2));
+  return sharp(bg).composite([{ input: textBuf, top, left, blend: "over" }]).png().toBuffer();
+}
+var SpriteSheetGenerator = class {
+  opts;
+  constructor(options = {}) {
+    this.opts = resolveOptions(options);
+  }
+  // ---------------------------------------------------------------------------
+  // Public: generate
+  // ---------------------------------------------------------------------------
+  /**
+   * Generate a sprite sheet from a `MatrixResult`.
+   *
+   * Grid layout:
+   *   - Rows = last axis cardinality
+   *   - Cols = product of all other axis cardinalities (or 1 if single axis)
+   *
+   * @param matrixResult - The result of `RenderMatrix.render()`.
+   */
+  async generate(matrixResult) {
+    const { cells, rows, cols, axisLabels } = matrixResult;
+    if (cells.length === 0) {
+      throw new Error("Cannot generate sprite sheet from empty MatrixResult");
+    }
+    const opts = this.opts;
+    const firstCell = cells[0];
+    if (!firstCell) {
+      throw new Error("Cannot generate sprite sheet from empty MatrixResult");
+    }
+    const cellContentWidth = firstCell.result.width;
+    const cellContentHeight = firstCell.result.height;
+    const slotWidth = cellContentWidth + opts.cellPadding * 2 + opts.borderWidth;
+    const slotHeight = cellContentHeight + opts.cellPadding * 2 + opts.borderWidth;
+    const gridWidth = cols * slotWidth + opts.borderWidth;
+    const gridHeight = rows * slotHeight + opts.borderWidth;
+    const totalWidth = opts.labelWidth + gridWidth;
+    const totalHeight = opts.labelHeight + gridHeight;
+    const compositeOps = [];
+    const topLabelBg = await makeRect(totalWidth, opts.labelHeight, opts.labelBackground);
+    compositeOps.push({ input: topLabelBg, top: 0, left: 0 });
+    const leftLabelBg = await makeRect(opts.labelWidth, totalHeight, opts.labelBackground);
+    compositeOps.push({ input: leftLabelBg, top: 0, left: 0 });
+    for (let c = 0; c <= cols; c++) {
+      const x = opts.labelWidth + c * slotWidth;
+      const borderLine = await makeRect(opts.borderWidth, gridHeight, opts.borderColor);
+      compositeOps.push({ input: borderLine, top: opts.labelHeight, left: x });
+    }
+    for (let r = 0; r <= rows; r++) {
+      const y = opts.labelHeight + r * slotHeight;
+      const borderLine = await makeRect(gridWidth, opts.borderWidth, opts.borderColor);
+      compositeOps.push({ input: borderLine, top: y, left: opts.labelWidth });
+    }
+    const vSep = await makeRect(opts.borderWidth, totalHeight, opts.borderColor);
+    compositeOps.push({
+      input: vSep,
+      top: 0,
+      left: Math.max(0, opts.labelWidth - opts.borderWidth)
+    });
+    const hSep = await makeRect(totalWidth, opts.borderWidth, opts.borderColor);
+    compositeOps.push({
+      input: hSep,
+      top: Math.max(0, opts.labelHeight - opts.borderWidth),
+      left: 0
+    });
+    const axisCount = matrixResult.axes.length;
+    const colLabels = [];
+    for (let c = 0; c < cols; c++) {
+      if (axisCount === 1) {
+        colLabels.push(axisLabels[0]?.[c] ?? String(c));
+      } else {
+        const cellAtCol = cells[c * rows];
+        if (cellAtCol) {
+          const parts = [];
+          for (let ai = 0; ai < axisCount - 1; ai++) {
+            const axis = matrixResult.axes[ai];
+            if (axis) {
+              parts.push(`${axis.name}=${axisLabels[ai]?.[cellAtCol.axisIndices[ai] ?? 0] ?? "?"}`);
+            }
+          }
+          colLabels.push(parts.join(", "));
+        } else {
+          colLabels.push(String(c));
+        }
+      }
+    }
+    for (let c = 0; c < cols; c++) {
+      const labelBuf = await makeLabelPng(
+        colLabels[c] ?? String(c),
+        slotWidth,
+        opts.labelHeight,
+        opts.labelDpi,
+        opts.labelBackground
+      );
+      compositeOps.push({
+        input: labelBuf,
+        top: 0,
+        left: opts.labelWidth + c * slotWidth
+      });
+    }
+    const lastAxisLabels = axisLabels[matrixResult.axes.length - 1] ?? [];
+    for (let r = 0; r < rows; r++) {
+      const labelBuf = await makeLabelPng(
+        lastAxisLabels[r] ?? String(r),
+        opts.labelWidth,
+        slotHeight,
+        opts.labelDpi,
+        opts.labelBackground
+      );
+      compositeOps.push({
+        input: labelBuf,
+        top: opts.labelHeight + r * slotHeight,
+        left: 0
+      });
+    }
+    const coordinateMap = new Array(cells.length);
+    for (let i = 0; i < cells.length; i++) {
+      const cell = cells[i];
+      if (!cell) continue;
+      const col = Math.floor(i / rows);
+      const row = i % rows;
+      const slotLeft = opts.labelWidth + col * slotWidth + opts.borderWidth;
+      const slotTop = opts.labelHeight + row * slotHeight + opts.borderWidth;
+      const contentLeft = slotLeft + opts.cellPadding;
+      const contentTop = slotTop + opts.cellPadding;
+      coordinateMap[i] = {
+        x: contentLeft,
+        y: contentTop,
+        width: cellContentWidth,
+        height: cellContentHeight
+      };
+      if (cell.result.screenshot.length > 0) {
+        let cellPng;
+        try {
+          cellPng = await sharp(cell.result.screenshot).resize(cellContentWidth, cellContentHeight, { fit: "fill" }).png().toBuffer();
+        } catch {
+          cellPng = await makeRect(cellContentWidth, cellContentHeight, "#ffffff");
+        }
+        compositeOps.push({
+          input: cellPng,
+          top: contentTop,
+          left: contentLeft
+        });
+      }
+    }
+    const bg = hexToRgb(opts.background);
+    const png = await sharp({
+      create: {
+        width: totalWidth,
+        height: totalHeight,
+        channels: 4,
+        background: bg
+      }
+    }).composite(compositeOps).png().toBuffer();
+    return {
+      png,
+      coordinates: coordinateMap,
+      width: totalWidth,
+      height: totalHeight
+    };
+  }
+};
+// src/stress.ts
+var SHORT_TEXT_VALUES = ["", " ", "A", "OK", "Hello", "Submit", "Cancel"];
+var SHORT_TEXT_LABELS = [
+  "empty",
+  "space",
+  "single-char",
+  "2-char",
+  "5-char",
+  "6-char",
+  "6-char-2"
+];
+var LONG_TEXT_VALUES = [
+  "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor.",
+  "The quick brown fox jumps over the lazy dog. ".repeat(3).trimEnd(),
+  "A very long label that contains many words and will likely overflow any container that does not handle text overflow properly in some manner or another.",
+  "supercalifragilisticexpialidocious-pneumonoultramicroscopicsilicovolcanoconiosis-antidisestablishmentarianism",
+  "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+];
+var LONG_TEXT_LABELS = ["80-chars", "3x-sentence", "200-chars", "long-words", "100-a-chars"];
+var UNICODE_TEXT_VALUES = [
+  "\u65E5\u672C\u8A9E\u30C6\u30AD\u30B9\u30C8",
+  "\u4E2D\u6587\u5185\u5BB9",
+  "\uD55C\uAD6D\uC5B4 \uD14D\uC2A4\uD2B8",
+  "H\xE9llo W\xF6rld \u2014 caf\xE9 na\xEFve r\xE9sum\xE9",
+  "\xD1o\xF1o se\xF1or",
+  "\u{1F44B} Hello \u{1F30D}",
+  "\u{1F3F3}\uFE0F\u200D\u{1F308} \u{1F389} \u{1F4A1} \u{1F680} \u2705",
+  "a\u200Bb\u200Bc",
+  // Zero-width space
+  "\u202Eflipped text\u202C"
+  // Right-to-left override
+];
+var UNICODE_TEXT_LABELS = [
+  "japanese",
+  "chinese",
+  "korean",
+  "diacritics",
+  "tilde-n",
+  "emoji-basic",
+  "emoji-complex",
+  "zero-width",
+  "rtl-override"
+];
+var RTL_TEXT_VALUES = [
+  "\u0645\u0631\u062D\u0628\u0627 \u0628\u0627\u0644\u0639\u0627\u0644\u0645",
+  // Arabic: Hello World
+  "\u0627\u0644\u0646\u0635 \u0627\u0644\u0639\u0631\u0628\u064A \u0627\u0644\u0637\u0648\u064A\u0644 \u062C\u062F\u0627\u064B \u0627\u0644\u0630\u064A \u064A\u0645\u062A\u062F \u0639\u0628\u0631 \u0623\u0633\u0637\u0631 \u0645\u062A\u0639\u062F\u062F\u0629",
+  // Arabic long
+  "\u05E9\u05DC\u05D5\u05DD \u05E2\u05D5\u05DC\u05DD",
+  // Hebrew: Hello World
+  "\u05D6\u05D4\u05D5 \u05D8\u05E7\u05E1\u05D8 \u05E2\u05D1\u05E8\u05D9 \u05D0\u05E8\u05D5\u05DA \u05E9\u05DE\u05EA\u05E4\u05E8\u05E1 \u05E2\u05DC \u05E4\u05E0\u05D9 \u05DB\u05DE\u05D4 \u05E9\u05D5\u05E8\u05D5\u05EA",
+  // Hebrew long
+  "\u0645\u0631\u062D\u0628\u0627\u064B \u200F hello"
+  // Arabic mixed with LTR
+];
+var RTL_TEXT_LABELS = [
+  "arabic-short",
+  "arabic-long",
+  "hebrew-short",
+  "hebrew-long",
+  "arabic-mixed"
+];
+var NUMBER_EDGE_VALUES = [
+  0,
+  -0,
+  1,
+  -1,
+  NaN,
+  Infinity,
+  -Infinity,
+  999999,
+  Number.MAX_SAFE_INTEGER,
+  Number.MIN_SAFE_INTEGER,
+  Number.EPSILON
+];
+var NUMBER_EDGE_LABELS = [
+  "zero",
+  "neg-zero",
+  "one",
+  "neg-one",
+  "NaN",
+  "+Infinity",
+  "-Infinity",
+  "999999",
+  "MAX_SAFE_INT",
+  "MIN_SAFE_INT",
+  "EPSILON"
+];
+function makeList(count) {
+  if (count === 0) return [];
+  return Array.from({ length: count }, (_, i) => `Item ${i + 1}`);
+}
+var LIST_COUNT_VALUES = [
+  makeList(0),
+  makeList(1),
+  makeList(3),
+  makeList(10),
+  makeList(100),
+  makeList(1e3)
+];
+var LIST_COUNT_LABELS = [
+  "empty-list",
+  "1-item",
+  "3-items",
+  "10-items",
+  "100-items",
+  "1000-items"
+];
+var IMAGE_STATE_VALUES = [
+  null,
+  "",
+  "https://broken.invalid/image.png",
+  "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwADhQGAWjR9awAAAABJRU5ErkJggg==",
+  // 1×1 transparent PNG
+  "https://picsum.photos/200/200",
+  "https://picsum.photos/4000/4000"
+];
+var IMAGE_STATE_LABELS = [
+  "null",
+  "empty-string",
+  "broken-url",
+  "1x1-data-uri",
+  "200x200",
+  "4000x4000"
+];
+var STRESS_PRESETS = {
+  "text.short": {
+    id: "text.short",
+    label: "Short Text",
+    description: "Empty, whitespace-only, single-char, and short-word string values.",
+    values: SHORT_TEXT_VALUES,
+    valueLabels: SHORT_TEXT_LABELS
+  },
+  "text.long": {
+    id: "text.long",
+    label: "Long Text",
+    description: "200+ character strings designed to overflow containers.",
+    values: LONG_TEXT_VALUES,
+    valueLabels: LONG_TEXT_LABELS
+  },
+  "text.unicode": {
+    id: "text.unicode",
+    label: "Unicode Text",
+    description: "CJK ideographs, diacritics, emoji, and zero-width characters.",
+    values: UNICODE_TEXT_VALUES,
+    valueLabels: UNICODE_TEXT_LABELS
+  },
+  "text.rtl": {
+    id: "text.rtl",
+    label: "RTL Text",
+    description: "Arabic and Hebrew strings for bidi text rendering.",
+    values: RTL_TEXT_VALUES,
+    valueLabels: RTL_TEXT_LABELS
+  },
+  "number.edge": {
+    id: "number.edge",
+    label: "Edge Numbers",
+    description: "0, -1, NaN, \xB1Infinity, MAX_SAFE_INTEGER, and other numeric extremes.",
+    values: NUMBER_EDGE_VALUES,
+    valueLabels: NUMBER_EDGE_LABELS
+  },
+  "list.count": {
+    id: "list.count",
+    label: "List Count",
+    description: "Arrays of 0, 1, 3, 10, 100, and 1000 items.",
+    values: LIST_COUNT_VALUES,
+    valueLabels: LIST_COUNT_LABELS
+  },
+  "image.states": {
+    id: "image.states",
+    label: "Image States",
+    description: "null, empty string, broken URL, 1\xD71 data URI, and large image URLs.",
+    values: IMAGE_STATE_VALUES,
+    valueLabels: IMAGE_STATE_LABELS
+  }
+};
+function getStressPreset(id) {
+  const preset = STRESS_PRESETS[id];
+  if (!preset) throw new Error(`Unknown stress preset category: "${id}"`);
+  return preset;
+}
+function getStressPresets(ids) {
+  return ids.map((id) => getStressPreset(id));
+}
+var ALL_STRESS_PRESETS = Object.values(STRESS_PRESETS);
+var ALL_STRESS_IDS = Object.keys(STRESS_PRESETS);
+function stressAxis(id) {
+  const preset = getStressPreset(id);
+  return {
+    name: preset.label,
+    values: preset.values
+  };
+}
+export { ALL_CONTEXTS, ALL_CONTEXT_IDS, ALL_STRESS_IDS, ALL_STRESS_PRESETS, BrowserPool, COMPOSITION_CONTEXTS, RenderError, RenderMatrix, SatoriRenderer, SpriteSheetGenerator, cartesianProduct, clearFontCache, contextAxis, detectHeuristicFlags, extractInlineStyles, fontCacheSize, getContext, getContexts, getStressPreset, getStressPresets, labelForValue, loadFont, safeRender, stressAxis, wrapWithProviders };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map