youiyoux 0.1.0 → 0.1.3

package/dist/chunks/{chunk-3ZHGONNA.js → chunk-L5BV4PI7.js}

@@ -45,7 +45,7 @@ import {
   unifiedDiff,
   validateTokenSets,
   writeFileAtomic
-} from "./chunk-ZLRFD5JI.js";
+} from "./chunk-C3TSTYP7.js";
 import {
   __commonJS,
   __toESM
@@ -8183,7 +8183,7 @@ async function bundle(sources, { req, parse: userParse, yamlToMomoa }) {
   };
   const originalSourceLength = sources.length;
   const origin = sources[0].filename;
-  let document = {};
+  let document2 = {};
   for (let i = 0; i < sources.length; i++) {
     const resolved = {
       ...sources[i],
@@ -8195,8 +8195,8 @@ async function bundle(sources, { req, parse: userParse, yamlToMomoa }) {
     if (typeof resolved.src !== "string") {
       resolved.src = print(resolved.document, { indent: 2 });
     }
-    if (!document.type) {
-      document = resolved.document;
+    if (!document2.type) {
+      document2 = resolved.document;
     }
     cache[sources[i].filename.href] = resolved;
     await traverseAsync(resolved.document, {
@@ -8222,9 +8222,9 @@ async function bundle(sources, { req, parse: userParse, yamlToMomoa }) {
     });
     if (i > 0) {
       if (i < originalSourceLength) {
-        document = mergeDocuments([document, resolved.document]);
+        document2 = mergeDocuments([document2, resolved.document]);
       } else {
-        let $defs = getObjMember(document.body, "$defs");
+        let $defs = getObjMember(document2.body, "$defs");
         if (!$defs) {
           const $defsMember = {
             type: "Member",
@@ -8233,7 +8233,7 @@ async function bundle(sources, { req, parse: userParse, yamlToMomoa }) {
             loc: VIRTUAL_LOC
           };
           $defs = $defsMember.value;
-          document.body.members.push($defsMember);
+          document2.body.members.push($defsMember);
         }
         $defs.members.push({
           type: "Member",
@@ -8245,7 +8245,7 @@ async function bundle(sources, { req, parse: userParse, yamlToMomoa }) {
     }
   }
   return {
-    document,
+    document: document2,
     sources: cache
   };
 }
@@ -10855,10 +10855,10 @@ function processTokens(rootSource, { config, logger, sourceByFilename, resolveAl
 }
 
 // ../../node_modules/.pnpm/@terrazzo+parser@2.7.1_yaml-to-momoa@0.1.0/node_modules/@terrazzo/parser/dist/resolver/normalize.js
-async function normalizeResolver(document, { logger, filename, req, src, yamlToMomoa }) {
+async function normalizeResolver(document2, { logger, filename, req, src, yamlToMomoa }) {
   const resolverBundle = await bundle([{ filename, src }], { req, yamlToMomoa });
   const resolverSource = evaluate(resolverBundle.document);
-  replaceNode(document, resolverBundle.document);
+  replaceNode(document2, resolverBundle.document);
   for (const set2 of Object.values(resolverSource.sets ?? {})) {
     for (const source of set2.sources) {
       resolvePartials(source, { resolver: resolverSource, logger });
@@ -10883,7 +10883,7 @@ async function normalizeResolver(document, { logger, filename, req, src, yamlToM
     resolutionOrder: resolverSource.resolutionOrder,
     _source: {
       filename,
-      document
+      document: document2
     }
   };
 }
@@ -11311,12 +11311,12 @@ async function loadResolver(inputs, { config, logger, req, yamlToMomoa }) {
     label: "init"
   };
   for (const input of inputs) {
-    let document;
+    let document2;
     if (typeof input.src === "string") {
       if (maybeRawJSON(input.src)) {
-        document = toMomoa(input.src);
+        document2 = toMomoa(input.src);
       } else if (yamlToMomoa) {
-        document = yamlToMomoa(input.src);
+        document2 = yamlToMomoa(input.src);
       } else {
         logger.error({
           ...entry,
@@ -11329,14 +11329,14 @@ async function loadResolver(inputs, { config, logger, req, yamlToMomoa }) {
         });
       }
     } else if (input.src && typeof input.src === "object") {
-      document = toMomoa(JSON.stringify(input.src, void 0, 2));
+      document2 = toMomoa(JSON.stringify(input.src, void 0, 2));
     } else {
       logger.error({
         ...entry,
         message: `Could not parse ${input.filename}. Is this valid JSON or YAML?`
       });
     }
-    if (!document || !isLikelyResolver(document)) {
+    if (!document2 || !isLikelyResolver(document2)) {
       continue;
     }
     if (inputs.length > 1) {
@@ -11345,7 +11345,7 @@ async function loadResolver(inputs, { config, logger, req, yamlToMomoa }) {
         message: `Resolver must be the only input, found ${inputs.length} sources.`
       });
     }
-    resolverDoc = document;
+    resolverDoc = document2;
     break;
   }
   let resolver;
@@ -11629,7 +11629,7 @@ function simpleFlatten(tokens, { logger }) {
 async function loadSources(inputs, { config, logger, req, continueOnError, yamlToMomoa, resolveAliases: resolveAliases3 = true, transform: transform2 }) {
   const entry = { group: "parser", label: "init" };
   const firstLoad = performance.now();
-  let document = {};
+  let document2 = {};
   const sources = inputs.map((input, i) => ({
     ...input,
     document: {},
@@ -11643,7 +11643,7 @@ async function loadSources(inputs, { config, logger, req, continueOnError, yamlT
       parse: transform2 ? transformer(transform2) : void 0,
       yamlToMomoa
     });
-    document = result.document;
+    document2 = result.document;
     sourceByFilename = result.sources;
     for (const [filename, source] of Object.entries(result.sources)) {
       const i = sources.findIndex((s) => s.filename.href === filename);
@@ -11670,8 +11670,8 @@ async function loadSources(inputs, { config, logger, req, continueOnError, yamlT
   logger.debug({ ...entry, message: `JSON loaded`, timing: performance.now() - firstLoad });
   const rootSource = {
     filename: sources[0].filename,
-    document,
-    src: print(document, { indent: 2 }).replaceAll(String.raw`\/`, "/")
+    document: document2,
+    src: print(document2, { indent: 2 }).replaceAll(String.raw`\/`, "/")
   };
   return {
     tokens: processTokens(rootSource, {
@@ -11686,17 +11686,17 @@ async function loadSources(inputs, { config, logger, req, continueOnError, yamlT
 }
 function transformer(transform2) {
   return async (src, filename) => {
-    let document = toMomoa(src);
+    let document2 = toMomoa(src);
     let lastPath = "#/";
     let last$type;
     if (transform2.root) {
-      const result = transform2.root(document, { filename, parent: void 0, path: [] });
+      const result = transform2.root(document2, { filename, parent: void 0, path: [] });
       if (result) {
-        document = result;
+        document2 = result;
       }
     }
-    const isResolver = isLikelyResolver(document);
-    traverse(document, {
+    const isResolver = isLikelyResolver(document2);
+    traverse(document2, {
       enter(node2, parent, rawPath) {
         const path = isResolver ? filterResolverPaths(rawPath) : rawPath;
         if (node2.type !== "Object" || path.length === 0) {
@@ -11729,7 +11729,7 @@ function transformer(transform2) {
         }
       }
     });
-    return document;
+    return document2;
   };
 }
 
@@ -13213,8 +13213,8 @@ function refs(sources, inline) {
     return [];
   });
 }
-function resolverLayout(document, themeModifier) {
-  const doc = document ?? {};
+function resolverLayout(document2, themeModifier) {
+  const doc = document2 ?? {};
   const inline = { count: 0 };
   const order = (doc.resolutionOrder ?? []).map((entry) => /^#\/sets\/(.+)$/.exec(String(entry?.$ref ?? ""))?.[1]).filter((name) => name !== void 0);
   const setNames = order.length > 0 ? order : Object.keys(doc.sets ?? {});
@@ -13588,13 +13588,13 @@ var YOUI_TYPES = /* @__PURE__ */ new Set(["spring", "focusRing"]);
 async function validateSets(repoRoot, system, resolverText) {
   const resolverFile = join2(repoRoot, system.tokens);
   const where2 = (file) => toPosix(relative(repoRoot, file));
-  let document;
+  let document2;
   try {
-    document = JSON.parse(resolverText);
+    document2 = JSON.parse(resolverText);
   } catch (error) {
     throw new DefinitionError(where2(resolverFile), [`not valid JSON: ${error instanceof Error ? error.message : String(error)}`]);
   }
-  const files = resolverLayout(document, system.themeModifier).files.map((ref) => join2(dirname2(resolverFile), ref));
+  const files = resolverLayout(document2, system.themeModifier).files.map((ref) => join2(dirname2(resolverFile), ref));
   const sources = await Promise.all(
     files.map(async (file) => {
       try {
@@ -15902,8 +15902,8 @@ var ExportOrigins = class {
       const found = binding ? await follow(binding.specifier, binding.imported) : null;
       if (!found) return null;
       const change = this.changes.get(found.old);
-      const rename = change.renameBarrels || this.elements.isOwned(file) || this.elements.implementationFiles.has(file);
-      return { ...found, next: found.next === null ? null : rename && name === found.old ? change.to : name };
+      const rename2 = change.renameBarrels || this.elements.isOwned(file) || this.elements.implementationFiles.has(file);
+      return { ...found, next: found.next === null ? null : rename2 && name === found.old ? change.to : name };
     }
     for (const specifier of module.starExports) {
       const found = await follow(specifier, name);
@@ -20749,7 +20749,7 @@ function composeOf(itemName, exports, label) {
   const main = components.find((e) => e === PASCAL(itemName)) ?? components[0];
   if (!main) return null;
   const has = (suffix) => components.includes(`${main}${suffix}`) ? `${main}${suffix}` : null;
-  const [input, list, item, group, trigger, content, header, title, description, footer] = ["Input", "List", "Item", "Group", "Trigger", "Content", "Header", "Title", "Description", "Footer"].map(has);
+  const [input, list, item, group, trigger, content, header, title, description, footer, menu] = ["Input", "List", "Item", "Group", "Trigger", "Content", "Header", "Title", "Description", "Footer", "Menu"].map(has);
   if (list && item) {
     const items = ["Calendar", "Search emoji", "Calculator"].map((text) => node(item, {}, [text]));
     return node(main, { style: { minWidth: 220 } }, [...input ? [node(input, { placeholder: "Type a command or search\u2026" })] : [], node(list, {}, group ? [node(group, { heading: "Suggestions" }, items)] : items)]);
@@ -20761,6 +20761,15 @@ function composeOf(itemName, exports, label) {
       node(content, { value: "password" }, ["Change your password here."])
     ]);
   }
+  if (menu && trigger) {
+    return node(main, {}, ["File", "Edit", "View"].map((text) => node(menu, {}, [node(trigger, {}, [text]), ...content && item ? [node(content, {}, [node(item, {}, ["New tab"])])] : []])));
+  }
+  if (item && trigger && content) {
+    return node(main, { type: "single", collapsible: true, defaultValue: "item-1", style: { width: 320 } }, [
+      node(item, { value: "item-1" }, [node(trigger, {}, ["Is it accessible?"]), node(content, {}, ["Yes, with your tokens."])]),
+      node(item, { value: "item-2" }, [node(trigger, {}, ["Is it styled?"]), node(content, {}, ["In your theme."])])
+    ]);
+  }
   if (trigger && content) {
     const head = header ? [node(header, {}, [...title ? [node(title, {}, [label])] : [], ...description ? [node(description, {}, ["A preview of this part in your theme."])] : []])] : [...title ? [node(title, {}, [label])] : []];
     return node(main, { open: true }, [node(trigger, {}, [`Open ${label}`]), node(content, {}, head.length ? head : [label])]);
@@ -21014,6 +21023,7 @@ async function bundlePreview(job, options = {}) {
       if (message.startsWith("esbuild timed out")) return { error: `bundling took over ${limitOf(timeoutMs)} and was stopped` };
       return { error: `it did not bundle: ${message}` };
     }
+    if (refusals.size > 0) return { error: [...refusals][0] };
     if (radix.size > 0) notes.add(`radix-ui is not installed: its ${[...radix.keys()].sort().join(", ")} ${radix.size === 1 ? "comes" : "come"} from ${[...new Set(radix.values())].sort().join(", ")}`);
     if (fromHub.size > 0) notes.add(`${[...fromHub].sort().join(", ")}: not installed in your project, so the hub's own ${fromHub.size === 1 ? "copy draws it" : "copies draw them"}`);
     const inputs = [];
@@ -21269,7 +21279,7 @@ var Eyes = class {
   }
   async open() {
     if (this.browser) return this.browser;
-    const { launchBrowser } = await import("./src-VEHGMKYV.js");
+    const { launchBrowser } = await import("./src-DS43LCRA.js");
     try {
       this.browser = await launchBrowser(this.options.executablePath, { purpose: { what: "youiyoux render", command: "youiyoux render" }, ...this.options.download === false ? { download: false } : {}, ...this.options.log ? { log: this.options.log } : {} });
     } catch (error) {
@@ -21625,6 +21635,344 @@ function shotsText(report, again = (t) => `run youiyoux render${t ? ` ${t}` : ""
   return lines.join("\n");
 }
 
+// ../scanner/src/screens/capture.ts
+import { readFileSync as readFileSync7 } from "node:fs";
+import { rename, writeFile } from "node:fs/promises";
+import { join as join19 } from "node:path";
+
+// ../scanner/src/screens/locate.ts
+import { realpathSync } from "node:fs";
+import { posix as posix7 } from "node:path";
+var MAX_PLACES = 4e3;
+function locateInPage(limit, maxFrames = 6) {
+  const size = { width: document.documentElement.scrollWidth, height: document.documentElement.scrollHeight };
+  const roots = [];
+  for (const element of document.querySelectorAll("*")) {
+    const key = Object.keys(element).find((k) => k.startsWith("__reactContainer$"));
+    if (!key) continue;
+    const container = element[key];
+    roots.push(container.stateNode?.current ?? container);
+  }
+  if (roots.length === 0) return { react: false, dev: false, size, places: [], capped: false };
+  const COMPONENT = /* @__PURE__ */ new Set([0, 1, 11, 14, 15]);
+  const nameOf = (type2) => {
+    const t = type2;
+    return t?.displayName || t?.name || t?.render?.displayName || t?.render?.name || t?.type?.displayName || t?.type?.name || null;
+  };
+  const INTERNAL = /\/node_modules\/|\/\.vite\/deps\/|\/_next\/static\/chunks\/(?:framework|main|webpack)|react-dom|jsx-dev-runtime|jsx-runtime/;
+  const framesOf = (stack) => {
+    const frames = [];
+    for (const text of (stack ?? "").split("\n").slice(1)) {
+      if (/react[-_]stack[-_]bottom[-_]frame/.test(text)) break;
+      const match = /((?:https?|file):\/\/[^\s()]+?):(\d+):(\d+)\)?\s*$/.exec(text);
+      if (!match || INTERNAL.test(match[1])) continue;
+      frames.push({ url: match[1], line: Number(match[2]), column: Number(match[3]) });
+      if (frames.length >= maxFrames) break;
+    }
+    return frames;
+  };
+  const boxOf = (fiber) => {
+    let left = Infinity;
+    let top = Infinity;
+    let right = -Infinity;
+    let bottom = -Infinity;
+    const walk = (first) => {
+      for (let node2 = first; node2; node2 = node2.sibling) {
+        if (node2.tag === 5) {
+          const rect = node2.stateNode?.getBoundingClientRect?.();
+          if (rect && rect.width > 0 && rect.height > 0) {
+            left = Math.min(left, rect.left);
+            top = Math.min(top, rect.top);
+            right = Math.max(right, rect.right);
+            bottom = Math.max(bottom, rect.bottom);
+          }
+        } else if (node2.tag !== 6) walk(node2.child);
+      }
+    };
+    walk(fiber.child);
+    if (!Number.isFinite(left)) return null;
+    return { x: Math.round(left + scrollX), y: Math.round(top + scrollY), width: Math.round(right - left), height: Math.round(bottom - top) };
+  };
+  const places = [];
+  let dev = false;
+  let capped = false;
+  const visit = (fiber, depth) => {
+    for (let node2 = fiber; node2; node2 = node2.sibling) {
+      let inner = depth;
+      if (COMPONENT.has(node2.tag)) {
+        if (node2._debugStack) dev = true;
+        const box = boxOf(node2);
+        const name = nameOf(node2.type);
+        if (box && name) {
+          if (places.length >= limit) {
+            capped = true;
+            return;
+          }
+          places.push({ name, owner: nameOf(node2._debugOwner?.type), frames: framesOf(node2._debugStack?.stack), box, depth });
+        }
+        inner = depth + 1;
+      }
+      visit(node2.child, inner);
+      if (capped) return;
+    }
+  };
+  for (const root of roots) visit(root.child, 0);
+  return { react: true, dev, size, places, capped };
+}
+var BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var DIGIT = new Map([...BASE64].map((c, i) => [c, i]));
+function decodeMap(map) {
+  if (!Array.isArray(map.sources) || typeof map.mappings !== "string") return null;
+  const root = typeof map.sourceRoot === "string" && map.sourceRoot ? map.sourceRoot.replace(/\/?$/, "/") : "";
+  const sources = map.sources.map((s) => typeof s === "string" ? `${root}${s}` : "");
+  const lines = [];
+  let source = 0;
+  let line2 = 0;
+  let column = 0;
+  for (const text of map.mappings.split(";")) {
+    const segments = [];
+    let generated = 0;
+    for (const part2 of text.split(",")) {
+      if (!part2) continue;
+      const values = [];
+      let value = 0;
+      let shift = 0;
+      for (const char of part2) {
+        const digit = DIGIT.get(char);
+        if (digit === void 0) return null;
+        value += (digit & 31) << shift;
+        if (digit & 32) shift += 5;
+        else {
+          values.push(value & 1 ? -(value >>> 1) : value >>> 1);
+          value = 0;
+          shift = 0;
+        }
+      }
+      generated += values[0] ?? 0;
+      if (values.length >= 4) {
+        source += values[1];
+        line2 += values[2];
+        column += values[3];
+        segments.push([generated, source, line2, column]);
+      }
+    }
+    lines.push(segments);
+  }
+  return { sources, lines };
+}
+function originalPosition(map, line2, column) {
+  const segments = map.lines[line2 - 1];
+  if (!segments?.length) return null;
+  let found = null;
+  for (const segment of segments) {
+    if (segment[0] > column - 1) break;
+    found = segment;
+  }
+  found ??= segments[0];
+  const source = map.sources[found[1]];
+  return source === void 0 ? null : { source, line: found[2] + 1, column: found[3] + 1 };
+}
+async function sourceMapOf(url, text, fetchText) {
+  const at = text.lastIndexOf("sourceMappingURL=");
+  if (at < 0 || !/\/\/[#@]\s*$/.test(text.slice(Math.max(0, at - 8), at))) return null;
+  const target = text.slice(at + "sourceMappingURL=".length).split(/\s/, 1)[0];
+  if (!target) return null;
+  let json;
+  if (target.startsWith("data:")) {
+    const at2 = target.indexOf(",");
+    const payload = target.slice(at2 + 1);
+    json = /;base64/.test(target.slice(0, at2)) ? Buffer.from(payload, "base64").toString("utf8") : decodeURIComponent(payload);
+  } else json = await fetchText(new URL(target, url).href);
+  if (!json) return null;
+  try {
+    return decodeMap(JSON.parse(json));
+  } catch {
+    return null;
+  }
+}
+function projectPath(source, moduleUrl, root) {
+  let path;
+  const webpack = /^webpack:\/\/[^/]*\/(.*)$/.exec(source);
+  if (webpack) path = `/${webpack[1].replace(/^\.\//, "")}`;
+  else if (/^[a-z]+:\/\//i.test(source) && !source.startsWith("file://")) path = new URL(source).pathname;
+  else if (source.startsWith("file://")) path = new URL(source).pathname;
+  else if (source.startsWith("/")) path = source;
+  else path = new URL(source, moduleUrl).pathname;
+  path = decodeURIComponent(path).replace(/^\/@fs\//, "/");
+  for (const base of root ? /* @__PURE__ */ new Set([root, realOrSelf(root)]) : []) {
+    const prefix = base.replace(/\\/g, "/").replace(/\/?$/, "/");
+    if (path.startsWith(prefix)) return posix7.normalize(path.slice(prefix.length));
+  }
+  if (/^\/(?:Users|home|private|var|tmp|opt|mnt|[A-Za-z]:)\//.test(path)) return null;
+  const relative6 = posix7.normalize(path.replace(/^\/+/, ""));
+  return relative6.startsWith("..") || relative6 === "." ? null : relative6;
+}
+function realOrSelf(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+async function resolvePlaces(raw, fetchText, root = null) {
+  const maps = /* @__PURE__ */ new Map();
+  const mapFor = (url) => {
+    const module = url.replace(/[?#].*$/, "");
+    let found = maps.get(module);
+    if (!found) {
+      found = fetchText(url).then((text) => text === null ? null : sourceMapOf(url, text, fetchText), () => null);
+      maps.set(module, found);
+    }
+    return found;
+  };
+  return Promise.all(
+    raw.map(async (place) => {
+      const base = { name: place.name, owner: place.owner, box: place.box, depth: place.depth };
+      for (const frame of place.frames) {
+        const map = await mapFor(frame.url);
+        const original = map ? originalPosition(map, frame.line, frame.column) : null;
+        if (!original) continue;
+        if (/(?:^|\/)node_modules\/|^webpack\/|^\(webpack\)/.test(original.source)) continue;
+        const file = projectPath(original.source, frame.url, root);
+        if (file) return { ...base, file, line: original.line, column: original.column };
+      }
+      const unmapped = place.frames[0];
+      return { ...base, file: unmapped ? projectPath(unmapped.url.replace(/[?#].*$/, ""), unmapped.url, null) : null, line: null, column: null };
+    })
+  );
+}
+
+// ../scanner/src/screens/capture.ts
+var SCREENS_SCHEMA = "youiyoux.screens/v1";
+var PLACES_SCHEMA = "youiyoux.places/v1";
+var SCHEMES2 = ["light", "dark"];
+var PICTURE_SCALE = 2;
+var FULL_SCALE = PICTURE_SCALE;
+var THUMB_SCALE = 0.5;
+var SETTLE_MS = 1200;
+var NAVIGATION_TIMEOUT_MS = 3e4;
+var MAX_VIEWPORTS = 6;
+var WEBP_QUALITY = 0.9;
+function screenSlug(route) {
+  if (route === "*") return "app-shell";
+  if (route === "?") return "unrouted";
+  return route.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "root";
+}
+function readScreensSpec(dir) {
+  const file = join19(dir, "screens.json");
+  let value;
+  try {
+    value = JSON.parse(readFileSync7(file, "utf8"));
+  } catch (error) {
+    throw new Error(`cannot read ${file}: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`);
+  }
+  const valid = value.schema === SCREENS_SCHEMA && typeof value.project === "string" && typeof value.source === "string" && typeof value.viewport?.width === "number" && typeof value.viewport.height === "number" && Array.isArray(value.screens) && value.screens.every((s) => typeof s?.route === "string" && typeof s.path === "string");
+  if (!valid) throw new Error(`${file} is not a ${SCREENS_SCHEMA} document: it needs project, source, viewport { width, height } and screens [{ route, path }]`);
+  const slugs = /* @__PURE__ */ new Map();
+  for (const { route } of value.screens) {
+    const slug2 = screenSlug(route);
+    if (slugs.has(slug2)) throw new Error(`${file}: routes ${slugs.get(slug2)} and ${route} would share the file name ${slug2}`);
+    slugs.set(slug2, route);
+  }
+  return value;
+}
+async function writeBytes(file, bytes) {
+  const temporary = `${file}.${process.pid}.tmp`;
+  await writeFile(temporary, bytes);
+  await rename(temporary, file);
+}
+async function encode(page, png, scale) {
+  const url = await page.evaluate(
+    async ({ data, scale: scale2, quality }) => {
+      const image = new Image();
+      image.src = `data:image/png;base64,${data}`;
+      await image.decode();
+      const canvas = document.createElement("canvas");
+      canvas.width = Math.max(1, Math.round(image.naturalWidth * scale2));
+      canvas.height = Math.max(1, Math.round(image.naturalHeight * scale2));
+      const context = canvas.getContext("2d");
+      context.imageSmoothingQuality = "high";
+      context.drawImage(image, 0, 0, canvas.width, canvas.height);
+      return canvas.toDataURL("image/webp", quality);
+    },
+    { data: png.toString("base64"), scale, quality: WEBP_QUALITY }
+  );
+  if (!url.startsWith("data:image/webp;base64,")) throw new Error("this Chromium cannot encode WebP");
+  return Buffer.from(url.slice("data:image/webp;base64,".length), "base64");
+}
+var sentence = (error) => (error instanceof Error ? error.message : String(error)).split("\n")[0].replace(/\.$/, "");
+async function captureScreens(dir, options) {
+  const spec = readScreensSpec(dir);
+  const unknown = (options.routes ?? []).filter((route) => !spec.screens.some((s) => s.route === route));
+  if (unknown.length) throw new Error(`${join19(dir, "screens.json")} has no route ${unknown.join(", ")}: it lists ${spec.screens.map((s) => s.route).join(", ")}`);
+  const chosen = options.routes?.length ? spec.screens.filter((s) => options.routes.includes(s.route)) : spec.screens;
+  const log = options.log ?? (() => void 0);
+  const { width, height } = spec.viewport;
+  const results = /* @__PURE__ */ new Map();
+  let dev = false;
+  let react = false;
+  for (const scheme of SCHEMES2) {
+    const context = await options.browser.newContext({ viewport: { width, height }, deviceScaleFactor: FULL_SCALE, colorScheme: scheme, reducedMotion: "reduce", ...options.storageState ? { storageState: options.storageState } : {} });
+    try {
+      const page = await context.newPage();
+      const encoder = await context.newPage();
+      for (const screen of chosen) {
+        const slug2 = screenSlug(screen.route);
+        if (results.get(screen.route)?.error) continue;
+        try {
+          const target = new URL(screen.path, options.base).href;
+          await page.goto(target, { waitUntil: "load", timeout: NAVIGATION_TIMEOUT_MS });
+          await page.evaluate(() => document.fonts?.ready.then(() => void 0));
+          await page.waitForTimeout(SETTLE_MS);
+          let located = scheme === "light" ? await page.evaluate(locateInPage, MAX_PLACES) : null;
+          if (located && !located.react) {
+            await page.waitForLoadState("load");
+            await page.waitForTimeout(SETTLE_MS * 2);
+            located = await page.evaluate(locateInPage, MAX_PLACES);
+          }
+          const pageHeight = located?.size.height ?? await page.evaluate(() => document.documentElement.scrollHeight);
+          const clip = { x: 0, y: 0, width, height: Math.min(Math.max(pageHeight, height), height * MAX_VIEWPORTS) };
+          const png = await page.screenshot({ fullPage: true, clip });
+          await writeBytes(join19(dir, `${slug2}.${scheme}.webp`), await encode(encoder, png, 1));
+          await writeBytes(join19(dir, `${slug2}.${scheme}.thumb.webp`), await encode(encoder, png, THUMB_SCALE / FULL_SCALE));
+          if (located) {
+            react ||= located.react;
+            dev ||= located.dev;
+            const places = await resolvePlaces(located.places, async (url) => {
+              const response = await fetch(url).catch(() => null);
+              return response?.ok ? response.text() : null;
+            }, options.root ?? null);
+            const file = { schema: PLACES_SCHEMA, route: screen.route, path: screen.path, viewport: spec.viewport, size: { width, height: clip.height }, dev: located.dev, capped: located.capped, places: places.filter((p3) => p3.box.y < clip.height) };
+            await writeFileAtomic(join19(dir, `${slug2}.places.json`), `${JSON.stringify(file)}
+`);
+            results.set(screen.route, { placed: file.places.length, lined: file.places.filter((p3) => p3.line !== null).length, error: null });
+          }
+          log(`${screen.route} (${scheme}) \u2192 ${slug2}.${scheme}.webp${located ? `, ${results.get(screen.route).placed} components placed` : ""}`);
+        } catch (error) {
+          results.set(screen.route, { placed: 0, lined: 0, error: `${sentence(error)} (${screen.path})` });
+          log(`${screen.route} (${scheme}): ${sentence(error)}`);
+        }
+      }
+    } finally {
+      await context.close();
+    }
+  }
+  const now = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+  if (chosen === spec.screens) await writeFileAtomic(join19(dir, "screens.json"), `${JSON.stringify({ ...spec, capturedAt: now }, null, 2)}
+`);
+  const screens = chosen.map((s) => ({ route: s.route, path: s.path, ...results.get(s.route) ?? { placed: 0, lined: 0, error: "not captured" } }));
+  return { dir, project: spec.project, screens, production: react && !dev, noReact: !react && screens.some((s) => !s.error) };
+}
+function captureText(report) {
+  const ok = report.screens.filter((s) => !s.error);
+  const lines = [`${ok.length} of ${report.screens.length} screens of ${report.project} captured \u2192 ${report.dir}`];
+  for (const s of report.screens) lines.push(s.error ? `  \u2716 ${s.route}: ${s.error}` : `  \u2713 ${s.route}: ${s.placed} components placed, ${s.lined} with their line`);
+  if (report.noReact) lines.push("No React on these pages, so nothing is placed: the pictures are kept without places.");
+  else if (report.production) lines.push("These pages are a production build: components are placed but have no lines. Run the app in development (vite, next dev) and capture again.");
+  lines.push(ok.length ? "Next: youiyoux ui --project <dir> shows them on the Screens page, each component selectable." : "Next: start the app, check --base, and capture again.");
+  return lines.join("\n");
+}
+
 export {
   parseCssColor,
   resolverLayout,
@@ -21793,5 +22141,19 @@ export {
   compareA11yIssues,
   renderShots,
   shotsNext,
-  shotsText
+  shotsText,
+  MAX_PLACES,
+  locateInPage,
+  decodeMap,
+  originalPosition,
+  sourceMapOf,
+  projectPath,
+  resolvePlaces,
+  SCREENS_SCHEMA,
+  PLACES_SCHEMA,
+  PICTURE_SCALE,
+  screenSlug,
+  readScreensSpec,
+  captureScreens,
+  captureText
 };