markswift 0.0.0-stage → 2.0.0

package/dist/cli-jdrbzqfa.js

@@ -0,0 +1,2975 @@
+import {
+  validateName,
+  LAYOUT_DOC_VERSION,
+  VALIDATION_MARK,
+  CONDITIONAL_MARK,
+  CONTAINER_MARK,
+  STYLE_WHITELIST,
+  round2,
+  cssUrls,
+  widthQuery,
+  matchesWidth,
+  PRESSABLE_SELECTOR,
+  TEXT_ENTRY_SELECTOR,
+  GENERATED_BY,
+  DEFAULT_BAND_DEVICES2,
+  planBands2,
+  compileLayout2,
+  needsProbe2,
+  validateLibrary2,
+  compileLayouts2
+} from "./cli-qchh0m4d.js";
+
+// src/api/build.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { relative, resolve as resolve3, sep } from "node:path";
+
+// src/input/root.ts
+var DEFAULT_ROOT = "[data-markswift-root], body:not(:has([data-markswift-root]))";
+
+// src/input/server.ts
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createServer } from "node:http";
+import { resolve } from "node:path";
+
+// src/input/mime.ts
+import { extname } from "node:path";
+var TYPES = {
+  ".html": "text/html;charset=utf-8",
+  ".htm": "text/html;charset=utf-8",
+  ".css": "text/css;charset=utf-8",
+  ".js": "text/javascript;charset=utf-8",
+  ".mjs": "text/javascript;charset=utf-8",
+  ".json": "application/json;charset=utf-8",
+  ".map": "application/json;charset=utf-8",
+  ".txt": "text/plain;charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".wasm": "application/wasm"
+};
+function mimeType(path) {
+  return TYPES[extname(path).toLowerCase()] ?? "application/octet-stream";
+}
+
+// src/input/server.ts
+async function serveDir(rootDir) {
+  const root = resolve(rootDir);
+  const server = createServer(async (req, res) => {
+    const reply = (status, body) => res.writeHead(status, { "content-type": "text/plain" }).end(body);
+    const { port } = server.address();
+    if (req.headers.host !== `127.0.0.1:${port}`)
+      return reply(403, "forbidden");
+    let path;
+    try {
+      path = decodeURIComponent(new URL(req.url ?? "/", "http://127.0.0.1").pathname);
+    } catch {
+      return reply(400, "bad request");
+    }
+    if (path.split("/").some((s) => s.startsWith(".")))
+      return reply(404, "not found");
+    const local = resolve(root, "." + path);
+    if (local !== root && !local.startsWith(root + "/"))
+      return reply(403, "forbidden");
+    const info = await stat(local).catch(() => {
+      return;
+    });
+    if (!info?.isFile())
+      return reply(404, "not found");
+    res.writeHead(200, { "content-type": mimeType(local), "content-length": info.size, "cache-control": "no-store" });
+    createReadStream(local).pipe(res);
+  });
+  await new Promise((done, fail) => server.once("error", fail).listen(0, "127.0.0.1", done));
+  const { port } = server.address();
+  return {
+    origin: `http://127.0.0.1:${port}`,
+    stop() {
+      server.closeAllConnections();
+      server.close();
+    }
+  };
+}
+
+// src/browser/settle.ts
+async function settle(page, options = {}) {
+  return await page.evaluate(async (at) => {
+    for (const img of document.images)
+      if (img.loading === "lazy")
+        img.loading = "eager";
+    await Promise.all([...document.images].map((img) => img.decode().catch(() => {})));
+    await document.fonts.ready;
+    for (const el of document.querySelectorAll("*")) {
+      const cv = getComputedStyle(el).contentVisibility;
+      if (cv === "auto")
+        el.style.setProperty("content-visibility", "visible", "important");
+      else if (cv === "hidden")
+        for (const c of el.children)
+          c.style.setProperty("display", "none", "important");
+    }
+    const recorded = at === null ? [] : (window.__markswiftStarted ?? []).filter((a) => a.playState === "finished");
+    let paused = 0;
+    for (const a of new Set([...document.getAnimations(), ...recorded])) {
+      if (at !== null) {
+        a.pause();
+        a.currentTime = at;
+        paused++;
+        continue;
+      }
+      try {
+        a.finish();
+      } catch {
+        a.cancel();
+      }
+    }
+    const frame = Promise.withResolvers();
+    requestAnimationFrame(() => requestAnimationFrame(() => frame.resolve()));
+    await frame.promise;
+    return paused;
+  }, options.at ?? null);
+}
+async function finishAnimations(page) {
+  await page.evaluate(() => {
+    for (const a of document.getAnimations()) {
+      try {
+        a.finish();
+      } catch {
+        a.cancel();
+      }
+    }
+  });
+}
+async function withFrozenProgress(page, cdp, shot) {
+  for (let attempt = 1;; attempt++) {
+    const hidden = await page.evaluateHandle(() => [...document.querySelectorAll("progress:indeterminate")].filter((p) => getComputedStyle(p).appearance !== "none").map((p) => {
+      const style = p.getAttribute("style");
+      p.style.setProperty("display", "none", "important");
+      return { p, style };
+    }));
+    try {
+      if (!await hidden.evaluate((list) => list.length))
+        return await shot(30000);
+      await cdp.send("Page.captureScreenshot", { clip: { x: 0, y: 0, width: 1, height: 1, scale: 1 } });
+      await cdp.send("Emulation.setVirtualTimePolicy", { policy: "pause" });
+      await hidden.evaluate((list) => {
+        for (const { p, style } of list)
+          if (style === null)
+            p.removeAttribute("style");
+          else
+            p.setAttribute("style", style);
+      });
+      try {
+        return await shot(FROZEN_SHOT_MS);
+      } catch (error) {
+        if (attempt >= FROZEN_ATTEMPTS || !(error instanceof Error && error.name === "TimeoutError"))
+          throw error;
+      } finally {
+        await cdp.send("Emulation.setVirtualTimePolicy", { policy: "advance" });
+      }
+    } finally {
+      await hidden.dispose();
+    }
+  }
+}
+var FROZEN_SHOT_MS = 8000;
+var FROZEN_ATTEMPTS = 3;
+
+// src/browser/fonts.ts
+import { createHash } from "node:crypto";
+async function collectFontFaces(page, sheetText) {
+  return await page.evaluate((sheetText) => {
+    const KEYWORD_WEIGHT = { normal: 400, bold: 700, lighter: 100, bolder: 700 };
+    const weightRange = (s) => {
+      const parts = s.trim().split(/\s+/).filter(Boolean);
+      const nums = parts.map((p) => KEYWORD_WEIGHT[p.toLowerCase()] ?? Number.parseFloat(p)).filter((n) => Number.isFinite(n));
+      if (!nums.length)
+        return [400, 400];
+      return [Math.min(...nums), Math.max(...nums)];
+    };
+    const splitSrc = (s) => {
+      const out = [];
+      let depth = 0, quote = "", start = 0;
+      for (let i = 0;i < s.length; i++) {
+        const c = s[i];
+        if (quote) {
+          if (c === quote && s[i - 1] !== "\\")
+            quote = "";
+        } else if (c === '"' || c === "'")
+          quote = c;
+        else if (c === "(")
+          depth++;
+        else if (c === ")")
+          depth--;
+        else if (c === "," && depth === 0) {
+          out.push(s.slice(start, i));
+          start = i + 1;
+        }
+      }
+      out.push(s.slice(start));
+      return out.map((p) => p.trim()).filter(Boolean);
+    };
+    const unquote = (s) => s.trim().replace(/^["']|["']$/g, "").trim();
+    const faces = [];
+    const unreadable = [];
+    const rulesOf = (sheet) => {
+      try {
+        return sheet.cssRules;
+      } catch {}
+      const text = sheet.href ? sheetText[sheet.href] : undefined;
+      if (text === undefined) {
+        unreadable.push(sheet.href ?? "inline stylesheet");
+        return;
+      }
+      const parsed = new CSSStyleSheet;
+      parsed.replaceSync(text);
+      return parsed.cssRules;
+    };
+    const visit = (rules, base) => {
+      for (const rule of rules) {
+        if (rule instanceof CSSFontFaceRule) {
+          const st = rule.style;
+          const family = unquote(st.getPropertyValue("font-family"));
+          if (!family)
+            continue;
+          const src = [];
+          for (const entry of splitSrc(st.getPropertyValue("src"))) {
+            const url = /url\(\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[^)]*)\s*\)/.exec(entry);
+            if (!url)
+              continue;
+            const fmt = /format\(\s*("[^"]*"|'[^']*'|[^)]*)\s*\)/.exec(entry);
+            try {
+              src.push({ url: new URL(unquote(url[1]), base).href, ...fmt ? { format: unquote(fmt[1]) } : {} });
+            } catch {}
+          }
+          const styleDesc = unquote(st.getPropertyValue("font-style")).split(/\s+/)[0]?.toLowerCase();
+          faces.push({
+            family,
+            weight: weightRange(st.getPropertyValue("font-weight") || "normal"),
+            style: styleDesc === "italic" || styleDesc === "oblique" ? styleDesc : "normal",
+            ...st.getPropertyValue("unicode-range") ? { unicodeRange: st.getPropertyValue("unicode-range") } : {},
+            src,
+            loaded: false
+          });
+        } else if (rule instanceof CSSImportRule) {
+          if (rule.styleSheet) {
+            const r = rulesOf(rule.styleSheet);
+            if (r)
+              visit(r, rule.styleSheet.href ?? base);
+          }
+        } else if ("cssRules" in rule)
+          visit(rule.cssRules, base);
+      }
+    };
+    for (const sheet of document.styleSheets) {
+      if (sheet.ownerNode?.hasAttribute?.("data-markswift-harness"))
+        continue;
+      const rules = rulesOf(sheet);
+      if (rules)
+        visit(rules, sheet.href ?? document.baseURI);
+    }
+    const loaded = new Set;
+    document.fonts.forEach((f) => {
+      if (f.status !== "loaded")
+        return;
+      const s = f.style.split(/\s+/)[0].toLowerCase();
+      loaded.add(`${unquote(f.family).toLowerCase()}|${s === "italic" || s === "oblique" ? s : "normal"}|${weightRange(f.weight).join(" ")}`);
+    });
+    const seen = new Set;
+    const out = [];
+    for (const f of faces) {
+      if (!f.src.length)
+        continue;
+      const key = `${f.family.toLowerCase()}|${f.style}|${f.weight.join(" ")}|${f.unicodeRange ?? ""}|${f.src.map((s) => s.url).join(",")}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      out.push({ ...f, loaded: loaded.has(`${f.family.toLowerCase()}|${f.style}|${f.weight.join(" ")}`) });
+    }
+    return { faces: out, unreadable };
+  }, sheetText);
+}
+var MAX_FONT_BYTES = 25 * 1024 * 1024;
+async function readFontBytes(faces, allowRemote = true, signal) {
+  const files = [];
+  const byHash = {};
+  for (const face of faces) {
+    for (const src of face.src) {
+      if (src.url.startsWith("data:"))
+        continue;
+      if (!allowRemote)
+        continue;
+      if (!URL.canParse(src.url) || !["http:", "https:"].includes(new URL(src.url).protocol))
+        continue;
+      let bytes;
+      try {
+        const res = await fetch(src.url, { signal, redirect: "follow" });
+        if (!res.ok || Number(res.headers.get("content-length") ?? 0) > MAX_FONT_BYTES)
+          continue;
+        bytes = new Uint8Array(await res.arrayBuffer());
+        if (bytes.length > MAX_FONT_BYTES)
+          continue;
+      } catch (error) {
+        if (signal?.aborted)
+          throw error;
+        continue;
+      }
+      const hash = createHash("sha256").update(bytes).digest("hex").slice(0, 12);
+      if (!byHash[hash]) {
+        const sig = new TextDecoder("latin1").decode(bytes.subarray(0, 4));
+        const ext = sig === "wOF2" ? "woff2" : sig === "wOFF" ? "woff" : sig === "OTTO" ? "otf" : "ttf";
+        byHash[hash] = `_fonts/${hash}.${ext}`;
+        files.push({ file: byHash[hash], bytes });
+      }
+      src.file = byHash[hash];
+      if (/^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(:|\/)/.test(src.url))
+        src.url = new URL(src.url).pathname;
+    }
+  }
+  return files;
+}
+
+// src/browser/capture.ts
+import { chromium } from "playwright-core";
+
+// src/browser/snapshot.ts
+var SKIP_TAGS = {
+  script: true,
+  style: true,
+  link: true,
+  meta: true,
+  template: true,
+  noscript: true
+};
+var KEEP_WITHOUT_LAYOUT = {
+  defs: true,
+  lineargradient: true,
+  radialgradient: true,
+  stop: true,
+  clippath: true,
+  mask: true,
+  option: true,
+  optgroup: true
+};
+var PSEUDO_TAGS = { before: "::before", after: "::after", marker: "::marker" };
+var pathChildren = (raw) => raw.children.filter((c) => c.type === 1 && c.pseudo === undefined);
+function attachPreferredSizes(root, sizes, pseudoStyles) {
+  const walk = (raw, path) => {
+    if (Object.hasOwn(sizes, path))
+      raw.preferredSize = sizes[path];
+    if (Object.hasOwn(pseudoStyles, path))
+      raw.pseudoStyles = pseudoStyles[path];
+    for (const [i, child] of pathChildren(raw).entries())
+      walk(child, path ? `${path}/${i}` : String(i));
+  };
+  walk(root, "");
+}
+function attachMotion(root, motion) {
+  const walk = (raw, path) => {
+    if (Object.hasOwn(motion, path))
+      raw.motion = motion[path];
+    let i = 0;
+    for (const child of raw.children) {
+      if (child.type !== 1)
+        continue;
+      if (child.pseudo !== undefined) {
+        const key = path + PSEUDO_TAGS[child.pseudo];
+        if (Object.hasOwn(motion, key))
+          child.motion = motion[key];
+        continue;
+      }
+      walk(child, path ? `${path}/${i++}` : String(i++));
+    }
+  };
+  walk(root, "");
+}
+function rawAt(root, path) {
+  let raw = root;
+  for (const step of path ? path.split("/") : [])
+    raw = raw && pathChildren(raw)[Number(step)];
+  return raw;
+}
+function pathOf(root, raw) {
+  const steps = [];
+  for (let r = raw;r !== root; r = r.parent) {
+    if (!r.parent)
+      return;
+    steps.unshift(pathChildren(r.parent).indexOf(r));
+  }
+  return steps.join("/");
+}
+function snapshotToTree(snap, boxes, states) {
+  const doc = snap.documents[0];
+  if (!doc)
+    throw new Error("empty snapshot");
+  const S = snap.strings;
+  const str = (i) => i >= 0 ? S[i] : "";
+  const n = doc.nodes.nodeType.length;
+  const raws = new Array(n);
+  for (let i = 0;i < n; i++) {
+    const attrs = {};
+    const a = doc.nodes.attributes[i] ?? [];
+    for (let k = 0;k + 1 < a.length; k += 2)
+      attrs[str(a[k]).toLowerCase()] = str(a[k + 1]);
+    raws[i] = {
+      idx: i,
+      type: doc.nodes.nodeType[i],
+      name: str(doc.nodes.nodeName[i]).toLowerCase(),
+      value: str(doc.nodes.nodeValue[i]),
+      attrs,
+      styles: {},
+      children: []
+    };
+    const backend = doc.nodes.backendNodeId?.[i];
+    if (backend !== undefined)
+      raws[i].backend = backend;
+  }
+  for (let i = 0;i < n; i++) {
+    const p = doc.nodes.parentIndex[i];
+    if (p >= 0) {
+      raws[p].children.push(raws[i]);
+      raws[i].parent = raws[p];
+    }
+  }
+  liveFormState(doc.nodes, raws, str);
+  if (states)
+    for (const key of ["pressed", "focused"])
+      for (const [idx, delta] of states[key]) {
+        const r = raws[idx];
+        if (r)
+          r.states = { ...r.states, [key]: delta };
+      }
+  const pseudo = doc.nodes.pseudoType;
+  if (pseudo)
+    for (let k = 0;k < pseudo.index.length; k++)
+      raws[pseudo.index[k]].pseudo = str(pseudo.value[k]);
+  const L = doc.layout;
+  for (let li = 0;li < L.nodeIndex.length; li++) {
+    const r = raws[L.nodeIndex[li]];
+    const b = L.bounds[li];
+    r.bounds = { x: b[0], y: b[1], w: b[2], h: b[3] };
+    const o = L.offsetRects?.[li];
+    if (o)
+      r.offset = { x: o[0], y: o[1], w: o[2], h: o[3] };
+    const sv = L.styles[li] ?? [];
+    for (let k = 0;k < STYLE_WHITELIST.length; k++) {
+      const v = sv[k];
+      if (v !== undefined && v >= 0)
+        r.styles[STYLE_WHITELIST[k]] = S[v];
+    }
+    const t = L.text[li];
+    if (r.type === 3)
+      r.text = r.value.trim() ? r.value : t !== undefined && t >= 0 ? S[t] : "";
+    if (L.paintOrders)
+      r.paint = L.paintOrders[li];
+    if (r.pseudo !== undefined)
+      (r.parts ??= []).push({ bounds: { ...r.bounds }, text: t !== undefined && t >= 0 ? S[t] : undefined });
+  }
+  const LB = boxes?.documents[0]?.layout;
+  if (LB) {
+    const seen = new Map;
+    for (let li = 0;li < LB.nodeIndex.length; li++) {
+      const r = raws[LB.nodeIndex[li]];
+      const b = LB.bounds[li];
+      if (r && b) {
+        r.bounds = { x: b[0], y: b[1], w: b[2], h: b[3] };
+        if (r.parts) {
+          const k = seen.get(r) ?? 0;
+          seen.set(r, k + 1);
+          const part = r.parts[k];
+          if (part)
+            part.bounds = { ...r.bounds };
+        }
+      }
+      const o = LB.offsetRects?.[li];
+      if (r && o)
+        r.offset = { x: o[0], y: o[1], w: o[2], h: o[3] };
+    }
+  }
+  assignLineBoxes(boxes?.documents[0] ?? doc, raws);
+  if (pseudo)
+    for (const i of pseudo.index)
+      raws[i].box = pseudoBox(raws[i]);
+  const cur = doc.nodes.currentSourceURL;
+  if (cur) {
+    const base = str(doc.documentURL);
+    for (let k = 0;k < cur.index.length; k++)
+      markCurrentSrc(raws[cur.index[k]], str(cur.value[k]), base);
+  }
+  const html = raws.find((r) => r.type === 1 && r.name === "html");
+  if (!html)
+    throw new Error("no <html> in snapshot");
+  return html;
+}
+function liveFormState(nodes, raws, str) {
+  const input = nodes.inputValue;
+  if (input)
+    for (let k = 0;k < input.index.length; k++) {
+      const r = raws[input.index[k]];
+      const type = r?.attrs["type"]?.toLowerCase();
+      if (r?.name !== "input" || type === "checkbox" || type === "radio")
+        continue;
+      const live = str(input.value[k]);
+      if (live === (r.attrs["value"] ?? ""))
+        continue;
+      if (live)
+        r.attrs["value"] = live;
+      else
+        delete r.attrs["value"];
+    }
+  const text = nodes.textValue;
+  if (text)
+    for (let k = 0;k < text.index.length; k++) {
+      const r = raws[text.index[k]];
+      if (r?.name !== "textarea")
+        continue;
+      const live = str(text.value[k]);
+      const markup = r.children.map((c) => c.type === 3 ? c.value : "").join("");
+      if (live !== markup)
+        r.attrs["value"] = live;
+    }
+  for (const [column, tag, attr] of [
+    [nodes.inputChecked, "input", "checked"],
+    [nodes.optionSelected, "option", "selected"]
+  ]) {
+    if (!column)
+      continue;
+    for (const r of raws)
+      if (r.name === tag)
+        delete r.attrs[attr];
+    for (const i of column.index)
+      if (raws[i]?.name === tag)
+        raws[i].attrs[attr] = "";
+  }
+}
+function assignLineBoxes(document2, raws) {
+  const tb = document2.textBoxes;
+  const nodeIndex = document2.layout.nodeIndex;
+  for (let k = 0;k < tb.layoutIndex.length; k++) {
+    const r = raws[nodeIndex[tb.layoutIndex[k]]];
+    const b = tb.bounds[k];
+    if (!r || !b)
+      continue;
+    (r.lines ??= []).push({
+      bounds: { x: b[0], y: b[1], w: b[2], h: b[3] },
+      start: tb.start[k],
+      length: tb.length[k]
+    });
+  }
+}
+function pseudoBox(raw) {
+  const o = raw.offset;
+  if (!o)
+    return;
+  const position = raw.styles["position"] ?? "static";
+  if (position === "fixed")
+    return { ...o };
+  for (let a = raw.parent;a; a = a.parent) {
+    if (!a.bounds)
+      continue;
+    const positioned = (a.styles["position"] ?? "static") !== "static";
+    if (a.name === "body")
+      return positioned ? { x: a.bounds.x + o.x, y: a.bounds.y + o.y, w: o.w, h: o.h } : { ...o };
+    if (positioned || position === "static" && (a.name === "table" || a.name === "td" || a.name === "th")) {
+      const bl = parseFloat(a.styles["border-left-width"] ?? "") || 0;
+      const bt = parseFloat(a.styles["border-top-width"] ?? "") || 0;
+      return { x: a.bounds.x + bl + o.x, y: a.bounds.y + bt + o.y, w: o.w, h: o.h };
+    }
+  }
+  return;
+}
+function markCurrentSrc(img, currentSrc, base) {
+  if (!currentSrc)
+    return;
+  const resolve = (u) => {
+    try {
+      return new URL(u, base).href;
+    } catch {
+      return u;
+    }
+  };
+  const src = img.attrs["src"];
+  if (src !== undefined && resolve(src) === currentSrc)
+    return;
+  const candidates = srcsetUrls(img.attrs["srcset"] ?? "");
+  if (img.parent?.name === "picture") {
+    for (const s of img.parent.children)
+      if (s.type === 1 && s.name === "source")
+        candidates.push(...srcsetUrls(s.attrs["srcset"] ?? ""));
+  }
+  img.currentSrc = candidates.find((c) => resolve(c) === currentSrc) ?? currentSrc;
+}
+function srcsetUrls(srcset) {
+  const out = [];
+  const n = srcset.length;
+  let i = 0;
+  while (i < n) {
+    while (i < n && /[\s,]/.test(srcset[i]))
+      i++;
+    const start = i;
+    while (i < n && !/\s/.test(srcset[i]))
+      i++;
+    const url = srcset.slice(start, i);
+    if (!url)
+      break;
+    if (url.endsWith(","))
+      out.push(url.replace(/,+$/, ""));
+    else {
+      out.push(url);
+      while (i < n && srcset[i] !== ",")
+        i++;
+    }
+  }
+  return out;
+}
+function findByAttr(root, attr, value) {
+  if (root.attrs[attr] === value)
+    return root;
+  for (const c of root.children) {
+    const f = findByAttr(c, attr, value);
+    if (f)
+      return f;
+  }
+  return;
+}
+function toLayout(raw, origin, identity, path = "") {
+  if (raw.type !== 1 || SKIP_TAGS[raw.name])
+    return;
+  if (!raw.bounds && !KEEP_WITHOUT_LAYOUT[raw.name])
+    return;
+  return element(raw, origin, identity, path);
+}
+function element(raw, origin, identity, path) {
+  const node = {
+    tag: raw.name,
+    attrs: raw.attrs,
+    styles: raw.styles,
+    bounds: raw.bounds ? rebase(raw.bounds, origin) : { x: 0, y: 0, w: 0, h: 0 },
+    children: [],
+    ...raw.preferredSize ? { preferredSize: raw.preferredSize } : {}
+  };
+  const id = identity(raw.name, raw.attrs, path);
+  if (id !== undefined)
+    node.id = id;
+  if (raw.paint !== undefined)
+    node.paint = raw.paint;
+  if (raw.currentSrc !== undefined)
+    node.currentSrc = raw.currentSrc;
+  if (raw.states)
+    node.states = raw.states;
+  if (raw.motion)
+    node.motion = raw.motion;
+  if (raw.pseudoStyles)
+    node.pseudoStyles = raw.pseudoStyles;
+  appendChildren(raw, origin, identity, path, node.children);
+  return node;
+}
+function appendChildren(raw, origin, identity, path, out) {
+  let after;
+  let i = 0;
+  for (const c of raw.children) {
+    if (c.type === 3) {
+      if (c.bounds && c.text && (c.text.trim() || c.bounds.w > 0)) {
+        const text = {
+          tag: "#text",
+          attrs: {},
+          styles: {},
+          bounds: rebase(c.bounds, origin),
+          text: c.text,
+          children: []
+        };
+        if (c.lines && c.lines.length > 1)
+          text.lines = c.lines.map((l) => ({ bounds: rebase(l.bounds, origin), start: l.start, length: l.length }));
+        out.push(text);
+      } else if ((!raw.bounds || raw.name === "textarea") && c.value.trim()) {
+        out.push({
+          tag: "#text",
+          attrs: {},
+          styles: {},
+          bounds: { x: 0, y: 0, w: 0, h: 0 },
+          text: c.value,
+          children: []
+        });
+      }
+      continue;
+    }
+    if (c.type !== 1)
+      continue;
+    if (c.pseudo !== undefined) {
+      const p = pseudoElement(c, origin, identity, path);
+      if (!p)
+        continue;
+      if (c.pseudo === "after")
+        after = p;
+      else
+        out.push(p);
+      continue;
+    }
+    const childPath = path === "" ? `${i++}` : `${path}/${i++}`;
+    if (SKIP_TAGS[c.name])
+      continue;
+    if (c.bounds || KEEP_WITHOUT_LAYOUT[c.name])
+      out.push(element(c, origin, identity, childPath));
+    else if (hasLayout(c))
+      appendChildren(c, origin, identity, childPath, out);
+  }
+  if (after)
+    out.push(after);
+}
+function hasLayout(raw) {
+  return raw.bounds !== undefined || raw.children.some(hasLayout);
+}
+function pseudoElement(raw, origin, identity, parentPath) {
+  const tag = PSEUDO_TAGS[raw.pseudo];
+  if (!tag || !raw.bounds)
+    return;
+  const box = raw.box && raw.box.w > 0 && raw.box.h > 0 ? raw.box : undefined;
+  const pseudoPath = parentPath === "" ? tag : `${parentPath}/${tag}`;
+  const parts = raw.parts ?? [];
+  const texts = parts.filter((p) => p.text !== undefined).map((p) => p.bounds);
+  const contains = (o, i) => i.x >= o.x - 0.5 && i.y >= o.y - 0.5 && i.x + i.w <= o.x + o.w + 0.5 && i.y + i.h <= o.y + o.h + 0.5;
+  let urls = cssUrls(raw.styles["content"]);
+  if (raw.pseudo === "marker" && !urls.length)
+    urls = cssUrls(raw.styles["list-style-image"]);
+  const children = [];
+  let open;
+  let images = 0;
+  const close = () => {
+    if (open)
+      children.push({
+        tag: "#text",
+        attrs: {},
+        styles: {},
+        bounds: rebase(open.bounds, origin),
+        text: open.text,
+        children: []
+      });
+    open = undefined;
+  };
+  for (const [i, p] of parts.entries()) {
+    if (p.text !== undefined) {
+      if (!open)
+        open = { text: p.text, bounds: { ...p.bounds } };
+      else {
+        const a = open.bounds;
+        const x = Math.min(a.x, p.bounds.x);
+        const y = Math.min(a.y, p.bounds.y);
+        open = {
+          text: open.text + p.text,
+          bounds: {
+            x,
+            y,
+            w: Math.max(a.x + a.w, p.bounds.x + p.bounds.w) - x,
+            h: Math.max(a.y + a.h, p.bounds.y + p.bounds.h) - y
+          }
+        };
+      }
+      continue;
+    }
+    if (i === 0 || !(p.bounds.w > 0 && p.bounds.h > 0) || texts.some((t) => contains(p.bounds, t)))
+      continue;
+    const src = urls[images];
+    if (src === undefined)
+      continue;
+    close();
+    const img = { tag: "img", attrs: { src }, styles: {}, bounds: rebase(p.bounds, origin), children: [] };
+    const id = identity("img", img.attrs, `${pseudoPath}/${images++}`);
+    if (id !== undefined)
+      img.id = id;
+    children.push(img);
+  }
+  close();
+  if (!images && children.length === 1 && !children[0].text?.trim())
+    children.length = 0;
+  if (!box && !children.length)
+    return;
+  const node = {
+    tag,
+    attrs: {},
+    styles: raw.styles,
+    bounds: rebase(box ?? raw.bounds, origin),
+    children
+  };
+  const id = identity(tag, node.attrs, pseudoPath);
+  if (id !== undefined)
+    node.id = id;
+  if (raw.paint !== undefined)
+    node.paint = raw.paint;
+  if (raw.states)
+    node.states = raw.states;
+  if (raw.motion)
+    node.motion = raw.motion;
+  return node;
+}
+function rebase(b, o) {
+  return { x: round2(b.x - o.x), y: round2(b.y - o.y), w: round2(b.w), h: round2(b.h) };
+}
+
+// src/browser/sizing.ts
+async function readPreferredSizes(page, selector) {
+  return page.evaluate((selector) => {
+    const root = document.querySelector(selector);
+    if (!root)
+      throw new Error(`capture root ${selector} not found`);
+    const PLACEHOLDER_KEYS = ["color", "-webkit-text-fill-color", "opacity", "font-style", "font-weight"];
+    const BACKDROP_KEYS = ["background-color", "background-image", "opacity", "filter"];
+    const out = {};
+    const pseudoStyles = {};
+    const walk = (el, path) => {
+      const typed = el;
+      const map = typed.computedStyleMap?.();
+      const width = map?.get("width")?.toString();
+      const height = map?.get("height")?.toString();
+      if (width !== undefined && height !== undefined) {
+        const entry = { width, height };
+        const position = map?.get("position")?.toString();
+        if (position === "absolute" || position === "fixed" || position === "relative" || position === "sticky") {
+          const inset = (k) => map?.get(k)?.toString() ?? "auto";
+          entry.insets = { top: inset("top"), right: inset("right"), bottom: inset("bottom"), left: inset("left") };
+        }
+        const autoMargins = ["top", "right", "bottom", "left"].filter((k) => map?.get(`margin-${k}`)?.toString() === "auto");
+        if (autoMargins.length)
+          entry.autoMargins = autoMargins;
+        const tracks = map?.get("grid-template-columns")?.toString();
+        if (tracks && tracks !== "none")
+          entry.gridTemplateColumns = tracks;
+        const display = map?.get("display")?.toString();
+        const rows = map?.get("grid-template-rows")?.toString();
+        if ((display === "grid" || display === "inline-grid") && rows && rows !== "none")
+          entry.gridTemplateRows = rows;
+        out[path] = entry;
+      }
+      if ((el.tagName === "INPUT" || el.tagName === "TEXTAREA") && el.hasAttribute("placeholder")) {
+        const ph = getComputedStyle(el, "::placeholder");
+        pseudoStyles[path] = {
+          placeholder: Object.fromEntries(PLACEHOLDER_KEYS.map((k) => [k, ph.getPropertyValue(k)]))
+        };
+      }
+      if (el.matches(":modal, :popover-open, :fullscreen") && getComputedStyle(el).getPropertyValue("overlay") === "auto") {
+        const bd = getComputedStyle(el, "::backdrop");
+        pseudoStyles[path] = {
+          ...pseudoStyles[path],
+          backdrop: Object.fromEntries(BACKDROP_KEYS.map((k) => [k, bd.getPropertyValue(k)]))
+        };
+      }
+      Array.from(el.children).forEach((child, i) => {
+        walk(child, path ? `${path}/${i}` : String(i));
+      });
+    };
+    walk(root, "");
+    return { sizes: out, pseudoStyles };
+  }, selector);
+}
+
+// src/browser/motion.ts
+var collect = (arg) => {
+  const root = arg.root === undefined ? null : document.querySelector(arg.root);
+  const out = {
+    byPath: {},
+    byTarget: (arg.targets ?? []).map(() => []),
+    ambiguous: [],
+    script: 0,
+    paused: 0
+  };
+  const inner = (arg.targets ?? []).map(() => new Map);
+  const recorded = arg.targets ? window.__markswiftStarted ?? [] : [];
+  const SKIP = { offset: true, computedOffset: true, easing: true, composite: true };
+  for (const a of new Set([...document.getAnimations(), ...recorded])) {
+    const effect = a.effect;
+    const target = effect?.target;
+    if (!effect || !target)
+      continue;
+    let slot = arg.targets ? arg.targets.indexOf(target) : -1;
+    if (arg.targets && slot < 0)
+      slot = arg.targets.findIndex((t) => t.contains(target));
+    if (arg.targets ? slot < 0 : !root?.contains(target))
+      continue;
+    const kind = a.constructor.name;
+    if (kind === "Animation")
+      out.script++;
+    if (kind !== arg.kind)
+      continue;
+    if (a.playState === "paused") {
+      out.paused++;
+      continue;
+    }
+    const pseudo = effect.pseudoElement;
+    if (pseudo && pseudo !== "::before" && pseudo !== "::after")
+      continue;
+    const keyframes = effect.getKeyframes().map((k) => {
+      const values = {};
+      for (const [key, v] of Object.entries(k)) {
+        if (SKIP[key] || typeof v !== "string")
+          continue;
+        const css = key.startsWith("--") ? key : key.replace(/^css(?=[A-Z])/, "").replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`).replace(/^-/, "").replace(/^webkit-/, "-webkit-");
+        values[css] = v;
+      }
+      return { offset: k.computedOffset, easing: k.easing ?? "linear", values };
+    });
+    const timing = effect.getTiming();
+    const duration = typeof timing.duration === "number" ? timing.duration : 0;
+    const delay = timing.delay ?? 0;
+    let entry;
+    if (kind === "CSSTransition") {
+      const property = a.transitionProperty;
+      entry = {
+        property,
+        duration,
+        delay,
+        easing: timing.easing ?? "linear",
+        from: keyframes[0]?.values[property] ?? "",
+        to: keyframes.at(-1)?.values[property] ?? ""
+      };
+    } else {
+      const anim = {
+        name: a.animationName,
+        duration,
+        delay,
+        iterations: timing.iterations === Infinity ? "infinite" : timing.iterations ?? 1,
+        direction: timing.direction ?? "normal",
+        fill: !timing.fill || timing.fill === "auto" ? "none" : timing.fill,
+        keyframes
+      };
+      if (pseudo === "::before" || pseudo === "::after")
+        anim.pseudo = pseudo;
+      if (effect.composite !== "replace")
+        anim.composite = effect.composite;
+      const timeline = a.timeline;
+      if (timeline === null)
+        anim.timeline = "none";
+      else if (timeline.constructor.name !== "DocumentTimeline")
+        anim.timeline = timeline.constructor.name;
+      entry = anim;
+    }
+    if (arg.targets) {
+      if (target === arg.targets[slot])
+        out.byTarget[slot].push(entry);
+      else
+        inner[slot].set(target, [...inner[slot].get(target) ?? [], entry]);
+    } else {
+      let path = "";
+      for (let el = target;el !== root; el = el.parentElement) {
+        const i = Array.prototype.indexOf.call(el.parentElement.children, el);
+        path = path ? `${i}/${path}` : String(i);
+      }
+      (out.byPath[path + (pseudo ?? "")] ??= []).push(entry);
+    }
+    if (arg.finish) {
+      try {
+        a.finish();
+      } catch {
+        a.cancel();
+      }
+    }
+  }
+  inner.forEach((m, slot) => {
+    if (out.byTarget[slot].length || !m.size)
+      return;
+    if (m.size === 1)
+      out.byTarget[slot] = [...m.values()][0];
+    else
+      out.ambiguous.push(slot);
+  });
+  return out;
+};
+var scanSheets = () => {
+  const out = { startingStyle: 0, authorReduce: false };
+  const walk = (rules) => {
+    for (const r of rules) {
+      if (r.constructor.name === "CSSStartingStyleRule")
+        out.startingStyle++;
+      if (r instanceof CSSMediaRule && r.conditionText.includes("prefers-reduced-motion"))
+        out.authorReduce = true;
+      if (r instanceof CSSImportRule && r.styleSheet)
+        read(r.styleSheet);
+      if ("cssRules" in r)
+        walk(r.cssRules);
+    }
+  };
+  const read = (sheet) => {
+    let rules;
+    try {
+      rules = sheet.cssRules;
+    } catch {
+      return;
+    }
+    walk(rules);
+  };
+  for (const sheet of document.styleSheets)
+    read(sheet);
+  return out;
+};
+async function readMotion(page, root) {
+  const reduce = await page.evaluate(collect, { root, kind: "CSSAnimation", finish: false });
+  await page.emulateMedia({ reducedMotion: "no-preference" });
+  const normal = await page.evaluate(collect, { root, kind: "CSSAnimation", finish: false });
+  await page.emulateMedia({ reducedMotion: "reduce" });
+  const { startingStyle, authorReduce } = await page.evaluate(scanSheets);
+  const motion = {};
+  for (const path of new Set([...Object.keys(normal.byPath), ...Object.keys(reduce.byPath)])) {
+    const animations = normal.byPath[path] ?? [];
+    const reduced = reduce.byPath[path] ?? [];
+    const m = {};
+    if (animations.length)
+      m.animations = animations;
+    if (authorReduce || JSON.stringify(reduced) !== JSON.stringify(animations))
+      m.reduced = reduced;
+    if (m.animations || m.reduced)
+      motion[path] = m;
+  }
+  const paused = Math.max(reduce.paused, normal.paused);
+  const warnings = [];
+  if (reduce.script)
+    warnings.push(`${reduce.script} script animation(s) (Element.animate) are not translated`);
+  if (paused)
+    warnings.push(`${paused} paused animation(s) are captured at their settled look`);
+  if (startingStyle)
+    warnings.push(`@starting-style rules are not translated (${startingStyle})`);
+  return { motion, warnings, authorReduce };
+}
+async function readTransitions(page, root) {
+  const { byPath } = await page.evaluate(collect, { root, kind: "CSSTransition", finish: true });
+  return byPath;
+}
+async function recordAnimations(page) {
+  await page.evaluate(() => {
+    const fresh = !window.__markswiftStarted;
+    window.__markswiftStarted = [];
+    if (!fresh)
+      return;
+    const add = (anims) => {
+      const list = window.__markswiftStarted;
+      for (const a of anims)
+        if (!list.includes(a))
+          list.push(a);
+    };
+    new MutationObserver(() => add(document.getAnimations().filter((a) => a instanceof CSSAnimation))).observe(document, { subtree: true, childList: true, attributes: true });
+    document.addEventListener("animationstart", (e) => add(e.target.getAnimations()), true);
+  });
+}
+async function readElementAnimations(page, targets) {
+  await page.emulateMedia({ reducedMotion: "no-preference" });
+  const { byTarget, ambiguous } = await page.evaluate(collect, {
+    targets,
+    kind: "CSSAnimation",
+    finish: false
+  });
+  await page.emulateMedia({ reducedMotion: "reduce" });
+  return {
+    lists: byTarget,
+    warnings: ambiguous.map((i) => `layer root ${i} has no animation of its own and several animated descendants; its enter/exit is not read`)
+  };
+}
+
+// src/browser/conditions.ts
+async function readConditionalRules(page, selector, viewportWidth, breakpoints = false) {
+  const { rules, found } = await page.evaluate(({ selector, mark, conditionalMark, containerMark }) => {
+    const found = [];
+    const root = document.querySelector(selector);
+    if (!root)
+      return { rules: [], found };
+    const SIZE = /\b(width|height|aspect-ratio|orientation|inline-size|block-size)\b/;
+    const VALIDATION = /:(user-)?(in)?valid\b/;
+    const PSEUDO_ELEMENT = /::?(before|after|marker|placeholder|selection|first-line|first-letter|backdrop|file-selector-button)\b/g;
+    const matching = (sel) => {
+      const plain = sel.replace(PSEUDO_ELEMENT, "");
+      try {
+        return [...root.matches(plain) ? [root] : [], ...root.querySelectorAll(plain)];
+      } catch {
+        return [];
+      }
+    };
+    const hits = (sel) => matching(sel).length > 0;
+    const index = new Map;
+    const containers = new Map;
+    const containerOf = (el, name) => {
+      for (let a = el.parentElement;a && root.contains(a); a = a.parentElement) {
+        const cs = getComputedStyle(a);
+        if (cs.containerType !== "normal" && (!name || cs.containerName.split(/\s+/).includes(name)))
+          return a;
+      }
+      return;
+    };
+    const stamp = (cond, sel) => {
+      for (const el of matching(sel)) {
+        let key = `media\x00${cond.query}`;
+        let entry = { kind: "media", query: cond.query };
+        if (cond.kind === "container") {
+          const host = containerOf(el, cond.name);
+          if (!host)
+            continue;
+          let serial = containers.get(host);
+          if (serial === undefined) {
+            serial = containers.size;
+            containers.set(host, serial);
+            host.setAttribute(containerMark, String(serial));
+          }
+          key = `container\x00${cond.query}\x00${serial}`;
+          entry = { kind: "container", query: cond.query, container: serial };
+        } else
+          entry.matches = window.matchMedia(cond.query).matches;
+        let i = index.get(key);
+        if (i === undefined) {
+          i = found.push(entry) - 1;
+          index.set(key, i);
+        }
+        const marks = (el.getAttribute(conditionalMark) ?? "").split(" ").filter(Boolean);
+        if (!marks.includes(String(i)))
+          el.setAttribute(conditionalMark, [...marks, i].join(" "));
+      }
+    };
+    const conditions = new Map;
+    const walk = (rules, parent, condition) => {
+      for (const rule of Array.from(rules)) {
+        let sel = parent;
+        let cond = condition;
+        if (rule instanceof CSSStyleRule) {
+          sel = parent === undefined ? rule.selectorText : rule.selectorText.includes("&") ? rule.selectorText.replaceAll("&", `:is(${parent})`) : `:is(${parent}) ${rule.selectorText}`;
+          if (cond && hits(sel)) {
+            conditions.get(cond.key).selectors.add(rule.selectorText);
+            stamp(cond, sel);
+          }
+          if (VALIDATION.test(sel))
+            for (const el of [root, ...root.querySelectorAll("*")])
+              try {
+                if (el.matches(sel))
+                  el.setAttribute(mark, "");
+              } catch {}
+        } else if ((rule instanceof CSSMediaRule || rule instanceof CSSContainerRule) && SIZE.test(rule.conditionText)) {
+          cond = rule instanceof CSSMediaRule ? { key: `@media ${rule.conditionText}`, kind: "media", query: rule.conditionText, name: "" } : {
+            key: `@container ${rule.conditionText}`,
+            kind: "container",
+            query: rule.containerQuery,
+            name: rule.containerName
+          };
+          if (!conditions.has(cond.key))
+            conditions.set(cond.key, { query: cond.query, selectors: new Set });
+          if (parent && hits(parent)) {
+            conditions.get(cond.key).selectors.add(parent);
+            stamp(cond, parent);
+          }
+        }
+        if ("cssRules" in rule)
+          walk(rule.cssRules, sel, cond);
+      }
+    };
+    for (const sheet of Array.from(document.styleSheets)) {
+      try {
+        walk(sheet.cssRules, undefined, undefined);
+      } catch {}
+    }
+    return {
+      rules: [...conditions].map(([condition, c]) => ({ condition, query: c.query, selectors: [...c.selectors] })),
+      found
+    };
+  }, { selector, mark: VALIDATION_MARK, conditionalMark: CONDITIONAL_MARK, containerMark: CONTAINER_MARK });
+  const warnings = rules.filter((c) => c.selectors.length && !(breakpoints && widthQuery(c.query))).map(({ condition, selectors }) => ({
+    source: "capture",
+    level: "approximated",
+    feature: condition.startsWith("@container") ? "container-query" : "media-query",
+    message: `${condition} restyles ${selectors.length} rule(s) matching captured elements (${selectors.slice(0, 5).join(", ")}${selectors.length > 5 ? ", …" : ""}); the view keeps the layout captured at a ${viewportWidth}px viewport and does not switch`
+  }));
+  return { warnings, found };
+}
+function applyConditionMarks(root, found) {
+  const hosts = new Map;
+  const visit = (n) => {
+    const marks = n.attrs[CONDITIONAL_MARK];
+    if (marks !== undefined) {
+      n.conditional = [...new Set(marks.split(" ").filter(Boolean).map(Number))].sort((a, b) => a - b);
+      delete n.attrs[CONDITIONAL_MARK];
+    }
+    const serial = n.attrs[CONTAINER_MARK];
+    if (serial !== undefined) {
+      hosts.set(Number(serial), n);
+      delete n.attrs[CONTAINER_MARK];
+    }
+    n.children.forEach(visit);
+  };
+  visit(root);
+  return found.map((f) => {
+    if (f.kind === "media")
+      return { kind: "media", query: f.query, matches: f.matches ?? false };
+    const host = f.container === undefined ? undefined : hosts.get(f.container);
+    if (!host?.id)
+      return { kind: "container", query: f.query, matches: false };
+    const px = (p) => Number.parseFloat(host.styles[p] ?? "") || 0;
+    const content = host.bounds.w - px("padding-left") - px("padding-right") - px("border-left-width") - px("border-right-width");
+    const q = widthQuery(f.query);
+    return {
+      kind: "container",
+      query: f.query,
+      container: host.id,
+      matches: q !== undefined && matchesWidth(q, content)
+    };
+  });
+}
+
+// src/browser/images.ts
+function inlineCapturedImages(root, baseURL, images) {
+  const warnings = new Set;
+  const resolve = (source) => {
+    if (!source || source.startsWith("data:") || source.startsWith("#"))
+      return source;
+    let url;
+    try {
+      url = new URL(source, baseURL).href;
+    } catch {
+      url = source;
+    }
+    const bytes = images.get(url);
+    if (bytes)
+      return bytes;
+    warnings.add(`Image could not be embedded: ${url}; supply a data URL or a reachable image resource.`);
+    return url;
+  };
+  const visit = (node) => {
+    if (node.tag === "img") {
+      const source = node.currentSrc ?? node.attrs.src;
+      if (source)
+        node.currentSrc = resolve(source);
+    }
+    const attr = node.tag === "video" ? "poster" : node.tag === "input" && node.attrs.type?.toLowerCase() === "image" ? "src" : "";
+    if (node.attrs[attr])
+      node.attrs[attr] = resolve(node.attrs[attr]);
+    for (const property of ["background-image", "mask-image"]) {
+      const value = node.styles[property];
+      if (value)
+        node.styles[property] = value.replace(/url\(\s*(?:"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|([^)]*))\s*\)/g, (match, double, single, bare) => {
+          const source = (double ?? single ?? bare ?? "").trim();
+          if (source.startsWith("data:") || source.startsWith("#"))
+            return match;
+          return `url(${JSON.stringify(resolve(source))})`;
+        });
+    }
+    node.children.forEach(visit);
+  };
+  visit(root);
+  return [...warnings];
+}
+
+// src/browser/states.ts
+var PAINT_KEYS = [
+  "background-color",
+  "background-image",
+  "color",
+  "-webkit-text-fill-color",
+  "border-top-color",
+  "border-right-color",
+  "border-bottom-color",
+  "border-left-color",
+  "box-shadow",
+  "outline-color",
+  "outline-style",
+  "outline-width",
+  "outline-offset",
+  "opacity",
+  "transform",
+  "scale",
+  "translate",
+  "rotate",
+  "filter",
+  "text-decoration-color"
+];
+var WATCH = ["display", "visibility"];
+var STATE_ARGS = { computedStyles: [...PAINT_KEYS, ...WATCH], includeDOMRects: true };
+var KEEP = Object.fromEntries(STATE_ARGS.computedStyles.map((k) => [k, true]));
+async function forceStates(cdp, nodeIds, classes) {
+  await Promise.all(nodeIds.map((nodeId) => cdp.send("CSS.forcePseudoState", { nodeId, forcedPseudoClasses: classes })));
+}
+function decode(snap, names, byIndex) {
+  const doc = snap.documents[0];
+  const out = new Map;
+  doc.layout.nodeIndex.forEach((index, li) => {
+    const styles = {};
+    (doc.layout.styles[li] ?? []).forEach((v, k) => {
+      if (v >= 0 && KEEP[names[k]])
+        styles[names[k]] = snap.strings[v];
+    });
+    const key = byIndex ? index : doc.nodes.backendNodeId[index];
+    out.set(key, { index, styles, offset: doc.layout.offsetRects?.[li] });
+  });
+  return out;
+}
+function diffStates(rest, state, ignoreAutoOutline) {
+  const deltas = new Map;
+  const [r, s] = [rest.documents[0]?.nodes, state.documents[0]?.nodes];
+  if (!r || !s)
+    return { deltas, moved: 0, revealed: 0 };
+  const byIndex = !r.backendNodeId || !s.backendNodeId;
+  if (byIndex && r.nodeType.length !== s.nodeType.length)
+    return { deltas, moved: 0, revealed: 0 };
+  const before = decode(rest, STYLE_WHITELIST, byIndex);
+  const after = decode(state, STATE_ARGS.computedStyles, byIndex);
+  let moved = 0;
+  let revealed = 0;
+  for (const [key, b] of after) {
+    const a = before.get(key);
+    if (!a || WATCH.some((k) => a.styles[k] !== b.styles[k])) {
+      revealed++;
+      continue;
+    }
+    if (a.offset && b.offset && a.offset.some((v, i) => Math.abs(v - b.offset[i]) > 0.5)) {
+      moved++;
+      continue;
+    }
+    const outlineAuto = ignoreAutoOutline && b.styles["outline-style"] === "auto";
+    const changed = {};
+    for (const k of PAINT_KEYS) {
+      if (outlineAuto && k.startsWith("outline-"))
+        continue;
+      const v = b.styles[k];
+      if (v !== undefined && v !== a.styles[k])
+        changed[k] = v;
+    }
+    if (Object.keys(changed).length)
+      deltas.set(a.index, changed);
+  }
+  return { deltas, moved, revealed };
+}
+async function captureStates(cdp, root, rest, motion) {
+  const out = {
+    pressed: new Map,
+    focused: new Map,
+    transitions: {},
+    warnings: []
+  };
+  await cdp.send("DOM.enable");
+  let css = false;
+  try {
+    const { root: doc } = await cdp.send("DOM.getDocument", { depth: 0 });
+    const plan = [
+      ["pressed", PRESSABLE_SELECTOR, ["hover", "active"], ":active"],
+      ["focused", TEXT_ENTRY_SELECTOR, ["focus", "focus-visible"], ":focus-visible"]
+    ];
+    for (const [state, selector, classes, label] of plan) {
+      const { nodeIds } = await cdp.send("DOM.querySelectorAll", {
+        nodeId: doc.nodeId,
+        selector: `${root} :is(${selector}), ${root}:is(${selector})`
+      });
+      if (!nodeIds.length)
+        continue;
+      if (!css)
+        await cdp.send("CSS.enable");
+      css = true;
+      const snapshot = async () => {
+        const snap = await cdp.send("DOMSnapshot.captureSnapshot", STATE_ARGS);
+        const { deltas, moved, revealed } = diffStates(rest, snap, state === "focused");
+        out[state] = deltas;
+        if (moved > 0)
+          out.warnings.push(`${moved} element(s) change layout under ${label}; their ${state} paint is not reproduced`);
+        if (revealed > 0)
+          out.warnings.push(`${revealed} element(s) appear or disappear under ${label}; not reproduced`);
+      };
+      if (!motion) {
+        await forceStates(cdp, nodeIds, [...classes]);
+        try {
+          await snapshot();
+        } finally {
+          await forceStates(cdp, nodeIds, []);
+        }
+        continue;
+      }
+      const { page, sheet } = motion;
+      const passes = [];
+      for (const media of ["no-preference", "reduce"]) {
+        await page.emulateMedia({ reducedMotion: media });
+        await finishAnimations(page);
+        await sheet.evaluate((s) => {
+          s.disabled = true;
+        });
+        await forceStates(cdp, nodeIds, [...classes]);
+        let into = {};
+        let back = {};
+        try {
+          into = await readTransitions(page, motion.root);
+          if (media === "reduce")
+            await snapshot();
+        } finally {
+          await forceStates(cdp, nodeIds, []);
+          back = await readTransitions(page, motion.root);
+          await sheet.evaluate((s) => {
+            s.disabled = false;
+          });
+        }
+        passes.push({ into, back });
+      }
+      const [normal, reduce] = passes;
+      const paths = new Set([normal, reduce].flatMap((p) => [...Object.keys(p.into), ...Object.keys(p.back)]));
+      for (const path of paths) {
+        const pair = { in: normal.into[path] ?? [], out: normal.back[path] ?? [] };
+        const reduced = { in: reduce.into[path] ?? [], out: reduce.back[path] ?? [] };
+        const differs = JSON.stringify(reduced) !== JSON.stringify(pair);
+        (out.transitions[path] ??= {})[state] = motion.authorReduce || differs ? { ...pair, reduced } : pair;
+      }
+    }
+    if (motion)
+      await finishAnimations(motion.page);
+  } finally {
+    if (css)
+      await cdp.send("CSS.disable");
+    await cdp.send("DOM.disable");
+  }
+  return out;
+}
+
+// src/browser/layers.ts
+var LAYER_MARK = "data-markswift-layer-root";
+var MAX_TRIGGERS = 12;
+var MAX_DISMISS_BUTTONS = 8;
+var ROOTS_ARGS = { computedStyles: ["opacity"], includePaintOrder: true };
+var PRE_ARGS = { computedStyles: [...PAINT_KEYS] };
+var TRIGGER_RULES = {
+  "[popovertarget]": { activation: "click", relation: "popovertarget" },
+  "button[commandfor]:is([command=show-modal i], [command=show-popover i], [command=toggle-popover i])": {
+    activation: "click",
+    relation: "commandfor"
+  },
+  "[interestfor]": { activation: "hover", relation: "interestfor" },
+  "details:not([open]) > summary:first-of-type": { activation: "click", relation: "details" },
+  "[data-markswift-opens]": { activation: "hint" },
+  "[data-slot=tooltip-trigger], [data-slot=hover-card-trigger]": { activation: "hover", scripted: true },
+  "[data-slot=context-menu-trigger]": { activation: "contextmenu", scripted: true },
+  "[aria-haspopup]:not([aria-haspopup=false]), [aria-expanded=false]": { activation: "click", scripted: true }
+};
+function laidOut(snap) {
+  const { nodes, layout } = snap.documents[0];
+  const name = (i) => snap.strings[nodes.nodeName[i]];
+  const closed = new Map;
+  nodes.parentIndex.forEach((p, i) => {
+    if (name(i) === "DETAILS" && !nodes.attributes[i].some((s, k) => k % 2 === 0 && snap.strings[s] === "open"))
+      closed.set(i, undefined);
+    if (p >= 0 && closed.has(p) && closed.get(p) === undefined && name(i) === "SUMMARY")
+      closed.set(p, i);
+  });
+  const hidden = (i) => {
+    for (let c = i, p = nodes.parentIndex[i];p >= 0; c = p, p = nodes.parentIndex[p])
+      if (closed.has(p) && closed.get(p) !== c)
+        return true;
+    return false;
+  };
+  return new Set(layout.nodeIndex.filter((i) => !hidden(i)).map((i) => nodes.backendNodeId[i]));
+}
+function layerRoots(before, snap, exclude) {
+  const { nodes, layout } = snap.documents[0];
+  const ids = nodes.backendNodeId;
+  const pseudo = new Set(nodes.pseudoType?.index);
+  const now = laidOut(snap);
+  const fresh = new Set;
+  const area = new Set;
+  const entry = new Map;
+  layout.nodeIndex.forEach((i, li) => {
+    if (now.has(ids[i]) && !before.has(ids[i]))
+      fresh.add(i);
+    if (!entry.has(i))
+      entry.set(i, li);
+    const [, , w, h] = layout.bounds[li];
+    if (w > 0 && h > 0)
+      for (let p = i;p >= 0 && !area.has(p); p = nodes.parentIndex[p])
+        area.add(p);
+  });
+  const paint = (i) => layout.paintOrders?.[entry.get(i)] ?? 0;
+  return [...fresh].filter((i) => nodes.nodeType[i] === 1 && !pseudo.has(i) && !fresh.has(nodes.parentIndex[i]) && !exclude.has(ids[i]) && area.has(i) && snap.strings[layout.styles[entry.get(i)]?.[0] ?? -1] !== "0").sort((a, b) => paint(a) - paint(b)).map((i) => ids[i]);
+}
+function outsidePoint(rects, viewport) {
+  const { width: w, height: h } = viewport;
+  return [
+    { x: 2, y: 2 },
+    { x: w - 2, y: 2 },
+    { x: 2, y: h - 2 },
+    { x: w - 2, y: h - 2 }
+  ].find((p) => !rects.some((r) => p.x >= r.x && p.x <= r.x + r.w && p.y >= r.y && p.y <= r.y + r.h));
+}
+function openDelta(rest, open) {
+  const keys = PAINT_KEYS.filter((k) => open[k] !== undefined && open[k] !== rest[k]);
+  return keys.length ? Object.fromEntries(keys.map((k) => [k, open[k]])) : undefined;
+}
+function layerIds(names) {
+  const used = new Set;
+  return names.map((name) => {
+    const words = name.normalize("NFKD").replace(/\p{M}/gu, "").toLowerCase().split(/[^a-z0-9]+/);
+    const base = words.filter(Boolean).slice(0, 4).join("-") || "layer";
+    let id = base;
+    for (let n = 2;used.has(id); n++)
+      id = `${base}-${n}`;
+    used.add(id);
+    return id;
+  });
+}
+async function findTriggers(page, root) {
+  const found = await page.evaluate(({ root, rules }) => {
+    const top = document.querySelector(root);
+    const scripted = document.scripts.length > 0 || [...document.querySelectorAll("*")].some((e) => [...e.attributes].some((a) => a.name.startsWith("on")));
+    const matched = [];
+    const triggers = [];
+    const warnings = [];
+    for (const el of top.querySelectorAll("*")) {
+      if (matched.some((m) => m.contains(el)))
+        continue;
+      const rule = rules.find(([sel, r]) => (!r.scripted || scripted) && el.matches(sel))?.[1];
+      if (!rule || !el.getClientRects().length)
+        continue;
+      if (el.matches(":disabled") || el.getAttribute("aria-disabled") === "true")
+        continue;
+      let activation = rule.activation;
+      if (activation === "hint") {
+        activation = el.getAttribute("data-markswift-opens") ?? "";
+        if (!["click", "hover", "contextmenu"].includes(activation)) {
+          warnings.push(`data-markswift-opens="${activation}" is not click, hover or contextmenu; the element is not opened`);
+          continue;
+        }
+      }
+      matched.push(el);
+      const steps = [];
+      for (let e = el;e !== top; e = e.parentElement)
+        steps.unshift([...e.parentElement.children].indexOf(e));
+      triggers.push({
+        path: steps.join("/"),
+        activation,
+        ...rule.relation ? { relation: rule.relation } : {},
+        name: el.getAttribute("aria-label")?.trim() || el.textContent?.trim() || el.getAttribute("title")?.trim() || ""
+      });
+    }
+    return { triggers, warnings };
+  }, { root, rules: Object.entries(TRIGGER_RULES) });
+  const ids = layerIds(found.triggers.map((t) => t.name));
+  return {
+    triggers: found.triggers.map(({ name: _, ...t }, i) => ({
+      ...t,
+      id: ids[i]
+    })),
+    warnings: found.warnings
+  };
+}
+async function activate(page, root, trigger) {
+  const at = await page.evaluate(({ root, path }) => {
+    let el = document.querySelector(root) ?? undefined;
+    for (const step of path ? path.split("/") : [])
+      el = el?.children[Number(step)];
+    if (!el)
+      return;
+    el.scrollIntoView({ block: "center", inline: "center" });
+    const r = el.getBoundingClientRect();
+    return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+  }, { root, path: trigger.path });
+  if (!at)
+    return false;
+  await recordAnimations(page);
+  if (trigger.activation === "hover") {
+    const mutated = await page.evaluateHandle(() => {
+      const { promise, resolve } = Promise.withResolvers();
+      const o = new MutationObserver(() => {
+        o.disconnect();
+        resolve();
+      });
+      o.observe(document, { subtree: true, childList: true, attributes: true, characterData: true });
+      setTimeout(resolve, 1000);
+      return { done: promise };
+    });
+    await page.mouse.move(at.x, at.y);
+    await mutated.evaluate((m) => m.done);
+    await mutated.dispose();
+  } else {
+    await page.mouse.click(at.x, at.y, { button: trigger.activation === "contextmenu" ? "right" : "left" });
+    await page.mouse.move(0, 0);
+  }
+  await page.evaluate(async () => {
+    const frame = Promise.withResolvers();
+    requestAnimationFrame(() => requestAnimationFrame(() => frame.resolve()));
+    await frame.promise;
+    scrollTo(0, 0);
+  });
+  return true;
+}
+var snapshot = async (cdp, args) => await cdp.send("DOMSnapshot.captureSnapshot", args);
+var rootHidden = (page, root) => page.evaluate((root) => !!document.querySelector(root)?.closest("[aria-hidden=true], [inert]"), root);
+async function openLayer(page, cdp, root, rootMark, trigger) {
+  const pre = await snapshot(cdp, PRE_ARGS);
+  const before = laidOut(pre);
+  const { nodes, layout } = pre.documents[0];
+  const rest = new Map(layout.nodeIndex.map((i, li) => [
+    nodes.backendNodeId[i],
+    Object.fromEntries(PAINT_KEYS.flatMap((k, s) => layout.styles[li][s] >= 0 ? [[k, pre.strings[layout.styles[li][s]]]] : []))
+  ]));
+  const hidden = await rootHidden(page, root);
+  if (!await activate(page, root, trigger))
+    return;
+  let open = await snapshot(cdp, ROOTS_ARGS);
+  const triggerRaw = rawAt(findByAttr(snapshotToTree(open), rootMark, "1"), trigger.path);
+  const exclude = new Set;
+  const collect = (r) => {
+    if (r.backend !== undefined)
+      exclude.add(r.backend);
+    r.children.forEach(collect);
+  };
+  if (triggerRaw)
+    collect(triggerRaw);
+  const mark = async (ids) => {
+    await page.evaluate((m) => {
+      for (const e of document.querySelectorAll(`[${m}]`))
+        e.removeAttribute(m);
+    }, LAYER_MARK);
+    await cdp.send("DOM.getDocument", { depth: 0 });
+    for (const [i, backendNodeId] of ids.entries()) {
+      const { object } = await cdp.send("DOM.resolveNode", { backendNodeId });
+      await cdp.send("Runtime.callFunctionOn", {
+        objectId: object.objectId,
+        functionDeclaration: "function (m, i) { this.setAttribute(m, i); }",
+        arguments: [{ value: LAYER_MARK }, { value: String(i) }]
+      });
+    }
+  };
+  const roots = layerRoots(before, open, exclude);
+  await mark(roots);
+  const isOpen = async () => {
+    open = await snapshot(cdp, ROOTS_ARGS);
+    return layerRoots(before, open, exclude).length > 0;
+  };
+  return {
+    rest,
+    hidden,
+    roots,
+    isOpen,
+    async reopen() {
+      if (!await isOpen()) {
+        await activate(page, root, trigger);
+        await settle(page);
+        open = await snapshot(cdp, ROOTS_ARGS);
+      }
+      await mark(layerRoots(before, open, exclude));
+    }
+  };
+}
+function dismissable(raw) {
+  if (!raw.bounds || raw.bounds.w <= 0 || raw.bounds.h <= 0)
+    return false;
+  const role = raw.attrs.role?.trim().toLowerCase() ?? "";
+  if (role === "button" || role === "option" || role.startsWith("menuitem"))
+    return true;
+  if (raw.name === "a")
+    return raw.attrs.href === undefined;
+  if (raw.name !== "button" || (raw.attrs.type?.toLowerCase() ?? "submit") !== "submit")
+    return raw.name === "button";
+  let form = raw.parent;
+  while (form && form.name !== "form")
+    form = form.parent;
+  return !form || form.attrs.method?.toLowerCase() === "dialog";
+}
+function dismissCandidates(roots, paths, identity) {
+  const out = [];
+  roots.forEach((root, i) => {
+    const walk = (raw, path) => {
+      const full = [paths[i], path].filter(Boolean).join("/");
+      if (dismissable(raw))
+        out.push({ root: i, path, id: identity(raw.name, raw.attrs, full) ?? full });
+      for (const [k, c] of pathChildren(raw).entries())
+        walk(c, path ? `${path}/${k}` : String(k));
+    };
+    walk(root, "");
+  });
+  return out.slice(0, MAX_DISMISS_BUTTONS);
+}
+function assembleLayer(o) {
+  const { trigger, marked } = o;
+  const inside = marked.map((raw) => pathOf(o.rootRaw, raw));
+  const paths = inside.map((p, i) => p ?? (i ? `${trigger.id}/${i}` : trigger.id));
+  const nodes = marked.map((raw, i) => toLayout(raw, o.origin, o.identity, paths[i]));
+  const any = (n, f) => f(n) || n.children.some((c) => any(c, f));
+  const fixed = (raw) => raw.styles.position === "fixed";
+  const placement = marked.every((raw, i) => inside[i] !== undefined && raw.styles.overlay !== "auto" && !fixed(raw)) ? "inflow" : o.info.some((r) => r.anchored) || marked.some((raw) => fixed(raw) && Math.abs(raw.bounds.x) < 0.5 && Math.abs(raw.bounds.y) < 0.5 && (raw.styles.transform !== "none" || raw.styles.translate !== "none")) ? "anchored" : "viewport";
+  const triggerAttrs = rawAt(o.rootRaw, trigger.path)?.attrs ?? {};
+  const inLayer = (attr) => {
+    const ids = new Set(triggerAttrs[attr]?.split(/\s+/).filter(Boolean));
+    return ids.size > 0 && nodes.some((n) => any(n, (d) => ids.has(d.attrs.id ?? "")));
+  };
+  const relation = trigger.relation ?? (inLayer("aria-controls") ? "aria-controls" : inLayer("aria-describedby") ? "aria-describedby" : "dom-diff");
+  const layer = {
+    id: trigger.id,
+    trigger: trigger.trigger,
+    activation: trigger.activation,
+    relation,
+    modal: o.info.some((r) => r.modal) || o.hiddenOnOpen || nodes.some((n) => any(n, (d) => d.attrs["aria-modal"] === "true")),
+    placement,
+    nodes,
+    dismiss: { escape: false, outside: false, buttons: [] }
+  };
+  if (placement === "inflow") {
+    const parent = (n) => n.children.some((c) => c.id === nodes[0].id) ? n : n.children.map(parent).find(Boolean);
+    const p = parent(o.root);
+    if (p?.id !== undefined) {
+      layer.parent = p.id;
+      layer.index = p.children.findIndex((c) => c.id === nodes[0].id);
+    }
+  }
+  return { layer, paths };
+}
+function triggerPaint(rest, rootRaw, trigger, identity) {
+  const paint = {};
+  let changed = 0;
+  const walk = (raw, path) => {
+    const before = raw.backend === undefined ? undefined : rest.get(raw.backend);
+    if (!before !== !raw.bounds)
+      changed++;
+    else if (before) {
+      const delta = openDelta(before, raw.styles);
+      const id = identity(raw.name, raw.attrs, path);
+      if (delta && id !== undefined)
+        paint[id] = delta;
+    }
+    for (const [k, c] of pathChildren(raw).entries())
+      walk(c, path ? `${path}/${k}` : String(k));
+  };
+  const raw = rawAt(rootRaw, trigger.path);
+  if (raw)
+    walk(raw, trigger.path);
+  return { paint, changed };
+}
+async function probeDismiss(page, opening, o) {
+  await opening.reopen();
+  const rects = await page.evaluate(({ mark, root, path, vw, vh }) => {
+    const box = (e) => {
+      const r = e.getBoundingClientRect();
+      return { x: r.x, y: r.y, w: r.width, h: r.height };
+    };
+    const rs = [...document.querySelectorAll(`[${mark}]`)].map(box).filter((r) => !(r.x <= 0 && r.y <= 0 && r.x + r.w >= vw && r.y + r.h >= vh));
+    let el = document.querySelector(root) ?? undefined;
+    for (const step of path ? path.split("/") : [])
+      el = el?.children[Number(step)];
+    return el ? [...rs, box(el)] : rs;
+  }, { mark: LAYER_MARK, root: o.root, path: o.trigger.path, vw: o.viewport.width, vh: o.viewport.height });
+  const at = outsidePoint(rects, o.viewport);
+  let outside = false;
+  if (at) {
+    await page.mouse.click(at.x, at.y);
+    await settle(page);
+    outside = !await opening.isOpen();
+  } else
+    o.warn(`layer ${o.trigger.id} covers every viewport corner; its outside-click dismissal was not probed`);
+  const buttons = [];
+  for (const c of o.candidates) {
+    await opening.reopen();
+    const point = await page.evaluate(({ sel, path }) => {
+      let el = document.querySelector(sel) ?? undefined;
+      for (const step of path ? path.split("/") : [])
+        el = el?.children[Number(step)];
+      if (!el)
+        return;
+      const r = el.getBoundingClientRect();
+      return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+    }, { sel: `[${LAYER_MARK}="${c.root}"]`, path: c.path });
+    if (!point)
+      continue;
+    await page.mouse.click(point.x, point.y);
+    await settle(page);
+    if (!await opening.isOpen())
+      buttons.push(c.id);
+  }
+  return { escape: o.escape, outside, buttons };
+}
+async function captureLayers(capture, spec, rest, { probeDismiss }) {
+  const triggers = rest.triggers ?? [];
+  const warn = (message) => rest.warnings.push({ source: "capture", message });
+  if (triggers.length > MAX_TRIGGERS) {
+    const skipped = triggers.slice(MAX_TRIGGERS);
+    warn(`${skipped.length} open-state trigger(s) beyond the first ${MAX_TRIGGERS} were not captured: ${skipped.slice(0, 5).map((t) => t.id).join(", ")}${skipped.length > 5 ? ", …" : ""}`);
+  }
+  const byId = new Map;
+  const index = (n) => {
+    if (n.id !== undefined)
+      byId.set(n.id, n);
+    n.children.forEach(index);
+  };
+  index(rest.layout.root);
+  const layers = [];
+  const shots = {};
+  for (const trigger of triggers.slice(0, MAX_TRIGGERS)) {
+    const open = await capture({ ...spec, open: trigger, probeDismiss });
+    for (const w of open.warnings)
+      if (!rest.warnings.some((r) => r.message === w.message))
+        rest.warnings.push(w);
+    if (!open.opened)
+      continue;
+    layers.push(open.opened.layer);
+    shots[open.opened.layer.id] = { ...open.png ? { png: open.png } : {}, size: open.opened.size, trigger };
+    for (const [id, delta] of Object.entries(open.opened.openPaint)) {
+      const node = byId.get(id);
+      if (node)
+        node.states = { ...node.states, open: delta };
+    }
+  }
+  if (layers.length)
+    rest.layout.layers = layers;
+  return shots;
+}
+
+// src/browser/capture.ts
+var ROOT_MARK = "data-markswift-root-capture";
+var TRANSFORMED_MARK = "data-markswift-transformed";
+var RELATIVE_MARK = "data-markswift-relative";
+var NO_TRANSFORM = "transform: none !important; translate: none !important; rotate: none !important; scale: none !important;";
+var requestURLs = (r) => {
+  const urls = [r.url()];
+  for (let q = r.request().redirectedFrom();q; q = q.redirectedFrom())
+    urls.push(q.url());
+  return urls;
+};
+var UNCOMPILED_TAILWIND = /@tailwind\s+(base|components|utilities|variants)\b|@import\s+(url\(\s*)?["']tailwindcss["']|@apply\s/;
+function sniffImage(b) {
+  if (b[0] === 137 && b.toString("latin1", 1, 4) === "PNG")
+    return "image/png";
+  if (b[0] === 255 && b[1] === 216 && b[2] === 255)
+    return "image/jpeg";
+  if (b.toString("latin1", 0, 4) === "GIF8")
+    return "image/gif";
+  if (b.toString("latin1", 0, 4) === "RIFF" && b.toString("latin1", 8, 12) === "WEBP")
+    return "image/webp";
+  return;
+}
+async function markTransformed(page) {
+  await page.evaluate(([transformed, relative]) => {
+    for (const el of document.querySelectorAll("*")) {
+      const cs = getComputedStyle(el);
+      if (cs.transform !== "none" || cs.translate !== "none" || cs.rotate !== "none" || cs.scale !== "none")
+        el.setAttribute(transformed, "");
+      if (cs.position === "relative")
+        el.setAttribute(relative, "");
+    }
+  }, [TRANSFORMED_MARK, RELATIVE_MARK]);
+}
+async function cancelAncestorTransforms(page) {
+  await page.evaluate((css) => {
+    const s = document.createElement("style");
+    s.textContent = css;
+    document.body.appendChild(s);
+  }, `:has([${ROOT_MARK}]) { ${NO_TRANSFORM} }
+[${TRANSFORMED_MARK}]:has([${ROOT_MARK}]) { will-change: transform !important; }
+[${RELATIVE_MARK}]:has([${ROOT_MARK}]) { inset: auto !important; }`);
+}
+async function noTransitions(page) {
+  const sheet = await page.addStyleTag({ content: "* { transition: none !important; }" });
+  await sheet.evaluate((s) => s.setAttribute("data-markswift-harness", ""));
+  return sheet;
+}
+
+class BrowserCapture {
+  browser;
+  context;
+  stopping;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async start() {
+    const args = this.opts.restricted ? ["--host-resolver-rules=MAP * ~NOTFOUND"] : [];
+    this.browser = await chromium.launch({ headless: true, channel: this.opts.channel ?? "chrome", args });
+    this.context = await this.browser.newContext({
+      viewport: this.opts.viewport,
+      deviceScaleFactor: this.opts.dpr,
+      reducedMotion: "reduce"
+    });
+  }
+  get version() {
+    return this.browser.version();
+  }
+  stop() {
+    if (!this.browser)
+      return Promise.resolve();
+    this.stopping ??= (async () => {
+      try {
+        await this.context?.close();
+      } finally {
+        await this.browser.close();
+      }
+    })();
+    return this.stopping;
+  }
+  async capture(spec, identity, source) {
+    const page = await this.context.newPage();
+    const viewport = spec.viewport ?? this.opts.viewport;
+    const errors = [];
+    const images = new Map;
+    const imageReads = [];
+    const sheets = new Map;
+    const sheetReads = [];
+    const favicon = (url) => url.endsWith("/favicon.ico");
+    page.on("pageerror", (e) => errors.push(String(e)));
+    page.on("console", (m) => {
+      if (m.type() === "error" && !favicon(m.location().url))
+        errors.push(m.text());
+    });
+    page.on("requestfailed", (r) => errors.push(`request failed: ${r.url()}`));
+    page.on("response", (r) => {
+      if (r.status() >= 400 && !favicon(r.url()))
+        errors.push(`${r.status()} ${r.url()}`);
+      const mime = r.headers()["content-type"]?.split(";")[0];
+      if (r.ok() && (mime?.startsWith("image/") || r.request().resourceType() === "image")) {
+        imageReads.push(r.body().then((bytes) => {
+          const type = mime?.startsWith("image/") ? mime : sniffImage(bytes);
+          if (!type) {
+            errors.push(`Image response is not an image: ${r.url()}`);
+            return;
+          }
+          for (const u of requestURLs(r))
+            images.set(u, `data:${type};base64,${bytes.toString("base64")}`);
+        }).catch(() => {
+          errors.push(`Could not capture image bytes: ${r.url()}`);
+        }));
+      }
+      if (r.ok() && r.request().resourceType() === "stylesheet") {
+        sheetReads.push(r.text().then((text) => {
+          for (const u of requestURLs(r))
+            sheets.set(u, text);
+        }).catch(() => {
+          errors.push(`Could not read stylesheet: ${r.url()}`);
+        }));
+      }
+    });
+    try {
+      await this.load(page, spec);
+      const noTransition = await noTransitions(page);
+      const motion = await readMotion(page, spec.root);
+      errors.push(...motion.warnings);
+      await settle(page);
+      const cdp = await this.context.newCDPSession(page);
+      await Promise.all(sheetReads);
+      const { faces: fonts, unreadable } = await collectFontFaces(page, Object.fromEntries(sheets));
+      for (const href of unreadable)
+        errors.push(`Stylesheet could not be read: ${href}; its @font-face rules were not collected.`);
+      const inlineStyles = await page.evaluate(() => [...document.querySelectorAll("style:not([data-markswift-harness])")].map((s) => s.textContent ?? ""));
+      const tailwind = new Set;
+      for (const text of inlineStyles)
+        if (UNCOMPILED_TAILWIND.test(text))
+          tailwind.add("inline <style>");
+      for (const [url, text] of sheets)
+        if (UNCOMPILED_TAILWIND.test(text))
+          tailwind.add(url);
+      for (const label of tailwind)
+        errors.push(`Stylesheet ${label} contains uncompiled Tailwind directives (@tailwind / @import "tailwindcss" / @apply); compile it first (for example with the Tailwind CLI) — the capture saw unstyled markup.`);
+      const fontFiles = await readFontBytes(fonts, !this.opts.restricted, this.opts.signal);
+      const canvas = await page.evaluate(({ sel, mark }) => {
+        const el = document.querySelector(sel);
+        if (!el)
+          throw new Error(`capture root ${sel} not found`);
+        el.setAttribute(mark, "1");
+        let canvas = "rgb(255, 255, 255)";
+        for (let p = el;p; p = p.parentElement) {
+          const bg = getComputedStyle(p).backgroundColor;
+          if (!bg || bg === "transparent" || bg === "none")
+            continue;
+          const legacy = /^rgba?\(([^)]+)\)$/.exec(bg);
+          const slash = /\/\s*([\d.]+)(%?)\s*\)\s*$/.exec(bg);
+          const alpha = legacy ? parseFloat((legacy[1].split(",")[3] ?? "1").trim()) : slash ? parseFloat(slash[1]) / (slash[2] ? 100 : 1) : 1;
+          if (alpha > 0.5) {
+            canvas = bg;
+            break;
+          }
+        }
+        return canvas;
+      }, { sel: spec.root, mark: ROOT_MARK });
+      const rootSel = `[${ROOT_MARK}="1"]`;
+      const found = spec.open ? undefined : await findTriggers(page, rootSel);
+      errors.push(...found?.warnings ?? []);
+      const opening = spec.open && await openLayer(page, cdp, rootSel, ROOT_MARK, spec.open);
+      if (spec.open && !opening)
+        errors.push(`trigger ${spec.open.id} is not in its open-state page; nothing opened`);
+      const roots = await Promise.all((opening ? opening.roots : []).map(async (_, i) => await page.$(`[${LAYER_MARK}="${i}"]`)));
+      const enter = roots.length ? await readElementAnimations(page, roots) : { lists: [], warnings: [] };
+      errors.push(...enter.warnings);
+      let animated = enter.lists.some((l) => l.length);
+      if (opening) {
+        await settle(page);
+        await page.evaluate(() => document.activeElement?.blur());
+        await settle(page);
+      }
+      const rootInfo = roots.length ? await page.evaluate((mark) => [...document.querySelectorAll(`[${mark}]`)].sort((a, b) => Number(a.getAttribute(mark)) - Number(b.getAttribute(mark))).map((el) => {
+        const cs = getComputedStyle(el);
+        return {
+          modal: el.matches(":modal"),
+          anchored: cs.getPropertyValue("position-area") !== "none" || cs.getPropertyValue("position-anchor") !== "normal"
+        };
+      }), LAYER_MARK) : [];
+      const hiddenOnOpen = !!opening && roots.length > 0 && !opening.hidden && await rootHidden(page, rootSel);
+      const conditional = await readConditionalRules(page, spec.root, viewport.width, spec.breakpoints);
+      const { sizes, pseudoStyles } = await readPreferredSizes(page, spec.root);
+      const layerSizes = await Promise.all(roots.map((_, i) => readPreferredSizes(page, `[${LAYER_MARK}="${i}"]`)));
+      const snapArgs = { computedStyles: [...STYLE_WHITELIST], includePaintOrder: true, includeDOMRects: true };
+      const snapA = await cdp.send("DOMSnapshot.captureSnapshot", snapArgs);
+      const states = await captureStates(cdp, spec.open ? `[${LAYER_MARK}]` : rootSel, snapA, spec.open ? undefined : { page, sheet: noTransition, root: spec.root, authorReduce: motion.authorReduce });
+      errors.push(...states.warnings);
+      await markTransformed(page);
+      await page.evaluate((css) => {
+        const s = document.createElement("style");
+        s.id = "__markswift_notransform";
+        s.textContent = css;
+        document.body.appendChild(s);
+      }, `* { ${NO_TRANSFORM} }
+[${TRANSFORMED_MARK}] { will-change: transform !important; }
+[${RELATIVE_MARK}] { inset: auto !important; }`);
+      const snapB = await cdp.send("DOMSnapshot.captureSnapshot", snapArgs);
+      await page.evaluate(() => document.getElementById("__markswift_notransform")?.remove());
+      const tree = snapshotToTree(snapA, snapB, states);
+      const rootRaw = findByAttr(tree, ROOT_MARK, "1");
+      if (!rootRaw)
+        throw new Error(`capture root ${spec.root} not in snapshot`);
+      attachPreferredSizes(rootRaw, sizes, pseudoStyles);
+      for (const [path, transitions] of Object.entries(states.transitions))
+        motion.motion[path] = { ...motion.motion[path], transitions };
+      attachMotion(rootRaw, motion.motion);
+      delete rootRaw.attrs[ROOT_MARK];
+      const box = rootRaw.bounds;
+      const root = box && toLayout(rootRaw, { x: box.x, y: box.y }, identity);
+      if (!box || !root)
+        throw new Error(`capture root ${spec.root} has no layout`);
+      const conditions = applyConditionMarks(root, conditional.found);
+      const size = { w: Math.floor(box.w), h: Math.floor(box.h) };
+      const triggers = found?.triggers.map((t) => {
+        const raw = rawAt(rootRaw, t.path);
+        return { ...t, trigger: identity(raw.name, raw.attrs, t.path) ?? t.path };
+      });
+      let opened;
+      let candidates = [];
+      if (spec.open && opening && roots.length) {
+        const marked = roots.map((_, i) => findByAttr(tree, LAYER_MARK, String(i)));
+        marked.forEach((raw, i) => {
+          delete raw.attrs[LAYER_MARK];
+          attachPreferredSizes(raw, layerSizes[i].sizes, layerSizes[i].pseudoStyles);
+        });
+        const { layer, paths } = assembleLayer({
+          trigger: spec.open,
+          rootRaw,
+          root,
+          marked,
+          origin: { x: box.x, y: box.y },
+          identity,
+          info: rootInfo,
+          hiddenOnOpen
+        });
+        enter.lists.forEach((list, i) => {
+          if (list.length)
+            layer.nodes[i].motion = { ...layer.nodes[i].motion, enter: list };
+        });
+        const { paint, changed } = triggerPaint(opening.rest, rootRaw, spec.open, identity);
+        if (changed)
+          errors.push(`${changed} element(s) inside trigger ${spec.open.id} appear or disappear while its layer is open; not reproduced`);
+        if (spec.probeDismiss && layer.placement !== "inflow")
+          candidates = dismissCandidates(marked, paths, identity);
+        opened = { layer, size, openPaint: paint };
+      }
+      let png;
+      if (spec.screenshot) {
+        const { x, y, w, h } = box;
+        if (!(size.w > 0 && size.h > 0) || x + w <= 0 || y + h <= 0)
+          throw new Error(`capture root ${spec.root} has an empty or off-page box (${w}×${h} at ${x},${y}); nothing to screenshot`);
+        await cancelAncestorTransforms(page);
+        png = await withFrozenProgress(page, cdp, (timeout) => page.screenshot({
+          clip: { x, y, width: size.w, height: size.h },
+          scale: "device",
+          animations: "disabled",
+          caret: "hide",
+          type: "png",
+          timeout
+        }));
+      }
+      const readExit = async (layer) => {
+        const exit = await readElementAnimations(page, roots);
+        errors.push(...exit.warnings);
+        exit.lists.forEach((list, i) => {
+          if (list.length)
+            layer.nodes[i].motion = { ...layer.nodes[i].motion, exit: list };
+        });
+        animated ||= exit.lists.some((l) => l.length);
+      };
+      if (opened && opening && spec.open && spec.probeDismiss && opened.layer.placement !== "inflow") {
+        await recordAnimations(page);
+        await page.keyboard.press("Escape");
+        await readExit(opened.layer);
+        await settle(page);
+        opened.layer.dismiss = await probeDismiss(page, opening, {
+          root: rootSel,
+          trigger: spec.open,
+          candidates,
+          viewport,
+          escape: !await opening.isOpen(),
+          warn: (message) => errors.push(message)
+        });
+      }
+      if (opened && spec.open && spec.probeDismiss && opened.layer.placement === "inflow") {
+        await activate(page, rootSel, spec.open);
+        await readExit(opened.layer);
+      }
+      if (animated && motion.authorReduce)
+        errors.push("overlay enter/exit animations follow the Reduce Motion fallback (author prefers-reduced-motion rules for them are not captured)");
+      await cdp.detach();
+      await Promise.all(imageReads);
+      const baseURI = await page.evaluate(() => document.baseURI);
+      for (const node of [root, ...opened?.layer.nodes ?? []])
+        errors.push(...inlineCapturedImages(node, baseURI, images));
+      return {
+        warnings: [...errors.map((message) => ({ source: "capture", message })), ...conditional.warnings],
+        layout: {
+          version: LAYOUT_DOC_VERSION,
+          source,
+          combo: { screen: spec.screen, theme: spec.theme },
+          size,
+          viewport: { x: -box.x || 0, y: -box.y || 0, w: viewport.width, h: viewport.height },
+          conditions,
+          dpr: this.opts.dpr,
+          canvas,
+          fonts,
+          root
+        },
+        png,
+        fontFiles,
+        ...triggers ? { triggers } : {},
+        ...opened ? { opened } : {}
+      };
+    } finally {
+      await page.close();
+    }
+  }
+  async load(page, spec) {
+    if (spec.viewport)
+      await page.setViewportSize(spec.viewport);
+    await page.emulateMedia({ colorScheme: spec.theme });
+    if (this.opts.restricted)
+      await page.route("**/*", (route) => route.abort("aborted"));
+    if (spec.html !== undefined) {
+      const documentURL = new URL(spec.url);
+      documentURL.hash = "";
+      await page.route((url) => url.href === documentURL.href, (route) => route.request().isNavigationRequest() ? route.fulfill({
+        contentType: "text/html; charset=utf-8",
+        body: spec.html,
+        ...this.opts.restricted ? {
+          headers: {
+            "Content-Security-Policy": "default-src 'none'; script-src 'none'; connect-src 'none'; style-src 'unsafe-inline'; img-src data:; font-src data:; frame-src 'none'"
+          }
+        } : {}
+      }) : this.opts.restricted ? route.abort() : route.continue());
+    }
+    await page.goto(spec.url, { waitUntil: "load" });
+    await page.waitForSelector(spec.waitFor ?? spec.root, { state: "attached", timeout: 15000 });
+    await spec.prepare?.(page);
+  }
+  async captureFrame(spec, frame, clip) {
+    const page = await this.context.newPage();
+    try {
+      if (!frame.reduced)
+        await page.emulateMedia({ reducedMotion: "no-preference" });
+      await this.load(page, spec);
+      await noTransitions(page);
+      if (!await settle(page, { at: frame.t }))
+        throw new Error(`${spec.screen}@t:${frame.t}: no animation to pause; the frame would be the settled look`);
+      await page.evaluate(({ sel, mark }) => document.querySelector(sel)?.setAttribute(mark, "1"), {
+        sel: spec.root,
+        mark: ROOT_MARK
+      });
+      await markTransformed(page);
+      await cancelAncestorTransforms(page);
+      return await withFrozenProgress(page, await this.context.newCDPSession(page), (timeout) => page.screenshot({ clip, scale: "device", animations: "allow", caret: "hide", type: "png", timeout }));
+    } finally {
+      await page.close();
+    }
+  }
+  async captureLayerFrame(spec, trigger, t, clip) {
+    const page = await this.context.newPage();
+    try {
+      await page.emulateMedia({ reducedMotion: "no-preference" });
+      await this.load(page, spec);
+      await noTransitions(page);
+      await settle(page);
+      await page.evaluate(({ sel, mark }) => document.querySelector(sel)?.setAttribute(mark, "1"), {
+        sel: spec.root,
+        mark: ROOT_MARK
+      });
+      const cdp = await this.context.newCDPSession(page);
+      const opening = await openLayer(page, cdp, `[${ROOT_MARK}="1"]`, ROOT_MARK, trigger);
+      await cdp.detach();
+      if (!opening?.roots.length)
+        throw new Error(`trigger ${trigger.id} opened nothing`);
+      await page.evaluate(() => document.activeElement?.blur());
+      if (!await settle(page, { at: t }))
+        throw new Error(`${spec.screen}@open:${trigger.id}@t:${t}: no animation to pause; the frame would be the settled look`);
+      await markTransformed(page);
+      await cancelAncestorTransforms(page);
+      return await withFrozenProgress(page, await this.context.newCDPSession(page), (timeout) => page.screenshot({ clip, scale: "device", animations: "allow", caret: "hide", type: "png", timeout }));
+    } finally {
+      await page.close();
+    }
+  }
+}
+
+// src/fonts/source.ts
+function coversLatin(range) {
+  if (!range)
+    return true;
+  for (const part of range.split(",")) {
+    const m = /u\+([0-9a-f?]+)(?:-([0-9a-f]+))?/i.exec(part.trim());
+    if (!m)
+      continue;
+    const lo = Number.parseInt(m[1].replace(/\?/g, "0"), 16);
+    const hi = m[2] ? Number.parseInt(m[2], 16) : Number.parseInt(m[1].replace(/\?/g, "f"), 16);
+    if (lo <= 65 && 65 <= hi)
+      return true;
+  }
+  return false;
+}
+function srcBytes(src, sources) {
+  const data = /^data:[^,]*;base64,(.*)$/s.exec(src.url);
+  if (data)
+    return Uint8Array.from(Buffer.from(data[1], "base64"));
+  if (src.url.startsWith("data:"))
+    return new TextEncoder().encode(decodeURIComponent(src.url.slice(src.url.indexOf(",") + 1)));
+  return src.file ? sources.get(src.file) : undefined;
+}
+var WEIGHT_SUBFAMILY = {
+  100: "Thin",
+  200: "ExtraLight",
+  300: "Light",
+  400: "Regular",
+  500: "Medium",
+  600: "SemiBold",
+  700: "Bold",
+  800: "ExtraBold",
+  900: "Black"
+};
+function sanitize(family) {
+  return family.replace(/[^A-Za-z0-9]/g, "") || "Font";
+}
+function fontFileStem(family, subfamily, claimed) {
+  const base = sanitize(family) + (subfamily === "Regular" ? "" : `-${subfamily.replace(/\s+/g, "")}`);
+  const owner = claimed.get(base.toLowerCase());
+  if (owner === undefined)
+    return base;
+  if (owner === family)
+    return;
+  for (let n = 2;; n++)
+    if (!claimed.has(`${base}-${n}`.toLowerCase()))
+      return `${base}-${n}`;
+}
+
+// src/fonts/converter.ts
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+// src/fonts/convert-font.py
+var convert_font_default = `import json, sys
+from fontTools.ttLib import TTFont
+
+src, dst, family, subfamily, want_rename = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4], sys.argv[5] == "1"
+# Converting the same font twice must not rewrite head.modified to the wall clock.
+font = TTFont(src, recalcTimestamp=False)
+flavor = font.flavor
+name = font["name"]
+names = {i: name.getDebugName(i) for i in (1, 2, 4, 6, 16, 17)}
+renamed = False
+# The registered name is the file's, not the CSS one: shadcn's 'Geist Variable' is a file whose
+# name table says 'Geist', so \`Font.custom("Geist Variable")\` would silently render in SF Pro.
+# Rewriting the name table here keeps the CSS family name the single name the whole pipeline
+# uses, instead of teaching the emitter a second naming convention. Stale records for the same
+# ids are dropped first so no platform-specific leftover can win the lookup.
+if want_rename and family not in {v for v in names.values() if v}:
+    ps = "".join(c for c in family if c.isalnum()) + ("-" + subfamily if subfamily != "Regular" else "")
+    full = family if subfamily == "Regular" else family + " " + subfamily
+    ids = (1, 2, 4, 6, 16, 17) if "fvar" in font else (1, 2, 4, 6)
+    name.names = [n for n in name.names if n.nameID not in ids]
+    for platform, encoding, lang in ((3, 1, 0x409), (1, 0, 0)):
+        name.setName(family, 1, platform, encoding, lang)
+        name.setName(subfamily, 2, platform, encoding, lang)
+        name.setName(full, 4, platform, encoding, lang)
+        name.setName(ps[:63], 6, platform, encoding, lang)
+        if "fvar" in font:
+            name.setName(family, 16, platform, encoding, lang)
+            name.setName(subfamily, 17, platform, encoding, lang)
+    renamed = True
+if flavor is not None:
+    font.flavor = None
+if renamed or flavor is not None:
+    font.save(dst)
+os2, hhea, head = font["OS/2"], font["hhea"], font["head"]
+typo = bool(os2.fsSelection & (1 << 7)) and os2.version >= 4
+print(json.dumps({
+    "upem": head.unitsPerEm,
+    "ascent": os2.sTypoAscender if typo else hhea.ascender,
+    "descent": abs(os2.sTypoDescender if typo else hhea.descender),
+    "lineGap": os2.sTypoLineGap if typo else hhea.lineGap,
+    "useTypoMetrics": typo,
+    "axes": {a.axisTag: [a.minValue, a.maxValue] for a in font["fvar"].axes} if "fvar" in font else {},
+    "converted": flavor is not None,
+    "renamed": renamed,
+    "wrote": renamed or flavor is not None,
+}))
+`;
+
+// src/fonts/converter.ts
+var run = promisify(execFile);
+var pythonFontConverter = async (bytes, family, subfamily, signal) => {
+  const dir = await mkdtemp(join(tmpdir(), "markswift-font-"));
+  try {
+    const src = join(dir, "src"), dst = join(dir, "dst"), py = join(dir, "convert-font.py");
+    await writeFile(src, bytes);
+    await writeFile(py, convert_font_default);
+    let out;
+    try {
+      ({ stdout: out } = await run("python3", [py, src, dst, family, subfamily, "1"], {
+        signal,
+        maxBuffer: 16 * 1024 * 1024
+      }));
+    } catch (error) {
+      const e = error;
+      if (e.code === "ENOENT")
+        return "python3 not found on PATH (webfont conversion needs Python 3 with fontTools and brotli)";
+      return (e.stderr?.trim().split(`
+`).pop() || `python3 failed: ${e.message}`).slice(0, 200);
+    }
+    let tool;
+    try {
+      tool = JSON.parse(out);
+    } catch {
+      return `unreadable fontTools output: ${out.slice(0, 120)}`;
+    }
+    const { wrote, ...result } = tool;
+    return wrote ? { ...result, bytes: new Uint8Array(await readFile(dst)) } : result;
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+};
+
+// src/fonts/registration.ts
+function plistFragment(files) {
+  if (!files.length)
+    return "";
+  return [
+    `<!-- ${GENERATED_BY} — merge into the app target's Info.plist. -->`,
+    "<key>UIAppFonts</key>",
+    "<array>",
+    ...files.map((f) => `    <string>Fonts/${f}</string>`),
+    "</array>",
+    ""
+  ].join(`
+`);
+}
+function registrationSwift(faces, owner) {
+  const pad = owner === undefined ? "" : "    ";
+  const entries = faces.map((f) => f.file).sort().map((f) => `${pad}        ${JSON.stringify(f)},`).join(`
+`);
+  const doc = faces.map((f) => `/// - ${f.family} (${f.file}): weight ${f.weight[0]}–${f.weight[1]}${f.axes["wght"] ? ", variable wght" : ""}${f.converted ? ", converted from WOFF2" : ""}${f.renamed ? ", name table rewritten so the CSS family name resolves" : ""}`).join(`
+`);
+  const register = `let urls = files.compactMap { bundle.url(forResource: "Fonts/" + $0, withExtension: nil) ?? bundle.url(forResource: $0, withExtension: nil) }
+var error: Unmanaged<CFError>?
+for url in urls {
+    // \`kCTFontManagerErrorAlreadyRegistered\` (105) is expected when \`UIAppFonts\`
+    // already loaded the file; every other failure would mean text renders in the
+    // system font, so it is surfaced instead of ignored.
+    if !CTFontManagerRegisterFontsForURL(url as CFURL, .process, &error), let taken = error?.takeRetainedValue() {
+        let code = CFErrorGetCode(taken)
+        if code != 105 { print("[markswift] font registration failed: \\(url.lastPathComponent) (\\(code))") }
+        error = nil
+    }
+}`.split(`
+`).map((line) => `${pad}        ${line}`).join(`
+`);
+  if (owner === undefined)
+    return `// ${GENERATED_BY} — bundled webfaces of this library.
+import CoreText
+import SwiftUI
+
+${doc}
+public enum BundledFonts {
+    /// File names under the \`Fonts/\` resource directory, in bundle order.
+    static let files: [String] = [
+${entries}
+    ]
+
+    /// Registers every bundled face with CoreText, once per process. Call once at app launch
+    /// (previews call it themselves).
+    public static func register() {
+        guard !registered else { return }
+        registered = true
+        let bundle = Bundle.module
+${register}
+    }
+
+    private nonisolated(unsafe) static var registered = false
+}
+`;
+  return `// ${GENERATED_BY} — bundled webfaces of ${owner}.
+import CoreText
+import SwiftUI
+
+${doc}
+extension ${owner} {
+    enum BundledFonts {
+        /// File names under the \`Fonts/\` resource directory, in bundle order.
+        static let files: [String] = [
+${entries}
+        ]
+
+        /// Registers every bundled face with CoreText, once per process. \`UIAppFonts\` covers the
+        /// app target; this covers previews, tests and any target that loads the views from a
+        /// package, where no \`Info.plist\` is read.
+        static func register(in bundle: Bundle = .main) {
+            guard !registered else { return }
+            registered = true
+${register}
+        }
+
+        private nonisolated(unsafe) static var registered = false
+    }
+}
+`;
+}
+
+// src/fonts/package.ts
+async function packageFonts(faces, sources, convert = pythonFontConverter, signal) {
+  const notes = [];
+  const note = (level, message) => notes.push({ source: "fonts", level, feature: "font-family", message });
+  const packaged = [];
+  const assets = {};
+  if (!faces.length)
+    return { faces: [], assets, plist: "", notes };
+  const groups = {};
+  for (const f of faces) {
+    const k = `${f.family}|${f.style}|${f.weight.join("-")}`;
+    (groups[k] ??= []).push(f);
+  }
+  const claimed = new Map;
+  for (const k of Object.keys(groups).sort()) {
+    const group = groups[k];
+    const latin = group.filter((f) => coversLatin(f.unicodeRange));
+    const chosen = (latin.length ? latin : group).find((f) => f.loaded) ?? (latin.length ? latin[0] : group[0]);
+    if (group.length > 1) {
+      note("approximated", `font-family ${chosen.family} ships ${group.length} unicode-range subsets at weight ${chosen.weight.join("–")}; bundled the one covering Basic Latin, ${group.length - 1} dropped (iOS has no per-codepoint fallback inside a family)`);
+    }
+    if (!latin.length)
+      note("unmapped", `font-family ${chosen.family} declares no face covering Basic Latin; bundled its first subset`);
+    let bytes;
+    let usedSrc;
+    for (const src of chosen.src) {
+      bytes = srcBytes(src, sources);
+      if (bytes?.length) {
+        usedSrc = src;
+        break;
+      }
+    }
+    if (!bytes?.length || !usedSrc) {
+      note("unmapped", `font-family ${chosen.family} has no readable src (${chosen.src.map((s) => s.url.slice(0, 60)).join(", ") || "none"}) → not bundled, text falls back to the system font`);
+      continue;
+    }
+    const sig = new TextDecoder("latin1").decode(bytes.subarray(0, 4));
+    const staticWeight = chosen.weight[0] === chosen.weight[1] ? chosen.weight[0] : undefined;
+    const weightName = staticWeight !== undefined && staticWeight !== 400 ? WEIGHT_SUBFAMILY[staticWeight] ?? `W${staticWeight}` : "";
+    const subfamily = [weightName, chosen.style === "normal" ? "" : "Italic"].filter(Boolean).join(" ") || "Regular";
+    const stem = fontFileStem(chosen.family, subfamily, claimed);
+    if (stem === undefined) {
+      note("approximated", `font-family ${chosen.family} declares another ${subfamily} face (${chosen.style}, weight ${chosen.weight.join("–")}); iOS registers one face per name, bundled the first`);
+      continue;
+    }
+    const file = `${stem}.${sig === "OTTO" ? "otf" : "ttf"}`;
+    const tool = await convert(bytes, chosen.family, subfamily, signal);
+    if (typeof tool === "string") {
+      const fmt = sig === "wOF2" ? "WOFF2" : sig === "wOFF" ? "WOFF" : "the source format";
+      note("unmapped", `font-family ${chosen.family} not bundled (${tool}); text falls back to the system font` + (sig === "wOF2" || sig === "wOFF" ? ` — iOS cannot register ${fmt}; converting it needs python3 with fontTools + brotli` : ""));
+      continue;
+    }
+    assets[`Fonts/${file}`] = tool.bytes ?? bytes;
+    const metrics = {
+      upem: tool.upem,
+      ascent: tool.ascent,
+      descent: tool.descent,
+      lineGap: tool.lineGap,
+      useTypoMetrics: tool.useTypoMetrics
+    };
+    packaged.push({
+      family: chosen.family,
+      file,
+      style: chosen.style,
+      weight: chosen.weight,
+      axes: tool.axes,
+      metrics,
+      converted: tool.converted,
+      renamed: tool.renamed
+    });
+    claimed.set(stem.toLowerCase(), chosen.family);
+    if (!chosen.loaded)
+      note("approximated", `font-family ${chosen.family} never loaded in the reference browser, so the reference pixels are a fallback face; bundled it anyway`);
+  }
+  for (const f of packaged) {
+    if (!f.axes["wght"] && f.weight[0] !== f.weight[1]) {
+      note("approximated", `font-family ${f.family} declares weight ${f.weight.join("–")} but the bundled file has no wght axis; weights other than ${f.weight[0]} are synthesised`);
+    }
+  }
+  const files = packaged.map((f) => f.file).sort();
+  return { faces: packaged, assets, plist: plistFragment(files), notes };
+}
+
+// src/fonts/metadata.ts
+function metricsForFonts(pkg) {
+  return Object.fromEntries(pkg.faces.map((face) => [face.family.toLowerCase(), { ...face.metrics }]));
+}
+function bundledFamilies(pkg) {
+  const out = {};
+  for (const f of pkg.faces) {
+    if (f.style !== "normal")
+      continue;
+    const prev = out[f.family];
+    const { wght: _w, opsz: _o, ...axes } = f.axes;
+    out[f.family] = {
+      weight: prev ? [Math.min(prev.weight[0], f.weight[0]), Math.max(prev.weight[1], f.weight[1])] : f.weight,
+      ...f.axes["wght"] ? { wght: f.axes["wght"] } : prev?.wght ? { wght: prev.wght } : {},
+      ...f.axes["opsz"] ? { opsz: f.axes["opsz"] } : prev?.opsz ? { opsz: prev.opsz } : {},
+      ...Object.keys(axes).length ? { axes } : prev?.axes ? { axes: prev.axes } : {}
+    };
+  }
+  return out;
+}
+
+// src/input/source.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { basename, dirname, resolve as resolve2 } from "node:path";
+async function resolveSource(source) {
+  if ("url" in source) {
+    const url = httpURL(source.url);
+    return { url, label: url, close() {} };
+  }
+  if ("file" in source) {
+    const file = resolve2(source.file);
+    const html = await readFile2(file, "utf8");
+    const server = await serveDir(dirname(file));
+    return {
+      html,
+      url: `${server.origin}/${encodeURIComponent(basename(file))}`,
+      label: basename(file),
+      close: () => server.stop()
+    };
+  }
+  if (source.baseURL && source.assetsDir)
+    throw new Error("choose baseURL or assetsDir, not both");
+  const server = source.assetsDir ? await serveDir(resolve2(source.assetsDir)) : undefined;
+  return {
+    html: source.html,
+    url: source.baseURL ? httpURL(source.baseURL) : `${server?.origin ?? "http://markswift.invalid"}/index.html`,
+    label: "inline.html",
+    close: () => server?.stop()
+  };
+}
+function httpURL(value) {
+  const url = new URL(value);
+  if (url.protocol !== "http:" && url.protocol !== "https:")
+    throw new Error("only http and https page URLs are supported");
+  return url.href;
+}
+
+// src/input/identity.ts
+var htmlIdentity = (_tag, attrs, path) => {
+  if (attrs.id)
+    return `#${attrs.id}`;
+  return attrs["data-markswift"] ?? attrs["data-testid"] ?? attrs["data-name"] ?? (path === "" ? "root" : path);
+};
+
+// src/api/bands.ts
+function validateBreakpoints(bp, prefix = "") {
+  if (bp !== undefined && bp !== true && (!(bp.devices ?? []).every((d) => [d.width, d.height].every((n) => Number.isInteger(n) && n > 0)) || bp.max !== undefined && !(Number.isInteger(bp.max) && bp.max >= 320)))
+    throw new Error(`${prefix}breakpoints devices must be positive integer sizes and max an integer ≥ 320`);
+}
+function planFor(bp, conditions, first) {
+  return planBands2(conditions, {
+    first,
+    devices: (bp === true ? undefined : bp.devices) ?? DEFAULT_BAND_DEVICES2,
+    max: (bp === true ? undefined : bp.max) ?? 1376
+  });
+}
+async function captureThemes(renderer, req, timedOut) {
+  const race = (spec) => Promise.race([renderer.capture(spec, htmlIdentity, req.label), timedOut]);
+  const shot = async (scheme, probeDismiss) => {
+    const spec = {
+      screen: req.name,
+      theme: scheme,
+      url: req.url,
+      html: req.html,
+      root: req.root,
+      waitFor: req.waitFor,
+      viewport: req.viewport,
+      ...req.breakpoints ? { breakpoints: true } : {},
+      async prepare(page) {
+        if (req.css)
+          await page.addStyleTag({ content: req.css });
+        if (scheme === "dark" && req.darkClass)
+          await page.evaluate((c) => document.documentElement.classList.add(c), req.darkClass);
+        await req.prepare?.(page);
+      }
+    };
+    const capture = await race(spec);
+    if (req.layers)
+      await captureLayers(race, spec, capture, { probeDismiss });
+    return capture;
+  };
+  const primary = await shot(req.theme === "dark" ? "dark" : "light", true);
+  if (req.theme !== "adaptive")
+    return { primary };
+  const dark = await shot("dark", false);
+  for (const layer of dark.layout.layers ?? []) {
+    const light = primary.layout.layers?.find((l) => l.id === layer.id);
+    if (light) {
+      layer.dismiss = light.dismiss;
+      layer.nodes.forEach((n, i) => {
+        const exit = light.nodes[i]?.motion?.exit;
+        if (exit)
+          n.motion = { ...n.motion, exit };
+      });
+    } else
+      dark.warnings.push({
+        source: "capture",
+        message: `layer ${layer.id} opens only in the dark theme; its dismissal was not probed`
+      });
+  }
+  return { primary, dark };
+}
+async function captureBands(renderer, req, first, plan, timedOut) {
+  const bands = [];
+  for (const [i, capture] of plan.captures.entries())
+    bands.push(capture.width === first.viewport.width && capture.height === first.viewport.height ? first.captured : await captureThemes(renderer, { ...req, viewport: capture, ...i > 0 ? { layers: false } : {} }, timedOut));
+  for (const viewport of plan.extra)
+    bands.push({ ...await captureThemes(renderer, { ...req, viewport, layers: false }, timedOut), extra: true });
+  return bands.sort((a, b) => a.primary.layout.viewport.w - b.primary.layout.viewport.w);
+}
+
+// src/api/convert.ts
+async function convert2(source, options = {}) {
+  validateName(options.name ?? "ConvertedView");
+  const viewport = options.viewport ?? { width: 390, height: 844 };
+  const dpr = options.dpr ?? 1;
+  if (![viewport.width, viewport.height].every((n) => Number.isInteger(n) && n > 0) || !Number.isFinite(dpr) || dpr <= 0) {
+    throw new Error("viewport dimensions must be positive integers and dpr must be positive and finite");
+  }
+  const bp = options.breakpoints;
+  validateBreakpoints(bp);
+  const timeoutMs = options.timeoutMs ?? 120000;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+    throw new Error("timeoutMs must be positive and finite");
+  if (["html", "file", "url"].filter((key) => (key in source)).length !== 1)
+    throw new Error("provide exactly one of html, file or url");
+  if (options.untrustedInput && (!("html" in source) || source.assetsDir || source.baseURL)) {
+    throw new Error("untrustedInput accepts pasted HTML without assetsDir or baseURL only");
+  }
+  const theme = options.theme ?? "adaptive";
+  if (theme !== "light" && theme !== "dark" && theme !== "adaptive")
+    throw new Error("theme must be light, dark or adaptive");
+  if (options.darkClass !== undefined && !/^\S+$/.test(options.darkClass))
+    throw new Error("darkClass must be a single class name");
+  let prepared;
+  const deadline = AbortSignal.timeout(timeoutMs);
+  const renderer = new BrowserCapture({
+    viewport,
+    dpr,
+    channel: options.browserChannel,
+    restricted: options.untrustedInput,
+    signal: deadline
+  });
+  const stopOnTimeout = () => void renderer.stop().catch(() => {});
+  deadline.addEventListener("abort", stopOnTimeout, { once: true });
+  const timedOut = new Promise((_, reject) => deadline.addEventListener("abort", () => reject(deadline.reason), { once: true }));
+  timedOut.catch(() => {});
+  try {
+    prepared = await resolveSource(source);
+    const { html, url, label } = prepared;
+    await renderer.start();
+    deadline.throwIfAborted();
+    const name = options.name ?? "ConvertedView";
+    const req = {
+      name,
+      url,
+      html,
+      label,
+      root: options.root ?? DEFAULT_ROOT,
+      theme,
+      css: options.css,
+      darkClass: options.darkClass,
+      waitFor: options.waitFor,
+      prepare: options.prepare,
+      ...bp ? { breakpoints: true } : {}
+    };
+    const layered = { ...req, layers: true };
+    const first = await captureThemes(renderer, layered, timedOut);
+    const plan = bp ? planFor(bp, first.primary.layout.conditions, viewport) : undefined;
+    const bands = plan ? await captureBands(renderer, layered, { viewport, captured: first }, plan, timedOut) : [first];
+    const { primary: capture, dark } = bands[0];
+    const probeWidth = plan ? plan.probes[0] : viewport.width > 320 ? 320 : 390;
+    const probe = options.probe !== false && probeWidth !== undefined && needsProbe2(capture.layout) ? (await captureThemes(renderer, {
+      ...req,
+      theme: capture.layout.combo.theme,
+      viewport: { width: probeWidth, height: plan?.captures[0]?.height ?? viewport.height }
+    }, timedOut)).primary.layout : undefined;
+    const variantProbes = [];
+    let band = 0;
+    for (let i = 1;i < bands.length; i++) {
+      const layout = bands[i].primary.layout;
+      const width = bands[i].extra ? undefined : plan.probes[++band];
+      const probed = options.probe !== false && width !== undefined && needsProbe2(layout) ? (await captureThemes(renderer, {
+        ...req,
+        theme: layout.combo.theme,
+        viewport: { width, height: plan.captures[band].height }
+      }, timedOut)).primary.layout : undefined;
+      variantProbes.push(probed && probed.size.w !== layout.size.w ? probed : undefined);
+    }
+    const captures = bands.flatMap((b) => b.dark ? [b.primary, b.dark] : [b.primary]);
+    const sources = new Map(captures.flatMap((c) => c.fontFiles).map((f) => [f.file, f.bytes]));
+    const fonts = await packageFonts(captures.length > 1 ? unionFaces(captures.map((c) => c.layout.fonts)) : capture.layout.fonts, sources, undefined, deadline);
+    deadline.throwIfAborted();
+    const compiled = compileLayout2(capture.layout, {
+      name,
+      mode: options.mode,
+      bundledFamilies: bundledFamilies(fonts),
+      fontMetrics: metricsForFonts(fonts),
+      dark: dark?.layout,
+      probe: probe && probe.size.w !== capture.layout.size.w ? probe : undefined,
+      palette: options.palette,
+      ...bands.length > 1 ? {
+        variants: bands.slice(1).map((b) => b.primary.layout),
+        ...dark ? { darkVariants: bands.slice(1).map((b) => b.dark.layout) } : {},
+        variantProbes
+      } : {}
+    });
+    const assets = { ...compiled.assets, ...fonts.assets };
+    if (fonts.faces.length) {
+      compiled.files[`${name}+Fonts.swift`] = registrationSwift(fonts.faces, name);
+      compiled.files[`${name}+UIAppFonts.plist.fragment`] = fonts.plist;
+    }
+    const pageWarnings = captures.length > 1 ? [...new Map(captures.flatMap((c) => c.warnings).map((w) => [w.message, w])).values()] : capture.warnings;
+    const notes = (plan?.notes ?? []).map((message) => ({
+      source: "capture",
+      level: "approximated",
+      feature: "media-query",
+      message
+    }));
+    return {
+      ...compiled,
+      assets,
+      warnings: [...pageWarnings, ...notes, ...fonts.notes, ...compiled.warnings],
+      layout: capture.layout,
+      ...dark ? { darkLayout: dark.layout } : {},
+      ...plan ? {
+        bands: bands.map((b) => ({
+          layout: b.primary.layout,
+          ...b.dark ? { darkLayout: b.dark.layout } : {}
+        }))
+      } : {}
+    };
+  } catch (error) {
+    if (deadline.aborted)
+      throw new Error(`conversion timed out after ${timeoutMs} ms`, { cause: error });
+    throw error;
+  } finally {
+    deadline.removeEventListener("abort", stopOnTimeout);
+    try {
+      await renderer.stop();
+    } finally {
+      prepared?.close();
+    }
+  }
+}
+function unionFaces(lists) {
+  const key = ({ loaded: _, ...face }) => JSON.stringify(face);
+  const faces = new Map;
+  for (const list of lists)
+    for (const f of list) {
+      const cur = faces.get(key(f));
+      if (!cur)
+        faces.set(key(f), f);
+      else if (f.loaded && !cur.loaded)
+        faces.set(key(f), { ...cur, loaded: true });
+    }
+  return [...faces.values()];
+}
+function convertHtml2(html, options = {}) {
+  return convert2({ html }, options);
+}
+
+// src/api/build.ts
+var RUNTIME_BUNDLE = "static var bundle: Bundle = .main";
+async function buildLibrary2(options) {
+  const { library, components } = options;
+  validateLibrary2(library, components.map((c) => c.name));
+  const timeoutMs = options.timeoutMs ?? 600000;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+    throw new Error("timeoutMs must be positive and finite");
+  const serveRoot = options.serveRoot === undefined ? undefined : resolve3(options.serveRoot);
+  for (const c of components) {
+    const { width, height } = c.viewport ?? { width: 390, height: 844 };
+    if (![width, height].every((n) => Number.isInteger(n) && n > 0))
+      throw new Error(`component ${c.name}: viewport dimensions must be positive integers`);
+    if (c.darkClass !== undefined && !/^\S+$/.test(c.darkClass))
+      throw new Error(`component ${c.name}: darkClass must be a single class name`);
+    validateBreakpoints(c.breakpoints, `component ${c.name}: `);
+    if ("url" in c.source) {
+      const protocol = URL.canParse(c.source.url) ? new URL(c.source.url).protocol : "";
+      if (protocol !== "http:" && protocol !== "https:")
+        throw new Error(`component ${c.name}: only http and https page URLs are supported`);
+    } else if (!serveRoot)
+      throw new Error(`component ${c.name}: a file source needs serveRoot`);
+    else if (!resolve3(serveRoot, c.source.file).startsWith(serveRoot + sep))
+      throw new Error(`component ${c.name}: ${c.source.file} is outside serveRoot ${serveRoot}`);
+  }
+  const deadline = AbortSignal.timeout(timeoutMs);
+  const renderers = new Map;
+  const stopAll = () => Promise.allSettled([...renderers.values()].map((r) => r.started.finally(() => r.capture.stop())));
+  const stopOnTimeout = () => void stopAll();
+  deadline.addEventListener("abort", stopOnTimeout, { once: true });
+  const timedOut = new Promise((_, reject) => deadline.addEventListener("abort", () => reject(deadline.reason), { once: true }));
+  timedOut.catch(() => {});
+  let server;
+  try {
+    if (components.some((c) => ("file" in c.source)))
+      server = await serveDir(serveRoot);
+    const captureOne = async (c) => {
+      const viewport = c.viewport ?? { width: 390, height: 844 };
+      const key = `${viewport.width}x${viewport.height}`;
+      let renderer = renderers.get(key);
+      if (!renderer) {
+        const capture = new BrowserCapture({ viewport, dpr: 1, signal: deadline });
+        renderer = { capture, started: capture.start() };
+        renderers.set(key, renderer);
+      }
+      await Promise.race([renderer.started, timedOut]);
+      deadline.throwIfAborted();
+      let page;
+      if ("url" in c.source)
+        page = { url: c.source.url, label: c.source.url };
+      else {
+        const path = relative(serveRoot, resolve3(serveRoot, c.source.file));
+        page = {
+          url: `${server.origin}/${path.split(sep).map(encodeURIComponent).join("/")}`,
+          html: await readFile3(resolve3(serveRoot, c.source.file), "utf8"),
+          label: path.split(sep).join("/")
+        };
+      }
+      const req = {
+        name: c.name,
+        ...page,
+        root: c.root ?? DEFAULT_ROOT,
+        theme: c.theme ?? "adaptive",
+        css: c.css,
+        darkClass: c.darkClass,
+        waitFor: c.waitFor,
+        layers: true,
+        ...c.breakpoints ? { breakpoints: true } : {}
+      };
+      const first = await captureThemes(renderer.capture, req, timedOut);
+      if (!c.breakpoints)
+        return { bands: [first], notes: [] };
+      const plan = planFor(c.breakpoints, first.primary.layout.conditions, viewport);
+      const bands = await captureBands(renderer.capture, req, { viewport, captured: first }, plan, timedOut);
+      return { bands, notes: plan.notes };
+    };
+    const captured = [];
+    let next = 0;
+    const worker = async () => {
+      for (let i = next++;i < components.length; i = next++)
+        captured[i] = await captureOne(components[i]);
+    };
+    await Promise.all(Array.from({ length: Math.min(4, components.length) }, worker));
+    const all = captured.flatMap((c) => c.bands.flatMap((b) => b.dark ? [b.primary, b.dark] : [b.primary]));
+    const fonts = await packageFonts(unionFaces(all.map((c) => c.layout.fonts)), new Map(all.flatMap((c) => c.fontFiles).map((f) => [f.file, f.bytes])), undefined, deadline);
+    deadline.throwIfAborted();
+    const compiled = compileLayouts2(components.map((c, i) => {
+      const [first, ...rest] = captured[i].bands;
+      return {
+        name: c.name,
+        layout: first.primary.layout,
+        dark: first.dark?.layout,
+        mode: c.mode,
+        ...rest.length ? {
+          variants: rest.map((b) => b.primary.layout),
+          ...first.dark ? { darkVariants: rest.map((b) => b.dark.layout) } : {}
+        } : {}
+      };
+    }), {
+      library,
+      bundledFamilies: bundledFamilies(fonts),
+      fontMetrics: metricsForFonts(fonts),
+      registerFonts: fonts.faces.length > 0,
+      palette: options.palette
+    });
+    const dir = `Sources/${library}/`;
+    const files = {};
+    const assets = {};
+    for (const [name, text] of Object.entries(compiled.files))
+      files[dir + name] = text;
+    if (fonts.faces.length)
+      files[`${dir}MarkswiftFonts.swift`] = registrationSwift(fonts.faces);
+    for (const [name, bytes] of Object.entries({ ...compiled.assets, ...fonts.assets }))
+      assets[dir + name] = bytes;
+    const resources = ["Fonts", "Images"].filter((d) => Object.keys(assets).some((k) => k.startsWith(`${dir}${d}/`)));
+    if (resources.length) {
+      const runtime = files[`${dir}MarkswiftRuntime.swift`].split(RUNTIME_BUNDLE);
+      if (runtime.length !== 2)
+        throw new Error(`MarkswiftRuntime.swift must contain "${RUNTIME_BUNDLE}" exactly once`);
+      files[`${dir}MarkswiftRuntime.swift`] = runtime.join("static var bundle: Bundle = .module");
+    }
+    files["Package.swift"] = [
+      "// swift-tools-version: 6.2",
+      `// ${GENERATED_BY} — tool-owned: regenerate with \`markswift build\`.`,
+      "import PackageDescription",
+      "",
+      "let package = Package(",
+      `    name: "${library}",`,
+      "    platforms: [.iOS(.v18), .macOS(.v15)],",
+      `    products: [.library(name: "${library}", targets: ["${library}"])],`,
+      "    targets: [",
+      "        .target(",
+      `            name: "${library}",`,
+      ...resources.length ? [`            resources: [${resources.map((d) => `.copy("${d}")`).join(", ")}],`] : [],
+      "            swiftSettings: [.defaultIsolation(MainActor.self)]",
+      "        ),",
+      "    ]",
+      ")",
+      ""
+    ].join(`
+`);
+    const warnings = new Map;
+    const add = (w) => {
+      const key = `${w.component ?? ""}\x00${w.source}\x00${w.message}`;
+      if (!warnings.has(key))
+        warnings.set(key, w);
+    };
+    for (const [i, c] of components.entries()) {
+      const { bands, notes } = captured[i];
+      for (const w of bands.flatMap((b) => [...b.primary.warnings, ...b.dark?.warnings ?? []]))
+        add({ ...w, component: c.name });
+      for (const message of notes)
+        add({ source: "capture", level: "approximated", feature: "media-query", component: c.name, message });
+      for (const w of compiled.warnings)
+        if (w.component === c.name)
+          add(w);
+    }
+    for (const w of compiled.warnings)
+      if (w.component === undefined)
+        add(w);
+    for (const w of fonts.notes)
+      add(w);
+    return { files, assets, warnings: [...warnings.values()], diagnostics: compiled.diagnostics };
+  } catch (error) {
+    if (deadline.aborted)
+      throw new Error(`build timed out after ${timeoutMs} ms`, { cause: error });
+    throw error;
+  } finally {
+    deadline.removeEventListener("abort", stopOnTimeout);
+    try {
+      await stopAll();
+    } finally {
+      server?.stop();
+    }
+  }
+}
+
+export { mimeType, convert2, convertHtml2, buildLibrary2 };