leglas 1.2.1 → 1.3.0

package/dist/index.js

@@ -162,8 +162,13 @@ function parseClassify(rest) {
 function parseWatch(rest) {
   let run4;
   let port;
+  let json = false;
   for (let index = 0; index < rest.length; index += 1) {
     const argument = rest[index];
+    if (argument === "--json") {
+      json = true;
+      continue;
+    }
     const equals = argument.indexOf("=");
     const flag = equals === -1 ? argument : argument.slice(0, equals);
     if (flag !== "--run" && flag !== "--port") {
@@ -184,7 +189,7 @@ function parseWatch(rest) {
     if ("error" in parsed) return { kind: "error", message: parsed.error };
     port = parsed.port;
   }
-  return { kind: "watch", run: run4, port };
+  return { kind: "watch", run: run4, port, json };
 }
 function parseShare(rest) {
   const titles = [];
@@ -323,12 +328,38 @@ function parseArgs(argv) {
     let count = 3;
     let basedOn = null;
     let json = false;
+    let build = false;
+    let brief = null;
+    let port = null;
     for (let index = 0; index < rest.length; index += 1) {
       const argument = rest[index];
       if (argument === "--json") {
         json = true;
         continue;
       }
+      if (argument === "--build") {
+        build = true;
+        continue;
+      }
+      if (argument === "--brief" || argument.startsWith("--brief=")) {
+        const raw = argument.includes("=") ? argument.slice(argument.indexOf("=") + 1) : rest[index += 1];
+        if (raw === void 0 || raw.trim() === "") {
+          return {
+            kind: "error",
+            message: '--brief needs a description, for example --brief "A hero for a cooking app".'
+          };
+        }
+        brief = raw;
+        continue;
+      }
+      if (argument === "--port" || argument.startsWith("--port=")) {
+        const raw = argument.includes("=") ? argument.split("=")[1] : rest[index += 1];
+        if (raw === void 0 || !/^\d+$/.test(raw)) {
+          return { kind: "error", message: "--port needs a number, for example --port 4000." };
+        }
+        port = Number(raw);
+        continue;
+      }
       if (argument === "--count" || argument.startsWith("--count=")) {
         const raw = argument.includes("=") ? argument.split("=")[1] : rest[index += 1];
         if (raw === void 0 || !/^\d+$/.test(raw)) {
@@ -362,7 +393,19 @@ function parseArgs(argv) {
         message: "leglas explore needs a surface name, for example: npx leglas explore hero --count 6"
       };
     }
-    return { kind: "explore", surface, count, basedOn, json };
+    if (build && brief === null && basedOn === null) {
+      return {
+        kind: "error",
+        message: 'leglas explore --build needs a brief, for example: npx leglas explore hero --build --brief "A hero for a cooking app". To vary a direction instead, name it with --based-on "<title>".'
+      };
+    }
+    if (!build && brief !== null) {
+      return {
+        kind: "error",
+        message: "--brief goes with --build: add --build to have Leglas build the set."
+      };
+    }
+    return { kind: "explore", surface, count, basedOn, json, build, brief, port };
   }
   if (argv[0] === "requests") {
     const rest = argv.slice(1);
@@ -666,7 +709,7 @@ function placeholder(label, note) {
   return `export function ${label}() {
   return (
     <div style={{ padding: "3rem", fontFamily: "system-ui" }}>
-      <p>${note}</p>
+      <p>{${JSON.stringify(note)}}</p>
     </div>
   );
 }
@@ -872,7 +915,8 @@ Useful to know:
   they have asked for that is not done yet. Add \`--screenshot\` to render a PNG
   you can inspect. Run it when handed a direction you did not register yourself.
 - Every command accepts \`--json\` and prints one envelope with a stable exit
-  code, so you can drive it without parsing prose.
+  code, so you can drive it without parsing prose. \`watch\` keeps running, so
+  it prints one JSON line per event instead.
 
 ${AGENTS_MARKER_END}
 `;
@@ -912,7 +956,7 @@ ${AGENTS_SECTION}`
 }
 
 // src/keep.ts
-import { basename as basename4, extname as extname4, normalize as normalize2 } from "path";
+import { basename as basename4, extname as extname4, isAbsolute as isAbsolute2, normalize as normalize3 } from "path";
 
 // ../server/dist/log.js
 var DEFAULT_LOG_DIR = "design-log";
@@ -993,8 +1037,8 @@ function composeEntry(input) {
 }
 
 // ../server/dist/json.js
-function parseJson(text2) {
-  return JSON.parse(text2);
+function parseJson(text3) {
+  return JSON.parse(text3);
 }
 function isJsonRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1314,7 +1358,7 @@ var KNOWN_AGENTS = {
     // moves that precondition and only that: `-s workspace-write` still
     // confines writes to the project, so the sandbox boundary is unchanged,
     // and in a git repository the flag does nothing at all.
-    args: (prompt, effort = null, images = []) => [
+    args: (prompt, effort = null, images2 = []) => [
       "exec",
       "--json",
       ...CODEX_WORKSPACE_CONFIG,
@@ -1322,23 +1366,23 @@ var KNOWN_AGENTS = {
       "-s",
       "workspace-write",
       "--skip-git-repo-check",
-      ...images.flatMap((image) => ["-i", image]),
+      ...images2.flatMap((image) => ["-i", image]),
       prompt
     ],
-    terminalArgs: (prompt, effort = null, images = []) => [
+    terminalArgs: (prompt, effort = null, images2 = []) => [
       "exec",
       ...CODEX_WORKSPACE_CONFIG,
       ...codexEffortConfig(effort),
       "-s",
       "workspace-write",
       "--skip-git-repo-check",
-      ...images.flatMap((image) => ["-i", image]),
+      ...images2.flatMap((image) => ["-i", image]),
       prompt
     ],
     // No sandbox flag here: `codex exec resume` refuses it and inherits the
     // session's own sandbox, which the first turn set to workspace-write. The
     // repository check is per invocation, so resume needs the flag of its own.
-    resumeArgs: (sessionId, prompt, effort = null, images = []) => [
+    resumeArgs: (sessionId, prompt, effort = null, images2 = []) => [
       "exec",
       "resume",
       sessionId,
@@ -1346,7 +1390,7 @@ var KNOWN_AGENTS = {
       ...CODEX_WORKSPACE_CONFIG,
       ...codexEffortConfig(effort),
       "--skip-git-repo-check",
-      ...images.flatMap((image) => ["-i", image]),
+      ...images2.flatMap((image) => ["-i", image]),
       prompt
     ],
     sessionFrom: (event) => event.type === "thread.started" && isString(event.thread_id) ? event.thread_id : null,
@@ -2181,12 +2225,12 @@ function buildNumber(entry) {
   const digits = /(\d+)\s*$/.exec(entry)?.[1];
   return digits === void 0 ? 0 : Number(digits);
 }
-function cacheRoots(platform, home, readdir4 = readableDirectories) {
+function cacheRoots(platform, home, readdir6 = readableDirectories) {
   const playwright = platform === "darwin" ? join4(home, "Library", "Caches", "ms-playwright") : join4(home, ".cache", "ms-playwright");
   const puppeteer = join4(home, ".cache", "puppeteer");
   const newestFirst = (dir, keep = () => true) => ({
     root: dir,
-    entries: readdir4(dir).filter(keep).sort((left, right) => buildNumber(right) - buildNumber(left))
+    entries: readdir6(dir).filter(keep).sort((left, right) => buildNumber(right) - buildNumber(left))
   });
   return [
     newestFirst(playwright, (entry) => entry.startsWith("chromium-") || entry.startsWith("chromium_headless_shell-")),
@@ -2207,13 +2251,13 @@ function findBrowser(search = {}) {
   const home = search.home ?? homedir();
   const exists = search.exists ?? existsSync2;
   const onPath = search.onPath ?? ((name) => firstOnPath(name, env));
-  const readdir4 = search.readdir ?? readableDirectories;
+  const readdir6 = search.readdir ?? readableDirectories;
   const firstExisting = (paths) => paths.find((path) => exists(path)) ?? null;
   for (const candidate of [env.LEGLAS_BROWSER, env.CHROME_PATH, env.PUPPETEER_EXECUTABLE_PATH]) {
     if (isString(candidate) && candidate !== "" && exists(candidate))
       return candidate;
   }
-  const caches = cacheRoots(platform, home, readdir4);
+  const caches = cacheRoots(platform, home, readdir6);
   const shell = firstExisting(caches.flatMap(({ root, entries }) => entries.flatMap((entry) => HEADLESS_SHELL.map((rest) => join4(root, entry, ...rest)))));
   if (shell !== null)
     return shell;
@@ -2243,7 +2287,7 @@ function findBrowser(search = {}) {
   }
   if (platform === "darwin" || platform === "linux") {
     const playwrightRoot = platform === "darwin" ? join4(home, "Library", "Caches", "ms-playwright") : join4(home, ".cache", "ms-playwright");
-    const playwright = readdir4(playwrightRoot).filter((entry) => entry.startsWith("chromium-") || entry.startsWith("chromium_headless_shell-")).sort((left, right) => buildNumber(right) - buildNumber(left)).flatMap((entry) => {
+    const playwright = readdir6(playwrightRoot).filter((entry) => entry.startsWith("chromium-") || entry.startsWith("chromium_headless_shell-")).sort((left, right) => buildNumber(right) - buildNumber(left)).flatMap((entry) => {
       const root = join4(playwrightRoot, entry);
       return [
         ...FOR_TESTING.map((rest) => join4(root, ...rest)),
@@ -2260,7 +2304,7 @@ function findBrowser(search = {}) {
     const puppeteerCache = join4(home, ".cache", "puppeteer");
     for (const kind of ["chrome", "chrome-headless-shell"]) {
       const kindRoot = join4(puppeteerCache, kind);
-      const found = firstExisting(readdir4(kindRoot).sort((left, right) => buildNumber(right) - buildNumber(left)).flatMap((entry) => {
+      const found = firstExisting(readdir6(kindRoot).sort((left, right) => buildNumber(right) - buildNumber(left)).flatMap((entry) => {
         const root = join4(kindRoot, entry);
         return [...FOR_TESTING, ...HEADLESS_SHELL].map((rest) => join4(root, ...rest));
       }));
@@ -2300,7 +2344,7 @@ async function connectWebSocket(url) {
     socket.addEventListener("error", failed, { once: true });
   });
   return {
-    send: (text2) => socket.send(text2),
+    send: (text3) => socket.send(text3),
     onMessage: (listener) => socket.addEventListener("message", (event) => listener(String(event.data))),
     onClose: (listener) => socket.addEventListener("close", listener),
     close: () => socket.close()
@@ -2525,10 +2569,10 @@ async function launchBrowser(executable, options = {}) {
     socketClosed = true;
     rejectPending();
   });
-  socket.onMessage((text2) => {
+  socket.onMessage((text3) => {
     let message2;
     try {
-      const parsed = parseJson(text2);
+      const parsed = parseJson(text3);
       if (!isJsonRecord(parsed))
         return;
       message2 = parsed;
@@ -2893,6 +2937,16 @@ function validBox(value) {
     return false;
   return [value.x, value.y, value.width, value.height].every((entry) => isNumber(entry) && Number.isFinite(entry));
 }
+function resourced(text3, url) {
+  const line = String(text3 ?? "");
+  if (!isString(url) || url === "")
+    return line;
+  try {
+    return `${line} (${new URL(url).pathname})`;
+  } catch {
+    return line;
+  }
+}
 function locatorExpression(focus) {
   return `${LOCATOR}(${JSON.stringify(focus.selector)}, ${JSON.stringify(focus.text)}, ${JSON.stringify(focus.tag)})`;
 }
@@ -2961,7 +3015,7 @@ async function render(page, input) {
     }),
     page.on("Log.entryAdded", (params) => {
       if (params?.entry?.level === "error")
-        remember(params.entry.text);
+        remember(resourced(params.entry.text, params.entry.url));
     })
   ];
   try {
@@ -3384,8 +3438,8 @@ async function rehomeCaptures(cwd, from, to, attachments) {
     file: attachment.file.startsWith(prefix) ? `${CAPTURES_DIR}/${to}/${attachment.file.slice(prefix.length)}` : attachment.file
   }));
 }
-function rehomeText(text2, from, to) {
-  return text2.split(`${CAPTURES_DIR}/${from}/`).join(`${CAPTURES_DIR}/${to}/`);
+function rehomeText(text3, from, to) {
+  return text3.split(`${CAPTURES_DIR}/${from}/`).join(`${CAPTURES_DIR}/${to}/`);
 }
 async function ownCapturesRoot(cwd) {
   const root = join5(cwd, CAPTURES_DIR);
@@ -4253,13 +4307,13 @@ function imageMediaType(path) {
     return "image/gif";
   return null;
 }
-async function claudeContent(prompt, images) {
-  if (images.length === 0)
+async function claudeContent(prompt, images2) {
+  if (images2.length === 0)
     return prompt;
   const blocks = [
     { type: "text", text: prompt }
   ];
-  for (const path of images) {
+  for (const path of images2) {
     const mediaType = imageMediaType(path);
     if (mediaType === null)
       continue;
@@ -5162,7 +5216,7 @@ function isStateUpdater(value) {
   return typeof value === "function";
 }
 var SESSION_TURNS_CAP = 8;
-function resolveCommand(choice, prompt, sessionId = null, allowedCommands = [], images = []) {
+function resolveCommand(choice, prompt, sessionId = null, allowedCommands = [], images2 = []) {
   if (choice.agent === null)
     return null;
   if (choice.agent === "custom") {
@@ -5189,24 +5243,24 @@ function resolveCommand(choice, prompt, sessionId = null, allowedCommands = [],
       agent: choice.agent,
       name: adapter.name,
       command: adapter.binary,
-      args: [...adapter.resumeArgs(sessionId, prompt, choice.effort, images), ...allow],
+      args: [...adapter.resumeArgs(sessionId, prompt, choice.effort, images2), ...allow],
       prompt,
       effort: choice.effort,
       sessionId,
       resumed: true,
-      images
+      images: images2
     };
   }
   return {
     agent: choice.agent,
     name: adapter.name,
     command: adapter.binary,
-    args: [...adapter.args(prompt, choice.effort, images), ...allow],
+    args: [...adapter.args(prompt, choice.effort, images2), ...allow],
     prompt,
     effort: choice.effort,
     sessionId: null,
     resumed: false,
-    images
+    images: images2
   };
 }
 function lineReader(stream, onLine) {
@@ -5492,8 +5546,8 @@ function startRunner(options) {
       `${options.leglasCommand} show`,
       ...request.mode === "variant" ? [registrationCommand(options.leglasCommand)] : []
     ];
-    const images = (await Promise.all((request.attachments ?? []).map(async (attachment) => await isOwnCapture(options.cwd, attachment.file) ? resolve2(options.cwd, attachment.file) : null))).filter((image) => image !== null);
-    let resolved = resolveCommand(choice, request.prompt, choice.agent === null ? null : resumable(choice.agent), allowedCommands, images);
+    const images2 = (await Promise.all((request.attachments ?? []).map(async (attachment) => await isOwnCapture(options.cwd, attachment.file) ? resolve2(options.cwd, attachment.file) : null))).filter((image) => image !== null);
+    let resolved = resolveCommand(choice, request.prompt, choice.agent === null ? null : resumable(choice.agent), allowedCommands, images2);
     if (resolved === null)
       return;
     const lines2 = [];
@@ -5539,7 +5593,7 @@ function startRunner(options) {
       // nothing says "cancelled". Stopped still means stopped.
       !stopped) {
         sessions.delete(resolved.agent);
-        const cold = resolveCommand(choice, request.prompt, null, allowedCommands, images);
+        const cold = resolveCommand(choice, request.prompt, null, allowedCommands, images2);
         if (cold !== null) {
           resolved = cold;
           observed.sessionId = null;
@@ -7233,10 +7287,10 @@ function resolveTitle(input, titles, renames) {
 // ../server/dist/server.js
 import { createReadStream, existsSync as existsSync3, statSync, unwatchFile, watch as watchFs, watchFile } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir8, readdir as readdir3, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir8, readdir as readdir5, writeFile as writeFile9 } from "fs/promises";
 import http4 from "http";
 import net3 from "net";
-import { basename as basename3, dirname as dirname8, extname as extname3, join as join12, normalize, relative as relative3 } from "path";
+import { basename as basename3, dirname as dirname10, extname as extname3, join as join16, normalize as normalize2, relative as relative4 } from "path";
 
 // ../server/dist/frame-policy.js
 var FRAMING_TIMEOUT_MS = 4e3;
@@ -7347,13 +7401,1148 @@ async function checkFraming(target, embedder, fetcher = fetch) {
   }
 }
 
+// ../server/dist/generation/generation.js
+import { spawn as nodeSpawn4 } from "child_process";
+import { readFile as readFile14, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname8, join as join14 } from "path";
+
+// ../server/dist/generation/claude.js
+var GENERATION_EFFORT = "medium";
+var RESTRICTED = [
+  "--output-format",
+  "stream-json",
+  "--verbose",
+  "--restricted",
+  "--strict-mcp-config"
+];
+function planArgs(prompt, effort = GENERATION_EFFORT) {
+  return ["-p", prompt, ...RESTRICTED, "--tools", "", "--effort", effort];
+}
+function buildArgs(prompt, effort = GENERATION_EFFORT) {
+  return [
+    "-p",
+    prompt,
+    ...RESTRICTED,
+    "--tools",
+    "Read,Write,Edit",
+    "--permission-mode",
+    "acceptEdits",
+    "--effort",
+    effort
+  ];
+}
+function resultText(lines2) {
+  for (let index = lines2.length - 1; index >= 0; index -= 1) {
+    const line = lines2[index]?.trim() ?? "";
+    if (!line.startsWith("{"))
+      continue;
+    try {
+      const event = parseJson(line);
+      if (isJsonRecord(event) && event.type === "result" && isString(event.result))
+        return event.result;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// ../server/dist/generation/codex.js
+import { readFile as readFile11 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join11 } from "path";
+var RESTRICTED2 = [
+  "exec",
+  "--json",
+  "--ephemeral",
+  "--skip-git-repo-check",
+  "-c",
+  `model_reasoning_effort=${GENERATION_EFFORT}`,
+  "-c",
+  "project_doc_max_bytes=0",
+  "-c",
+  "skills.include_instructions=false",
+  "-c",
+  "skills.bundled.enabled=false",
+  // Through the config, not `--disable`: a Codex that lacks one of these
+  // ignores it here, where `--disable` refuses to start at all.
+  ...[
+    "multi_agent",
+    "apps",
+    "plugins",
+    "memories",
+    "goals",
+    "browser_use",
+    "computer_use",
+    "image_generation"
+  ].flatMap((feature) => ["-c", `features.${feature}=false`])
+];
+var BARE = /^[A-Za-z0-9_-]+$/;
+async function codexServers(home = defaultCodexHome()) {
+  let config;
+  try {
+    config = await readFile11(join11(home, "config.toml"), "utf8");
+  } catch {
+    return [];
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const match of config.matchAll(/^\s*\[\s*mcp_servers\s*\.\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_-]+))\s*\]\s*(?:#.*)?$/gm)) {
+    const name = match[1] ?? match[2] ?? match[3] ?? "";
+    if (BARE.test(name))
+      names.add(name);
+  }
+  return [...names];
+}
+function defaultCodexHome(env = process.env) {
+  return env.CODEX_HOME !== void 0 && env.CODEX_HOME !== "" ? env.CODEX_HOME : join11(homedir2(), ".codex");
+}
+var serversOff = (servers) => servers.flatMap((name) => ["-c", `mcp_servers.${name}.enabled=false`]);
+function codexPlanArgs(prompt, servers) {
+  return [...RESTRICTED2, ...serversOff(servers), "-s", "read-only", prompt];
+}
+function codexBuildArgs(prompt, servers) {
+  return [...RESTRICTED2, ...serversOff(servers), "-s", "workspace-write", prompt];
+}
+function codexResultText(lines2) {
+  for (let index = lines2.length - 1; index >= 0; index -= 1) {
+    const line = lines2[index]?.trim() ?? "";
+    if (!line.startsWith("{"))
+      continue;
+    try {
+      const event = parseJson(line);
+      const item = isJsonRecord(event) ? event.item : void 0;
+      if (isJsonRecord(event) && event.type === "item.completed" && isJsonRecord(item) && item.type === "agent_message" && isString(item.text))
+        return item.text;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// ../server/dist/generation/facts.js
+import { readFile as readFile13, readdir as readdir4 } from "fs/promises";
+import { dirname as dirname7, join as join13, normalize } from "path";
+
+// ../server/dist/generation/switch-file.js
+import { readFile as readFile12, readdir as readdir3, stat as stat4 } from "fs/promises";
+import { join as join12, relative as relative3 } from "path";
+var MAP = /const DIRECTIONS = \{([\s\S]*?)\} as const;/;
+var SOURCE = /\.(tsx|jsx|ts|js)$/;
+var SCAN_LIMIT = 3e3;
+async function isFile(path) {
+  try {
+    return (await stat4(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function findSwitch(cwd, slug) {
+  for (const name of ["switch.tsx", "switch.jsx"]) {
+    const path = join12(".leglas", "variants", slug, name);
+    if (await isFile(join12(cwd, path)))
+      return path;
+  }
+  const wanted = `"v-${slug}"`;
+  let seen = 0;
+  const walk = async (folder) => {
+    let items;
+    try {
+      items = await readdir3(join12(cwd, folder), { withFileTypes: true });
+    } catch {
+      return null;
+    }
+    for (const item of items) {
+      if (seen >= SCAN_LIMIT || item.name.startsWith(".") || item.name === "node_modules")
+        continue;
+      const path = join12(folder, item.name);
+      if (item.isDirectory()) {
+        const found = await walk(path);
+        if (found !== null)
+          return found;
+        continue;
+      }
+      if (!SOURCE.test(item.name))
+        continue;
+      seen += 1;
+      const source = await readFile12(join12(cwd, path), "utf8").catch(() => "");
+      if (source.includes(wanted) && MAP.test(source))
+        return path;
+    }
+    return null;
+  };
+  for (const root of ["src", "app"]) {
+    const found = await walk(root);
+    if (found !== null)
+      return relative3(cwd, join12(cwd, found));
+  }
+  return null;
+}
+function readDirections(source) {
+  const imports = /* @__PURE__ */ new Map();
+  for (const match of source.matchAll(/^import \{ (\w+) \} from "([^"]+)";$/gm)) {
+    imports.set(match[1] ?? "", match[2] ?? "");
+  }
+  const body = MAP.exec(source)?.[1] ?? "";
+  const directions = [];
+  for (const match of body.matchAll(/"?([\w-]+)"?\s*:\s*(\w+)/g)) {
+    const key = match[1] ?? "";
+    const name = match[2] ?? "";
+    const from = imports.get(name);
+    if (from !== void 0)
+      directions.push({ key, name, from });
+  }
+  return directions;
+}
+function directionKeys(source) {
+  const body = MAP.exec(source)?.[1] ?? "";
+  return [...body.matchAll(/"?([\w-]+)"?\s*:/g)].flatMap((match) => match[1] === void 0 ? [] : [match[1]]);
+}
+function fallbackKey(source) {
+  return /const FALLBACK: \w+ = "([\w-]+)";/.exec(source)?.[1] ?? null;
+}
+function addSlots(source, slots) {
+  if (!MAP.test(source))
+    throw new Error("The switch file has no DIRECTIONS map.");
+  const lines2 = source.split("\n");
+  let last = -1;
+  lines2.forEach((line, index) => {
+    if (line.startsWith("import "))
+      last = index;
+  });
+  lines2.splice(last + 1, 0, ...slots.map((slot) => `import { ${slot.name} } from "./${slot.key}";`));
+  const added = slots.map((slot) => `  "${slot.key}": ${slot.name},`).join("\n");
+  return lines2.join("\n").replace(MAP, (_, body) => `const DIRECTIONS = {
+${body.replace(/^\s*\n|\s+$/g, "").replace(/,?$/, ",")}
+${added}
+} as const;`);
+}
+function placeholderSource(name) {
+  return `export function ${name}() {
+  return null;
+}
+`;
+}
+
+// ../server/dist/generation/facts.js
+var IMAGE = /\.(png|jpe?g|webp|avif|gif|svg)$/i;
+var IMAGE_LIMIT = 24;
+var EXAMPLE_LINES = 250;
+var VARIED_LINES = 600;
+function clip(source, limit) {
+  const lines2 = source.replace(/\n$/, "").split("\n");
+  if (lines2.length <= limit)
+    return source;
+  const hidden = lines2.length - limit;
+  return [
+    ...lines2.slice(0, limit),
+    `// \u2026 ${hidden} more ${hidden === 1 ? "line" : "lines"}, not shown`
+  ].join("\n");
+}
+var BASELINE_LINES = 15;
+var STUB = /Re-export what your|A first direction for/;
+async function text2(path) {
+  return readFile13(path, "utf8").catch(() => null);
+}
+async function firstFile(cwd, candidates) {
+  for (const candidate of candidates) {
+    if (await text2(join13(cwd, candidate)) !== null)
+      return candidate;
+  }
+  return null;
+}
+function cssImports(source, from) {
+  return [...source.matchAll(/import\s+["']([^"']+\.css)["']/g)].map((match) => normalize(join13(dirname7(from), match[1] ?? "")));
+}
+async function globalStylesheet(cwd) {
+  const entries = [];
+  const html = await text2(join13(cwd, "index.html"));
+  const script = html === null ? null : /<script[^>]+type="module"[^>]+src="\/?([^"]+)"/.exec(html);
+  if (script?.[1] !== void 0)
+    entries.push(script[1]);
+  for (const root of ["app", "src/app"]) {
+    for (const extension of ["tsx", "jsx", "ts", "js"])
+      entries.push(`${root}/layout.${extension}`);
+  }
+  const sheets = [];
+  for (const entry of entries) {
+    const source = await text2(join13(cwd, entry));
+    if (source !== null)
+      sheets.push(...cssImports(source, entry));
+  }
+  for (const sheet of sheets) {
+    const source = await text2(join13(cwd, sheet));
+    if (source !== null && /:root\s*\{|@font-face/.test(source))
+      return sheet;
+  }
+  return firstFile(cwd, sheets);
+}
+async function images(cwd) {
+  const found = [];
+  const walk = async (folder) => {
+    let items;
+    try {
+      items = await readdir4(join13(cwd, "public", folder), { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const item of items) {
+      if (found.length >= IMAGE_LIMIT || item.name.startsWith("."))
+        continue;
+      const path = folder === "" ? item.name : `${folder}/${item.name}`;
+      if (item.isDirectory())
+        await walk(path);
+      else if (IMAGE.test(item.name))
+        found.push(`/${path}`);
+    }
+  };
+  await walk("");
+  return found;
+}
+async function componentFile(cwd, from, specifier) {
+  const base = normalize(join13(dirname7(from), specifier));
+  return firstFile(cwd, [
+    base,
+    ...["tsx", "jsx", "ts", "js"].map((extension) => `${base}.${extension}`)
+  ]);
+}
+async function example(cwd, switchPath, prefer) {
+  const source = await text2(join13(cwd, switchPath));
+  if (source === null)
+    return null;
+  const directions = readDirections(source);
+  const first = prefer ?? fallbackKey(source);
+  const ordered = [...directions].sort((a, b) => Number(b.key === first) - Number(a.key === first));
+  for (const direction of ordered) {
+    const limit = direction.key === prefer ? VARIED_LINES : EXAMPLE_LINES;
+    const path = await componentFile(cwd, switchPath, direction.from);
+    const body = path === null ? null : await text2(join13(cwd, path));
+    if (path === null || body === null || body === placeholderSource(direction.name) || STUB.test(body))
+      continue;
+    if (body.split("\n").length < BASELINE_LINES) {
+      const target = /from\s+["'](\.[^"']+)["']/.exec(body)?.[1];
+      const followed = target === void 0 ? null : await componentFile(cwd, path, target);
+      const real = followed === null ? null : await text2(join13(cwd, followed));
+      if (followed !== null && real !== null) {
+        return {
+          key: direction.key,
+          path: followed,
+          source: clip(real, limit)
+        };
+      }
+      continue;
+    }
+    return { key: direction.key, path, source: clip(body, limit) };
+  }
+  return null;
+}
+async function dependencyNames(cwd) {
+  try {
+    const pkg = parseJson(await text2(join13(cwd, "package.json")) ?? "");
+    return isJsonRecord(pkg) && isJsonRecord(pkg.dependencies) ? Object.keys(pkg.dependencies) : [];
+  } catch {
+    return [];
+  }
+}
+async function readProjectFacts(cwd, switchPath, prefer = null) {
+  const dependencies = await dependencyNames(cwd);
+  const sheetPath = await globalStylesheet(cwd);
+  const css = sheetPath === null ? null : await text2(join13(cwd, sheetPath));
+  return {
+    dependencies,
+    stylesheet: sheetPath === null || css === null ? null : {
+      path: sheetPath,
+      fonts: [
+        ...new Set([...css.matchAll(/font-family:\s*["']([^"']+)["']/g)].map((match) => match[1] ?? ""))
+      ],
+      tokens: /:root\s*\{[\s\S]*?\n\}/.exec(css)?.[0] ?? ""
+    },
+    images: await images(cwd),
+    example: await example(cwd, switchPath, prefer)
+  };
+}
+function factsBlock(facts, surface, varied = null) {
+  const lines2 = [
+    "Leglas read the project for you. Follow its house style: differ in the idea, not in the craft."
+  ];
+  if (facts.dependencies.length > 0)
+    lines2.push(`Dependencies: ${facts.dependencies.join(", ")}.`);
+  if (facts.stylesheet !== null) {
+    const fonts = facts.stylesheet.fonts.length === 0 ? "" : ` It declares the fonts ${facts.stylesheet.fonts.join(", ")}.`;
+    lines2.push(`The global stylesheet ${facts.stylesheet.path} is already loaded on every page.${fonts}`);
+    if (facts.stylesheet.tokens !== "")
+      lines2.push("It sets these tokens:", "```css", facts.stylesheet.tokens, "```");
+  }
+  if (facts.images.length > 0)
+    lines2.push(`Images the project already serves from its root: ${facts.images.join(", ")}.`);
+  if (facts.example !== null) {
+    lines2.push(varied?.key === facts.example.key ? `${varied.title}, the direction being varied, is ${facts.example.path}. Its imports are relative to that file:` : `The ${surface}'s current direction, ${facts.example.path}, shows how directions here are written:`, "```tsx", facts.example.source.trimEnd(), "```");
+  }
+  return lines2.join("\n");
+}
+
+// ../server/dist/generation/prompts.js
+function described(base) {
+  const idea = base.idea.replace(/\.$/, "");
+  return idea === "" ? `"${base.title}"` : `"${base.title}" (${idea})`;
+}
+function steer(brief) {
+  if (brief === "")
+    return ".";
+  return `. What to explore: ${/[.!?]$/.test(brief) ? brief : `${brief}.`}`;
+}
+var ANSWER = "Answer from this brief alone: do not read, search or run anything. Reply with only a JSON array of objects with key (kebab-case), title and idea (one line).";
+function planPrompt(input) {
+  const { base } = input;
+  if (base !== void 0 && base !== null) {
+    return `Propose ${input.count} variations of the ${input.surface} direction ${described(base)}${steer(input.brief)} Every variation stays recognisably ${base.title} and changes one deliberate thing; name each for what it changes. Decide them together so no two change the same thing. ${ANSWER}`;
+  }
+  const already = input.existing.length === 0 ? "" : ` The ${input.surface} already has these directions: ${input.existing.join(", ")}; yours must differ from them too.`;
+  return `Propose ${input.count} genuinely different design directions for the ${input.surface} of this product: ${input.brief} Decide all of them together; if two would look alike at a glance, replace one.${already} ${ANSWER}`;
+}
+function replacePrompt2(input) {
+  const avoid = input.avoid.map((concept) => `${concept.title} (${concept.idea})`).join("; ");
+  const { base } = input;
+  if (base !== void 0 && base !== null) {
+    return `Propose 1 more variation of the ${input.surface} direction ${described(base)}${steer(input.brief)} It stays recognisably ${base.title} and changes something none of these change: ${avoid}. ${ANSWER}`;
+  }
+  return `Propose 1 design direction for the ${input.surface} of this product: ${input.brief} It must not look like any of these: ${avoid}. ${ANSWER}`;
+}
+function buildPrompt(input) {
+  const others = input.others.map((other) => `${other.title} (${other.idea})`).join("; ");
+  const { base } = input;
+  const varying = base !== void 0 && base !== null;
+  const rivals = others === "" ? "" : varying ? ` The other variations are ${others}; change something different from them.` : ` The other directions are ${others}; yours must not look like any of them.`;
+  const what = varying ? `Build this variation of the ${input.surface} direction "${base.title}": ${input.concept.title}, ${input.concept.idea.replace(/\.$/, "")}. Keep it recognisably ${base.title} and change only what the variation names.` : `Build this design direction for the ${input.surface}: ${input.concept.title}, ${input.concept.idea.replace(/\.$/, "")}.`;
+  const product = varying ? steer(input.brief).slice(1) : ` The product: ${input.brief}`;
+  return `${what}${product}${rivals}
+
+Everything you need is in this message, so do not look around the project. It is ${input.stack}. Your file is ${input.file}. It holds a placeholder: read it once, then replace it in a single write with a component exported as ${input.name}. Keep every new style in that file, in a <style> element or inline.
+
+${input.facts}
+
+This is a first draft for someone comparing directions side by side, not a finished page. Aim for about 250 lines and write it in one pass: no second drafts, and no review, lint, tests or screenshots. Leglas renders and captures it for you. Your task ends when the file is written.`;
+}
+function fixPrompt(input) {
+  return `Leglas rendered ${input.file} and the page reported: ${input.errors.slice(0, 3).join(" | ")}. Fix what your file causes, in as few edits as you can, and change nothing else. If nothing in your file causes it, change nothing. Do not look around the project.`;
+}
+function kebab(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function pascal(key) {
+  return key.split("-").filter((part) => part !== "").map((part) => /^\d/.test(part) ? `N${part}` : part[0].toUpperCase() + part.slice(1)).join("");
+}
+function parseConcepts(reply, count) {
+  const start = reply.indexOf("[");
+  const end = reply.lastIndexOf("]");
+  if (start === -1 || end < start)
+    throw new Error("The plan reply held no JSON array.");
+  let parsed;
+  try {
+    parsed = parseJson(reply.slice(start, end + 1));
+  } catch {
+    throw new Error("The plan reply's JSON did not parse.");
+  }
+  if (!Array.isArray(parsed))
+    throw new Error("The plan reply held no JSON array.");
+  const concepts = [];
+  for (const entry of parsed) {
+    if (!isJsonRecord(entry))
+      continue;
+    const title = isString(entry.title) ? entry.title.trim() : "";
+    const key = kebab(isString(entry.key) && entry.key.trim() !== "" ? entry.key : title);
+    if (title === "" || key === "" || concepts.some((concept) => concept.key === key))
+      continue;
+    concepts.push({ key, title, idea: isString(entry.idea) ? entry.idea.trim() : "" });
+    if (concepts.length === count)
+      return concepts;
+  }
+  throw new Error(`The plan reply named fewer than ${count} distinct directions.`);
+}
+
+// ../server/dist/generation/generation.js
+var MAX_DIRECTIONS = 6;
+var BUILD_DEADLINE_MS = 5 * 6e4;
+var PLAN_DEADLINE_MS = 2 * 6e4;
+var FIX_DEADLINE_MS = 3 * 6e4;
+var KILL_GRACE_MS = 5e3;
+var RECHECK_MS = 1500;
+var OWN_FAILURES = /* @__PURE__ */ new Set([
+  "broken",
+  "not-written",
+  "too-slow",
+  "unexpected"
+]);
+var BUSY = "A set of directions is already being built. Wait for it, or stop it first.";
+var KEPT_JOBS = 5;
+var CLAUDE = {
+  id: "claude",
+  name: "Claude",
+  plan: (prompt) => planArgs(prompt),
+  build: (prompt) => buildArgs(prompt),
+  result: resultText
+};
+function codex(servers) {
+  return {
+    id: "codex",
+    name: "Codex",
+    plan: (prompt) => codexPlanArgs(prompt, servers),
+    build: (prompt) => codexBuildArgs(prompt, servers),
+    result: codexResultText
+  };
+}
+function wait(milliseconds) {
+  return new Promise((resolve5) => {
+    setTimeout(resolve5, milliseconds).unref?.();
+  });
+}
+function surfaceSlug2(surface) {
+  return surface.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function baseOf(preview, surface) {
+  let key;
+  try {
+    key = new URL(preview.url, "http://leglas.invalid").searchParams.get(`v-${surfaceSlug2(surface)}`);
+  } catch {
+    return null;
+  }
+  return key === null || key === "" ? null : { title: preview.title, key, idea: preview.note ?? "" };
+}
+async function stackOf(cwd, switchPath) {
+  let deps = {};
+  try {
+    const pkg = parseJson(await readFile14(join14(cwd, "package.json"), "utf8"));
+    if (isJsonRecord(pkg)) {
+      for (const group of [pkg.devDependencies, pkg.dependencies]) {
+        if (!isJsonRecord(group))
+          continue;
+        for (const [name, version] of Object.entries(group)) {
+          if (isString(version))
+            deps[name] = version;
+        }
+      }
+    }
+  } catch {
+    deps = {};
+  }
+  const major = /\d+/.exec(deps.react ?? "")?.[0];
+  const react = major === void 0 ? "React" : `React ${major}`;
+  const typescript = switchPath.endsWith(".tsx") ? " and TypeScript" : "";
+  if (deps.next !== void 0)
+    return `a Next.js app with ${react}${typescript}`;
+  if (deps.vite !== void 0)
+    return `a Vite app with ${react}${typescript}`;
+  return `an app with ${react}${typescript}`;
+}
+function provenance(job) {
+  const words = job.surface.replace(/-/g, " ");
+  return {
+    askedFor: job.brief === "" ? void 0 : job.brief,
+    // Variations sit under the direction they vary, as any family does on the rail.
+    basedOn: job.basedOn ?? void 0,
+    tags: [words.charAt(0).toUpperCase() + words.slice(1)]
+  };
+}
+function copy(job) {
+  return {
+    ...job,
+    slots: job.slots.map((slot) => ({
+      ...slot,
+      failure: slot.failure === null ? null : { ...slot.failure }
+    }))
+  };
+}
+function createGenerations(deps) {
+  const now = deps.now ?? Date.now;
+  const spawn5 = deps.spawn ?? ((command, args, options) => nodeSpawn4(command, args, { ...options, env: agentEnvironment() }));
+  const lives = [];
+  let closed = false;
+  const busy = () => lives.some((live) => live.job.state === "planning" || live.job.state === "building");
+  const changed = () => deps.onChange();
+  let registry = Promise.resolve();
+  const serially = (task) => {
+    const next = registry.then(task, task);
+    registry = next.catch(() => {
+    });
+    return next;
+  };
+  const run4 = (agent, args, deadlineMs, onLine) => {
+    const lines2 = [];
+    let timedOut = false;
+    let child = null;
+    const done = new Promise((resolve5) => {
+      if (closed) {
+        resolve5({ code: null, lines: lines2, error: "Leglas is closing.", timedOut });
+        return;
+      }
+      try {
+        child = spawn5(agent.id, args, {
+          cwd: deps.cwd,
+          shell: false,
+          stdio: ["ignore", "pipe", "pipe"],
+          ...ownGroup()
+        });
+      } catch (error) {
+        resolve5({
+          code: null,
+          lines: lines2,
+          error: error instanceof Error ? error.message : String(error),
+          timedOut
+        });
+        return;
+      }
+      let buffered = "";
+      const take = (chunk) => {
+        buffered += chunk.toString();
+        const parts = buffered.split("\n");
+        buffered = parts.pop() ?? "";
+        lines2.push(...parts);
+        if (onLine !== void 0)
+          for (const line of parts)
+            onLine(line);
+      };
+      child.stdout.on("data", take);
+      child.stderr.on("data", take);
+      const deadline = setTimeout(() => {
+        timedOut = true;
+        if (child !== null)
+          signalTree(child, "SIGTERM");
+        setTimeout(() => {
+          if (child !== null)
+            signalTree(child, "SIGKILL");
+        }, KILL_GRACE_MS).unref?.();
+      }, deadlineMs);
+      deadline.unref?.();
+      child.once("error", (error) => {
+        clearTimeout(deadline);
+        resolve5({ code: null, lines: lines2, error: error.message, timedOut });
+      });
+      child.once("close", (code) => {
+        clearTimeout(deadline);
+        if (buffered !== "")
+          lines2.push(buffered);
+        resolve5({ code, lines: lines2, error: null, timedOut });
+      });
+    });
+    return {
+      done,
+      stop: async () => {
+        if (child === null)
+          return;
+        signalTree(child, "SIGTERM");
+        const exited = await Promise.race([
+          done.then(() => true),
+          wait(KILL_GRACE_MS).then(() => false)
+        ]);
+        if (!exited && child !== null) {
+          signalTree(child, "SIGKILL");
+          await Promise.race([done, wait(KILL_GRACE_MS)]);
+        }
+      }
+    };
+  };
+  const failureOf2 = (agent, outcome) => classifyFailure({
+    agent: agent.name,
+    error: outcome.error,
+    exitCode: outcome.code,
+    lines: outcome.lines.slice(-40)
+  });
+  const settle = (live) => {
+    const { job } = live;
+    for (const slot of job.slots) {
+      if (slot.state !== "building" && slot.state !== "checking")
+        slot.activity = null;
+    }
+    if (job.state === "planning" || job.state === "failed")
+      return;
+    if (job.slots.some((slot) => slot.state === "building" || slot.state === "checking")) {
+      job.state = "building";
+      return;
+    }
+    job.state = job.slots.every((slot) => slot.state === "stopped") ? "stopped" : "done";
+    job.endedAt = now();
+  };
+  const restore = async (slot) => {
+    await writeFile7(join14(deps.cwd, slot.file), placeholderSource(pascal(slot.key)), "utf8").catch(() => {
+    });
+  };
+  const begin = (live, slot) => {
+    const attempt = (live.attempts.get(slot.key) ?? 0) + 1;
+    live.attempts.set(slot.key, attempt);
+    return attempt;
+  };
+  const owns = (live, slot, attempt) => live.attempts.get(slot.key) === attempt;
+  const guarded = (work, onError) => work.catch((error) => onError(error instanceof Error ? error.message : String(error)));
+  const detach = (live, work, onError) => {
+    const kept = guarded(work, onError);
+    live.pending.add(kept);
+    void kept.then(() => live.pending.delete(kept));
+  };
+  const drain = async (live) => {
+    while (live.pending.size > 0)
+      await Promise.all(live.pending);
+  };
+  const release = async (live, slot) => {
+    const running = live.runs.get(slot.key);
+    await running?.stop();
+    await restore(slot);
+    if (running !== void 0 && live.runs.get(slot.key) === running)
+      live.runs.delete(slot.key);
+  };
+  const fail = (live, slot, failure) => {
+    slot.state = "failed";
+    slot.failure = failure;
+    slot.endedAt = now();
+    detach(live, restore(slot), () => {
+    });
+    if (OWN_FAILURES.has(failure.code))
+      return;
+    const same = live.job.slots.filter((other) => other.failure?.code === failure.code).length;
+    if (same >= 2) {
+      for (const other of live.job.slots) {
+        if (other.state !== "building" && other.state !== "checking")
+          continue;
+        begin(live, other);
+        other.state = "stopped";
+        other.failure = {
+          code: "same-failure",
+          message: `Stopped after two directions failed the same way: ${failure.message}`
+        };
+        other.endedAt = now();
+        detach(live, release(live, other), () => {
+        });
+      }
+    }
+  };
+  const lost = (live, slot, attempt, message2) => {
+    if (!owns(live, slot, attempt))
+      return;
+    fail(live, slot, { code: "unexpected", message: message2 });
+    settle(live);
+    changed();
+  };
+  const follow = (live, slot, attempt) => (line) => {
+    const activity = activityFrom(live.agent.id, line, deps.cwd);
+    if (activity === null || activity === slot.activity || !owns(live, slot, attempt))
+      return;
+    slot.activity = activity;
+    changed();
+  };
+  const build = async (live, slot, attempt) => {
+    const concept = live.concepts.get(slot.key);
+    if (concept === void 0 || !owns(live, slot, attempt))
+      return;
+    slot.state = "building";
+    if (slot.startedAt === null)
+      slot.startedAt = now();
+    slot.endedAt = null;
+    slot.failure = null;
+    slot.fixed = false;
+    slot.activity = null;
+    changed();
+    const others = [...live.concepts.values()].filter((other) => other !== concept);
+    const prompt = buildPrompt({
+      surface: live.job.surface,
+      brief: live.job.brief,
+      concept,
+      others,
+      file: slot.file,
+      name: pascal(slot.key),
+      stack: live.stack,
+      facts: live.facts ?? "",
+      base: live.base
+    });
+    const building = run4(live.agent, live.agent.build(prompt), BUILD_DEADLINE_MS, follow(live, slot, attempt));
+    live.runs.set(slot.key, building);
+    const outcome = await building.done;
+    if (!owns(live, slot, attempt))
+      return;
+    if (live.runs.get(slot.key) === building)
+      live.runs.delete(slot.key);
+    const written = await readFile14(join14(deps.cwd, slot.file), "utf8").catch(() => "");
+    if (!owns(live, slot, attempt))
+      return;
+    if (outcome.timedOut) {
+      fail(live, slot, {
+        code: "too-slow",
+        message: `The build took longer than ${BUILD_DEADLINE_MS / 6e4} minutes, so Leglas stopped it.`
+      });
+    } else if (outcome.error !== null || outcome.code !== 0) {
+      fail(live, slot, failureOf2(live.agent, outcome));
+    } else if (written === placeholderSource(pascal(slot.key))) {
+      fail(live, slot, {
+        code: "not-written",
+        message: "The build finished without writing its file."
+      });
+    } else {
+      slot.state = "checking";
+      slot.activity = null;
+      changed();
+      await check(live, slot, attempt);
+    }
+    settle(live);
+    changed();
+  };
+  const ownErrors = async (live, slot, attempt) => {
+    const others = live.job.slots.filter((other) => other !== slot);
+    const until = now() + BUILD_DEADLINE_MS + FIX_DEADLINE_MS;
+    for (; ; ) {
+      const report = await deps.render(slot.title);
+      if (!owns(live, slot, attempt))
+        return null;
+      const errors = report?.errors ?? [];
+      const names = (file) => errors.some((error) => error.includes(file));
+      const waiting = !names(slot.file) && others.some((other) => (other.state === "building" || other.state === "checking") && names(other.file));
+      if (!waiting || now() >= until) {
+        return errors.filter((error) => !others.some((other) => error.includes(other.file)));
+      }
+      await wait(RECHECK_MS);
+      if (!owns(live, slot, attempt))
+        return null;
+    }
+  };
+  const check = async (live, slot, attempt) => {
+    let errors = await ownErrors(live, slot, attempt);
+    if (errors === null)
+      return;
+    if (errors.length > 0) {
+      const fixing = run4(live.agent, live.agent.build(fixPrompt({ file: slot.file, errors })), FIX_DEADLINE_MS, follow(live, slot, attempt));
+      live.runs.set(slot.key, fixing);
+      const outcome = await fixing.done;
+      if (!owns(live, slot, attempt))
+        return;
+      slot.activity = null;
+      changed();
+      if (live.runs.get(slot.key) === fixing)
+        live.runs.delete(slot.key);
+      if (outcome.timedOut || outcome.error !== null || outcome.code !== 0) {
+        fail(live, slot, outcome.timedOut ? { code: "too-slow", message: "The fix took too long, so Leglas stopped it." } : failureOf2(live.agent, outcome));
+        return;
+      }
+      slot.fixed = true;
+      errors = await ownErrors(live, slot, attempt);
+      if (errors === null)
+        return;
+      if (errors.length > 0) {
+        fail(live, slot, {
+          code: "broken",
+          message: `The page still reports: ${errors[0] ?? ""}`
+        });
+        return;
+      }
+    }
+    slot.state = "ready";
+    slot.endedAt = now();
+  };
+  const freeTitle = (title, taken) => {
+    let candidate = title;
+    for (let suffix = 2; taken.has(candidate); suffix += 1)
+      candidate = `${title} ${suffix}`;
+    taken.add(candidate);
+    return candidate;
+  };
+  const plan = async (live, existing) => {
+    const { job } = live;
+    const planning = run4(live.agent, live.agent.plan(planPrompt({
+      surface: job.surface,
+      brief: job.brief,
+      count: job.count,
+      existing,
+      base: live.base
+    })), PLAN_DEADLINE_MS);
+    live.plan = planning;
+    const outcome = await planning.done;
+    live.plan = null;
+    if (job.state !== "planning")
+      return;
+    if (outcome.timedOut || outcome.error !== null || outcome.code !== 0) {
+      job.state = "failed";
+      job.error = outcome.timedOut ? "Planning took too long, so Leglas stopped it." : failureOf2(live.agent, outcome).message;
+      job.endedAt = now();
+      changed();
+      return;
+    }
+    let concepts;
+    try {
+      concepts = parseConcepts(live.agent.result(outcome.lines) ?? "", job.count);
+    } catch (error) {
+      job.state = "failed";
+      job.error = error instanceof Error ? error.message : String(error);
+      job.endedAt = now();
+      changed();
+      return;
+    }
+    live.facts = factsBlock(await readProjectFacts(deps.cwd, live.switchPath, live.base?.key ?? null), job.surface, live.base);
+    const slug = surfaceSlug2(job.surface);
+    const keys = new Set(existing);
+    const titles = new Set(await deps.titles());
+    const folder = dirname8(live.switchPath);
+    const slots = [];
+    const extension = live.switchPath.endsWith(".jsx") ? "jsx" : "tsx";
+    const taken = async (key) => keys.has(key) || await isFile(join14(deps.cwd, folder, `${key}.${extension}`));
+    for (const concept of concepts) {
+      let key = `${slug}-${concept.key}`;
+      for (let suffix = 2; await taken(key); suffix += 1)
+        key = `${slug}-${concept.key}-${suffix}`;
+      keys.add(key);
+      const title = freeTitle(concept.title, titles);
+      live.concepts.set(key, { ...concept, title });
+      slots.push({
+        key,
+        title,
+        idea: concept.idea,
+        file: join14(folder, `${key}.${extension}`),
+        state: "building",
+        startedAt: null,
+        endedAt: null,
+        failure: null,
+        fixed: false,
+        activity: null
+      });
+    }
+    const source = await readFile14(join14(deps.cwd, live.switchPath), "utf8");
+    for (const slot of slots) {
+      await writeFile7(join14(deps.cwd, slot.file), placeholderSource(pascal(slot.key)), {
+        encoding: "utf8",
+        flag: "wx"
+      });
+    }
+    await writeFile7(join14(deps.cwd, live.switchPath), addSlots(source, slots.map((slot) => ({ key: slot.key, name: pascal(slot.key) }))), "utf8");
+    for (const slot of slots) {
+      await serially(() => deps.register({
+        title: slot.title,
+        url: `/?v-${slug}=${slot.key}`,
+        note: slot.idea,
+        ...provenance(job)
+      }));
+    }
+    job.slots = slots;
+    if (job.state !== "planning") {
+      for (const slot of slots) {
+        slot.state = "stopped";
+        slot.endedAt = now();
+      }
+      changed();
+      return;
+    }
+    job.state = "building";
+    job.plannedAt = now();
+    changed();
+    await Promise.all(job.slots.map((slot) => {
+      const attempt = begin(live, slot);
+      return guarded(build(live, slot, attempt), (message2) => lost(live, slot, attempt, message2));
+    }));
+  };
+  const find = (id) => lives.find((live) => live.job.id === id);
+  const stop = async (id, key) => {
+    const live = find(id);
+    if (live === void 0)
+      return false;
+    const { job } = live;
+    if (key === void 0 && job.state === "planning") {
+      job.state = "stopped";
+      job.endedAt = now();
+      changed();
+      await live.plan?.stop();
+      await drain(live);
+      return true;
+    }
+    const targets = job.slots.filter((slot) => (key === void 0 || slot.key === key) && (slot.state === "building" || slot.state === "checking"));
+    for (const slot of targets) {
+      begin(live, slot);
+      slot.state = "stopped";
+      slot.endedAt = now();
+    }
+    settle(live);
+    changed();
+    await Promise.all(targets.map((slot) => release(live, slot)));
+    return targets.length > 0;
+  };
+  return {
+    async start(request) {
+      if (closed)
+        return { ok: false, error: "Leglas is closing." };
+      const agent = request.agent.agent;
+      if (agent !== "claude" && agent !== "codex") {
+        return {
+          ok: false,
+          error: "Building directions runs on Claude or Codex. Choose one of them as the agent to use it."
+        };
+      }
+      const count = Math.floor(request.count);
+      if (!Number.isFinite(count) || count < 1 || count > MAX_DIRECTIONS) {
+        return { ok: false, error: `Ask for between 1 and ${MAX_DIRECTIONS} directions.` };
+      }
+      const brief = request.brief.trim();
+      const base = request.basedOn ?? null;
+      if (brief === "" && base === null)
+        return { ok: false, error: "Describe what the directions are for." };
+      const slug = surfaceSlug2(request.surface);
+      if (slug === "")
+        return { ok: false, error: "Name the surface to build directions for." };
+      if (busy())
+        return { ok: false, error: BUSY };
+      const switchPath = await findSwitch(deps.cwd, slug);
+      if (switchPath === null) {
+        return {
+          ok: false,
+          error: `The ${slug} has no switch file yet. Run \`leglas new ${slug} --from <your component>\` and render ${pascal(slug)}Switch where the ${slug} is, then build directions into it.`
+        };
+      }
+      const existing = directionKeys(await readFile14(join14(deps.cwd, switchPath), "utf8"));
+      if (base !== null && !existing.includes(base.key)) {
+        return {
+          ok: false,
+          error: `${base.title} is not a direction of the ${slug}, so Leglas cannot build variations of it.`
+        };
+      }
+      const unbuilt = base === null ? void 0 : lives.flatMap((kept) => kept.job.slots).find((slot) => slot.key === base.key && slot.state !== "ready");
+      if (base !== null && unbuilt !== void 0) {
+        return {
+          ok: false,
+          error: `${base.title} has no finished design yet, so there is nothing to vary. Retry it first.`
+        };
+      }
+      const job = {
+        id: `gen-${now().toString(36)}`,
+        surface: slug,
+        brief,
+        count,
+        state: "planning",
+        startedAt: now(),
+        plannedAt: null,
+        endedAt: null,
+        error: null,
+        slots: [],
+        basedOn: base?.title ?? null,
+        agent
+      };
+      const live = {
+        job,
+        concepts: /* @__PURE__ */ new Map(),
+        runs: /* @__PURE__ */ new Map(),
+        plan: null,
+        switchPath,
+        facts: null,
+        stack: await stackOf(deps.cwd, switchPath),
+        attempts: /* @__PURE__ */ new Map(),
+        base,
+        agent: agent === "codex" ? codex(await codexServers(deps.codexHome)) : CLAUDE,
+        pending: /* @__PURE__ */ new Set()
+      };
+      if (busy())
+        return { ok: false, error: BUSY };
+      lives.push(live);
+      while (lives.length > KEPT_JOBS)
+        lives.shift();
+      changed();
+      detach(live, plan(live, existing), (message2) => {
+        job.state = "failed";
+        job.error = message2;
+        job.endedAt = now();
+        changed();
+      });
+      return { ok: true, job: copy(job) };
+    },
+    snapshot: () => lives.map((live) => copy(live.job)),
+    stop,
+    retry(id, key) {
+      const live = find(id);
+      const slot = live?.job.slots.find((candidate) => candidate.key === key);
+      if (closed || live === void 0 || slot === void 0 || slot.state !== "failed" && slot.state !== "stopped" || live.runs.has(slot.key))
+        return false;
+      const attempt = begin(live, slot);
+      slot.state = "building";
+      slot.startedAt = now();
+      slot.failure = null;
+      detach(live, restore(slot).then(() => build(live, slot, attempt)), (message2) => lost(live, slot, attempt, message2));
+      live.job.state = "building";
+      live.job.endedAt = null;
+      changed();
+      return true;
+    },
+    replace(id, key) {
+      const live = find(id);
+      const slot = live?.job.slots.find((candidate) => candidate.key === key);
+      if (closed || live === void 0 || slot === void 0 || slot.state === "building" || slot.state === "checking" || live.runs.has(slot.key))
+        return false;
+      const attempt = begin(live, slot);
+      slot.state = "building";
+      slot.startedAt = now();
+      slot.failure = null;
+      live.job.state = "building";
+      live.job.endedAt = null;
+      changed();
+      const replacing = async () => {
+        const asking = run4(live.agent, live.agent.plan(replacePrompt2({
+          surface: live.job.surface,
+          brief: live.job.brief,
+          avoid: [...live.concepts.values()],
+          base: live.base
+        })), PLAN_DEADLINE_MS);
+        live.runs.set(slot.key, asking);
+        const outcome = await asking.done;
+        if (!owns(live, slot, attempt))
+          return;
+        if (live.runs.get(slot.key) === asking)
+          live.runs.delete(slot.key);
+        let concept;
+        try {
+          if (outcome.code !== 0)
+            throw new Error(failureOf2(live.agent, outcome).message);
+          concept = parseConcepts(live.agent.result(outcome.lines) ?? "", 1)[0];
+        } catch (error) {
+          fail(live, slot, {
+            code: "unreadable-plan",
+            message: error instanceof Error ? error.message : String(error)
+          });
+          settle(live);
+          changed();
+          return;
+        }
+        const titles = new Set(await deps.titles());
+        if (!owns(live, slot, attempt))
+          return;
+        titles.delete(slot.title);
+        const title = freeTitle(concept.title, titles);
+        await serially(async () => {
+          await deps.unregister([slot.title]);
+          return deps.register({
+            title,
+            url: `/?v-${surfaceSlug2(live.job.surface)}=${slot.key}`,
+            note: concept.idea,
+            ...provenance(live.job)
+          });
+        });
+        live.concepts.set(slot.key, { ...concept, title });
+        slot.title = title;
+        slot.idea = concept.idea;
+        if (!owns(live, slot, attempt))
+          return;
+        await restore(slot);
+        await build(live, slot, attempt);
+      };
+      detach(live, replacing(), (message2) => lost(live, slot, attempt, message2));
+      return true;
+    },
+    async close() {
+      closed = true;
+      await Promise.race([
+        Promise.all(lives.map(async (live) => {
+          await stop(live.job.id);
+          await drain(live);
+        })),
+        wait(KILL_GRACE_MS * 2 + 1e3)
+      ]);
+    }
+  };
+}
+
 // ../server/dist/server-info.js
-import { lstat as lstat2, mkdir as mkdir7, readFile as readFile11, rename as rename2, rm as rm4, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname7, join as join11 } from "path";
+import { lstat as lstat2, mkdir as mkdir7, readFile as readFile15, rename as rename2, rm as rm4, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname9, join as join15 } from "path";
 var SERVER_INFO_PATH = ".leglas/server.json";
 async function writeServerInfo(cwd, info) {
-  const path = join11(cwd, SERVER_INFO_PATH);
-  const directory = dirname7(path);
+  const path = join15(cwd, SERVER_INFO_PATH);
+  const directory = dirname9(path);
   await mkdir7(directory, { recursive: true });
   if (!(await lstat2(directory)).isDirectory())
     return;
@@ -7361,7 +8550,7 @@ async function writeServerInfo(cwd, info) {
   if (existing !== null && !existing.isFile())
     return;
   const temporary = `${path}.${process.pid}.tmp`;
-  await writeFile7(temporary, `${JSON.stringify({ ...info, startedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
+  await writeFile8(temporary, `${JSON.stringify({ ...info, startedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
 `, "utf8");
   await rename2(temporary, path).catch(async (cause) => {
     await rm4(temporary, { force: true }).catch(() => {
@@ -7371,7 +8560,7 @@ async function writeServerInfo(cwd, info) {
 }
 async function readServerInfo(cwd) {
   try {
-    const value = parseJson(await readFile11(join11(cwd, SERVER_INFO_PATH), "utf8"));
+    const value = parseJson(await readFile15(join15(cwd, SERVER_INFO_PATH), "utf8"));
     if (!isJsonRecord(value) || !isNumber(value.port) || !Number.isInteger(value.port) || value.port < 1 || value.port > 65535 || !isString(value.url) || value.url === "" || !isNumber(value.pid) || !Number.isInteger(value.pid))
       return null;
     return { port: value.port, url: value.url, pid: value.pid };
@@ -7385,7 +8574,7 @@ async function removeServerInfo(cwd, expected) {
     if (current !== null && (current.port !== expected.port || current.pid !== expected.pid))
       return;
   }
-  await rm4(join11(cwd, SERVER_INFO_PATH), { force: true });
+  await rm4(join15(cwd, SERVER_INFO_PATH), { force: true });
 }
 
 // ../server/dist/server.js
@@ -7546,8 +8735,8 @@ function probe(target, timeoutMs = 1e3) {
   });
 }
 function serveFrom(res, dir, relativePath) {
-  const relative6 = normalize(relativePath).replace(/^(\.\.[/\\])+/, "");
-  const candidate = join12(dir, relative6);
+  const relative8 = normalize2(relativePath).replace(/^(\.\.[/\\])+/, "");
+  const candidate = join16(dir, relative8);
   if (!candidate.startsWith(dir))
     return false;
   if (!existsSync3(candidate) || !statSync(candidate).isFile())
@@ -7561,25 +8750,25 @@ function serveFrom(res, dir, relativePath) {
   return true;
 }
 function serveShellFile(res, shellDir, urlPath) {
-  const relative6 = normalize(urlPath.slice(LEGLAS_PREFIX.length)).replace(/^(\.\.[/\\])+/, "");
-  const isRoot = relative6 === "" || relative6 === "." || relative6 === "/";
-  return serveFrom(res, shellDir, isRoot ? "index.html" : relative6);
+  const relative8 = normalize2(urlPath.slice(LEGLAS_PREFIX.length)).replace(/^(\.\.[/\\])+/, "");
+  const isRoot = relative8 === "" || relative8 === "." || relative8 === "/";
+  return serveFrom(res, shellDir, isRoot ? "index.html" : relative8);
 }
 var HEALTH_PROBE_MS = 3e3;
 function fileStamp(path) {
   try {
-    const stat5 = statSync(path);
-    return `${stat5.dev}:${stat5.ino}:${stat5.size}:${stat5.mtimeMs}:${stat5.ctimeMs}`;
+    const stat6 = statSync(path);
+    return `${stat6.dev}:${stat6.ino}:${stat6.size}:${stat6.mtimeMs}:${stat6.ctimeMs}`;
   } catch {
     return null;
   }
 }
 function watchLiveFiles(cwd, configPath, live) {
-  const leglasDir = join12(cwd, ".leglas");
+  const leglasDir = join16(cwd, ".leglas");
   const targets = [
-    { path: join12(cwd, LOCAL_PREVIEWS_PATH), change: "config" },
-    { path: join12(cwd, REQUESTS_PATH), change: "requests" },
-    { path: join12(cwd, ANNOTATIONS_PATH), change: "requests" }
+    { path: join16(cwd, LOCAL_PREVIEWS_PATH), change: "config" },
+    { path: join16(cwd, REQUESTS_PATH), change: "requests" },
+    { path: join16(cwd, ANNOTATIONS_PATH), change: "requests" }
   ];
   const byName = new Map(targets.map((target) => [basename3(target.path), target]));
   const known = new Map(targets.map((target) => [target.path, fileStamp(target.path)]));
@@ -7693,7 +8882,7 @@ function watchLiveFiles(cwd, configPath, live) {
   }
   if (configPath !== null) {
     try {
-      const directory = dirname8(configPath);
+      const directory = dirname10(configPath);
       const name = basename3(configPath);
       const target = { path: configPath, change: "config" };
       known.set(configPath, fileStamp(configPath));
@@ -7731,7 +8920,7 @@ function watchLiveFiles(cwd, configPath, live) {
     }
   };
 }
-function watchHealth(target, live) {
+function watchHealth(target, live, intervalMs) {
   let previous = null;
   let probing = false;
   let closed = false;
@@ -7754,7 +8943,7 @@ function watchHealth(target, live) {
     }).finally(() => {
       probing = false;
     });
-  }, HEALTH_PROBE_MS);
+  }, intervalMs);
   timer.unref?.();
   return {
     close: () => {
@@ -7778,15 +8967,15 @@ function configStalenessNotice(cwd, boot, current) {
   if (boot === null && current === null)
     return null;
   if (boot === null && current !== null) {
-    const label = relative3(cwd, current.path) || current.path;
+    const label = relative4(cwd, current.path) || current.path;
     return `${label} appeared after Leglas started. Restart leglas to pick it up.`;
   }
   if (boot !== null && current === null) {
-    const label = relative3(cwd, boot.path) || boot.path;
+    const label = relative4(cwd, boot.path) || boot.path;
     return `${label} was removed after Leglas started. Restart leglas to run without it.`;
   }
   if (boot !== null && current !== null && (boot.path !== current.path || boot.mtimeMs !== current.mtimeMs)) {
-    const label = relative3(cwd, current.path) || current.path;
+    const label = relative4(cwd, current.path) || current.path;
     return `${label} changed after Leglas started. Restart leglas to pick it up.`;
   }
   return null;
@@ -7832,7 +9021,7 @@ async function bind2(server, requested) {
   throw new Error(`No free port between ${requested} and ${requested + PORT_ATTEMPTS - 1}.`);
 }
 async function startServer(options) {
-  const { config, configErrors = [], configWarnings = [], shellDir = null, project = "", cwd = process.cwd(), leglasCommand = "npx -y leglas", fileMounts = /* @__PURE__ */ new Map(), detect = () => detectAgents() } = options;
+  const { config, configErrors = [], configWarnings = [], shellDir = null, project = "", cwd = process.cwd(), leglasCommand = "npx -y leglas", fileMounts = /* @__PURE__ */ new Map(), detect = () => detectAgents(), captureDeadlineMs = CAPTURE_DEADLINE_MS, healthProbeMs = HEALTH_PROBE_MS } = options;
   const browserPool = options.pool ?? createBrowserPool();
   let shares = null;
   let liveHealth = null;
@@ -7877,6 +9066,7 @@ async function startServer(options) {
   let lastSeen = null;
   const externallyAttached = () => lastSeen !== null && Date.now() - lastSeen < ATTACHED_WINDOW_MS;
   let runner = null;
+  let generations = null;
   let agentsCache = null;
   let agentsInflight = null;
   const AGENTS_FRESH_MS = 3e4;
@@ -7927,11 +9117,36 @@ async function startServer(options) {
       });
     });
   };
+  const readGenerationBody = (req, res, run4) => {
+    if (!hasJsonBody(req)) {
+      return sendJson2(res, 400, { ok: false, error: "A generation request must be JSON." });
+    }
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => {
+      const parsed = jsonBody(body);
+      if (parsed === null)
+        return sendJson2(res, 400, { ok: false, error: "Body must be JSON." });
+      if (generations === null)
+        return sendJson2(res, 503, { ok: false, error: "Leglas is still starting." });
+      void run4(parsed, generations);
+    });
+  };
+  const actOnGeneration = async (res, action, parsed, act) => {
+    if (!isString(parsed.id) || parsed.slot !== void 0 && !isString(parsed.slot)) {
+      return sendJson2(res, 400, {
+        ok: false,
+        error: "Name the generation by its id, and the direction by its slot."
+      });
+    }
+    const done = await act(parsed.id, isString(parsed.slot) ? parsed.slot : void 0);
+    return done ? sendJson2(res, 200, { ok: true }) : sendJson2(res, 409, { ok: false, error: `Nothing to ${action} there right now.` });
+  };
   const handleRequest = (req, res, context) => {
     const url = req.url ?? "/";
     const path = url.split("?")[0] ?? "/";
     const query = new URLSearchParams(url.includes("?") ? url.slice(url.indexOf("?") + 1) : "");
-    if (!context.remote && req.method === "POST" && path.startsWith(`${LEGLAS_PREFIX}/api/`) && !isTrustedMutation(req)) {
+    if (!context.remote && req.method !== "GET" && req.method !== "HEAD" && path.startsWith(`${LEGLAS_PREFIX}/api/`) && !isTrustedMutation(req)) {
       return sendJson2(res, 403, { ok: false, error: "Cross-origin API mutations are refused." });
     }
     if (context.remote && path === `${LEGLAS_PREFIX}/api/config`) {
@@ -7949,6 +9164,48 @@ async function startServer(options) {
     if (context.remote && path.startsWith(`${LEGLAS_PREFIX}/api/`)) {
       return sendJson2(res, 403, { error: "Not available to viewers." });
     }
+    if (path === `${LEGLAS_PREFIX}/api/generate` && req.method === "GET") {
+      return sendJson2(res, 200, { ok: true, jobs: generations?.snapshot() ?? [] });
+    }
+    if (path === `${LEGLAS_PREFIX}/api/generate` && req.method === "POST") {
+      return void readGenerationBody(req, res, async (parsed, running) => {
+        if (!isString(parsed.surface) || !isString(parsed.brief)) {
+          return sendJson2(res, 400, {
+            ok: false,
+            error: "Name a surface and describe the directions in a brief."
+          });
+        }
+        let basedOn = null;
+        if (parsed.basedOn !== void 0 && parsed.basedOn !== null && parsed.basedOn !== "") {
+          const title = parsed.basedOn;
+          const preview = isString(title) ? (await livePreviews()).find((entry) => entry.title === title) : void 0;
+          basedOn = preview === void 0 ? null : baseOf(preview, parsed.surface);
+          if (basedOn === null) {
+            return sendJson2(res, 422, {
+              ok: false,
+              error: `${isString(title) ? title : "That"} is not a direction of the ${surfaceSlug2(parsed.surface)}, so Leglas cannot build variations of it.`
+            });
+          }
+        }
+        const started = await running.start({
+          surface: parsed.surface,
+          brief: parsed.brief,
+          count: isNumber(parsed.count) ? parsed.count : 3,
+          agent: await readAgentChoice(cwd),
+          basedOn
+        });
+        return started.ok ? sendJson2(res, 202, { ok: true, job: started.job }) : sendJson2(res, 422, { ok: false, error: started.error });
+      });
+    }
+    if (path === `${LEGLAS_PREFIX}/api/generate/stop` && req.method === "POST") {
+      return void readGenerationBody(req, res, (parsed, running) => actOnGeneration(res, "stop", parsed, (id, slot) => running.stop(id, slot)));
+    }
+    if (path === `${LEGLAS_PREFIX}/api/generate/retry` && req.method === "POST") {
+      return void readGenerationBody(req, res, (parsed, running) => actOnGeneration(res, "retry", parsed, (id, slot) => slot === void 0 ? false : running.retry(id, slot)));
+    }
+    if (path === `${LEGLAS_PREFIX}/api/generate/replace` && req.method === "POST") {
+      return void readGenerationBody(req, res, (parsed, running) => actOnGeneration(res, "replace", parsed, (id, slot) => slot === void 0 ? false : running.replace(id, slot)));
+    }
     if (path === `${LEGLAS_PREFIX}/api/update` && req.method === "GET" || req.method === "POST" && ["check", "skip", "install"].some((action) => path === `${LEGLAS_PREFIX}/api/update/${action}`)) {
       const updates = options.updates;
       if (updates === void 0) {
@@ -8212,8 +9469,8 @@ async function startServer(options) {
         const id = newRequestId();
         const file = `${REFERENCES_DIR}/${id}.${image.kind}`;
         try {
-          await mkdir8(join12(cwd, REFERENCES_DIR), { recursive: true });
-          await writeFile8(join12(cwd, file), body);
+          await mkdir8(join16(cwd, REFERENCES_DIR), { recursive: true });
+          await writeFile9(join16(cwd, file), body);
           void pruneReferences(cwd).catch(() => {
           });
           return sendJson2(res, 200, {
@@ -8255,7 +9512,7 @@ async function startServer(options) {
         }
         const references = parsed.references ?? [];
         if (references.length > 0) {
-          const present = new Set((await readdir3(join12(cwd, REFERENCES_DIR)).catch(() => [])).map((name) => name.slice(0, name.indexOf(".") === -1 ? name.length : name.indexOf("."))));
+          const present = new Set((await readdir5(join16(cwd, REFERENCES_DIR)).catch(() => [])).map((name) => name.slice(0, name.indexOf(".") === -1 ? name.length : name.indexOf("."))));
           const gone = references.filter((id2) => !present.has(id2));
           if (gone.length > 0) {
             return sendJson2(res, 410, {
@@ -8385,7 +9642,7 @@ async function startServer(options) {
         const timer = setTimeout(() => {
           timedOut();
           controller.abort();
-        }, CAPTURE_DEADLINE_MS);
+        }, captureDeadlineMs);
         timer.unref?.();
         try {
           const captureInput = {
@@ -8418,8 +9675,8 @@ async function startServer(options) {
           const noteSuffix = isString(parsed.note) ? `-${parsed.note.replace(/[^A-Za-z0-9_-]+/g, "-")}` : "";
           const name = `${captureSlug(preview.title)}-${result.frame.width}${noteSuffix}.png`;
           const relativeFile = `${CAPTURES_DIR}/show/${name}`;
-          await mkdir8(join12(cwd, CAPTURES_DIR, "show"), { recursive: true });
-          await writeFile8(join12(cwd, relativeFile), shot.png);
+          await mkdir8(join16(cwd, CAPTURES_DIR, "show"), { recursive: true });
+          await writeFile9(join16(cwd, relativeFile), shot.png);
           return sendJson2(res, 200, {
             ok: true,
             file: relativeFile,
@@ -8799,15 +10056,15 @@ async function startServer(options) {
       const rest = path.slice(FILES_PREFIX.length + 1);
       const slash = rest.indexOf("/");
       const slug = slash === -1 ? rest : rest.slice(0, slash);
-      let relative6 = slash === -1 ? "" : rest.slice(slash + 1);
+      let relative8 = slash === -1 ? "" : rest.slice(slash + 1);
       try {
-        relative6 = decodeURIComponent(relative6);
+        relative8 = decodeURIComponent(relative8);
       } catch {
-        relative6 = "";
+        relative8 = "";
       }
       const dir = fileMounts.get(slug);
       const serveMount = () => {
-        if (dir !== void 0 && relative6 !== "" && serveFrom(res, dir, relative6))
+        if (dir !== void 0 && relative8 !== "" && serveFrom(res, dir, relative8))
           return;
         res.writeHead(404, {
           "content-type": "text/plain; charset=utf-8",
@@ -8817,7 +10074,7 @@ async function startServer(options) {
       };
       if (!context.remote)
         return serveMount();
-      if (relative6.split("/").some((segment) => segment.startsWith("."))) {
+      if (relative8.split("/").some((segment) => segment.startsWith("."))) {
         return sendJson2(res, 403, { ok: false, error: "Not available to viewers." });
       }
       return void (shares?.fileSlugAllowed(slug, context.grantId ?? "") ?? Promise.resolve(false)).then((allowed) => {
@@ -8898,7 +10155,7 @@ async function startServer(options) {
   port = await bind2(server, options.port ?? DEFAULT_PORT);
   options.updates?.setPort(port);
   const liveFiles = watchLiveFiles(cwd, bootConfigPath, live);
-  liveHealth = watchHealth(target, live);
+  liveHealth = watchHealth(target, live, healthProbeMs);
   await pruneCaptures(cwd, (await readRequests(cwd).catch(() => [])).map((request) => request.id)).catch(() => {
   });
   await writeServerInfo(cwd, {
@@ -8918,6 +10175,42 @@ async function startServer(options) {
   if (options.claudeAgentSession !== void 0)
     runnerOptions.claudeAgentSession = options.claudeAgentSession;
   runner = startRunner(runnerOptions);
+  const renderDirection = async (title) => {
+    const preview = (await livePreviews()).find((entry) => entry.title === title);
+    if (preview === void 0)
+      return null;
+    const browser = await browserPool.acquire();
+    if (browser === null)
+      return null;
+    const address = server.address();
+    const renderPort = address !== null && !isString(address) ? address.port : options.port ?? DEFAULT_PORT;
+    try {
+      const captured = await capturePage(browser, {
+        url: previewUrl(`http://127.0.0.1:${renderPort}`, preview),
+        width: 1440,
+        timeoutMs: CAPTURE_LOAD_MS
+      });
+      return { errors: captured.errors };
+    } catch (error) {
+      return { errors: [error instanceof Error ? error.message : String(error)] };
+    }
+  };
+  const generationDeps = {
+    cwd,
+    render: renderDirection,
+    register: (input) => addLocalPreview(cwd, input, (config?.previews ?? []).filter((entry) => entry.local !== true)),
+    unregister: async (titles) => {
+      await dropLocalPreviews(cwd, titles);
+    },
+    titles: async () => {
+      const local = await readLocalPreviews(cwd).catch(() => null);
+      return new Set([...config?.previews ?? [], ...local?.previews ?? []].map((entry) => entry.title));
+    },
+    onChange: () => live.nudge("generation")
+  };
+  if (options.generationSpawn !== void 0)
+    generationDeps.spawn = options.generationSpawn;
+  generations = createGenerations(generationDeps);
   options.updates?.onBusy(() => runner?.snapshot().running ?? false);
   options.updates?.onChange(() => live.nudge("update"));
   let closePromise = null;
@@ -8935,6 +10228,7 @@ async function startServer(options) {
           shares?.close() ?? Promise.resolve(),
           branches.stop(),
           runner.stop(),
+          generations?.close() ?? Promise.resolve(),
           browserPool.close(),
           live.close()
         ]);
@@ -8956,9 +10250,9 @@ async function startServer(options) {
 // ../server/dist/update.js
 import { spawn as spawnChild2 } from "child_process";
 import { existsSync as existsSync4, readFileSync, realpathSync } from "fs";
-import { lstat as lstat3, mkdir as mkdir9, mkdtemp, rename as rename3, rm as rm5, writeFile as writeFile9 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname9, join as join13, posix as posix2, win32 } from "path";
+import { lstat as lstat3, mkdir as mkdir9, mkdtemp, rename as rename3, rm as rm5, writeFile as writeFile10 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname11, join as join17, posix as posix2, win32 } from "path";
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var INSTALL_DEADLINE_MS = 5 * 60 * 1e3;
 
@@ -8991,8 +10285,8 @@ function planKeep(options) {
       error: `Cannot tell which file produces ${JSON.stringify(options.title)}. Its URL (${winner.url}) was not generated by leglas new, so there is nothing safe to move.`
     };
   }
-  const to = normalize2(options.to);
-  if (to.startsWith("..")) {
+  const to = normalize3(options.to);
+  if (to.startsWith("..") || isAbsolute2(to)) {
     return { ok: false, error: "The destination has to be inside the project." };
   }
   if (to.split(/[/\\]/)[0] === ".leglas") {
@@ -9017,11 +10311,11 @@ function planKeep(options) {
 }
 
 // src/run-init.ts
-import { readFile as readFile12, writeFile as writeFile10 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile16, writeFile as writeFile11 } from "fs/promises";
+import { join as join18 } from "path";
 async function readIfPresent(path) {
   try {
-    return await readFile12(path, "utf8");
+    return await readFile16(path, "utf8");
   } catch {
     return null;
   }
@@ -9029,18 +10323,18 @@ async function readIfPresent(path) {
 async function runInit(options, deps) {
   const existingConfig = findConfigFile(options.cwd);
   const plan = planInit({
-    agents: await readIfPresent(join14(options.cwd, "AGENTS.md")),
+    agents: await readIfPresent(join18(options.cwd, "AGENTS.md")),
     config: existingConfig === null ? null : "present",
-    gitignore: await readIfPresent(join14(options.cwd, ".gitignore")),
+    gitignore: await readIfPresent(join18(options.cwd, ".gitignore")),
     force: options.force
   });
   const touched = [];
   for (const write2 of plan.writes) {
-    await writeFile10(join14(options.cwd, write2.path), write2.contents, "utf8");
+    await writeFile11(join18(options.cwd, write2.path), write2.contents, "utf8");
     touched.push(write2.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile10(join14(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile11(join18(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     touched.push(".gitignore");
   }
   if (options.json) {
@@ -9060,8 +10354,8 @@ async function runInit(options, deps) {
 
 // src/run-keep.ts
 import { existsSync as existsSync5 } from "fs";
-import { copyFile as copyFile2, mkdir as mkdir10, readFile as readFile13, rm as rm6, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname10, join as join15 } from "path";
+import { copyFile as copyFile2, mkdir as mkdir10, readFile as readFile17, rm as rm6, writeFile as writeFile12 } from "fs/promises";
+import { dirname as dirname12, isAbsolute as isAbsolute3, join as join19, relative as relative5 } from "path";
 
 // src/resolve-title.ts
 function resolveOrExplain(input, titles, renames) {
@@ -9094,15 +10388,15 @@ async function writeLogEntry(options) {
     annotations: await readAnnotations(options.cwd),
     date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
   });
-  const dir = join15(options.cwd, options.logDir);
+  const dir = join19(options.cwd, options.logDir);
   await mkdir10(dir, { recursive: true });
-  const file = join15(dir, `${entry.slug}.md`);
-  await writeFile11(file, entry.markdown, "utf8");
+  const file = join19(dir, `${entry.slug}.md`);
+  await writeFile12(file, entry.markdown, "utf8");
   if (entry.pictures.length > 0) {
-    const pictureDir = join15(dir, entry.slug);
+    const pictureDir = join19(dir, entry.slug);
     await mkdir10(pictureDir, { recursive: true });
     for (const picture of entry.pictures) {
-      await copyFile2(join15(options.cwd, picture.from), join15(pictureDir, picture.to)).catch(() => {
+      await copyFile2(join19(options.cwd, picture.from), join19(pictureDir, picture.to)).catch(() => {
       });
     }
   }
@@ -9123,19 +10417,20 @@ async function runKeep(options, deps) {
     await readRenames(options.cwd)
   );
   if (!resolved.ok) return fail(resolved.error);
-  const plan = planKeep({ title: resolved.title, previews, to: options.to });
+  const destination = isAbsolute3(options.to) ? relative5(options.cwd, options.to) : options.to;
+  const plan = planKeep({ title: resolved.title, previews, to: destination });
   if (!plan.ok) return fail(plan.error);
-  const from = join15(options.cwd, plan.move.from);
-  const to = join15(options.cwd, plan.move.to);
+  const from = join19(options.cwd, plan.move.from);
+  const to = join19(options.cwd, plan.move.to);
   if (!existsSync5(from)) {
     return fail(`${plan.move.from} does not exist. Nothing to keep.`);
   }
   if (existsSync5(to)) {
     return fail(`${plan.move.to} already exists. Choose another destination or move it aside.`);
   }
-  const source = await readFile13(from, "utf8");
-  await mkdir10(dirname10(to), { recursive: true });
-  await writeFile11(to, renameExport(source, plan.exportName), "utf8");
+  const source = await readFile17(from, "utf8");
+  await mkdir10(dirname12(to), { recursive: true });
+  await writeFile12(to, renameExport(source, plan.exportName), "utf8");
   const surface = plan.removeDir.slice(plan.removeDir.lastIndexOf("/") + 1);
   let logged = null;
   let logError = null;
@@ -9150,7 +10445,7 @@ async function runKeep(options, deps) {
   } catch (error) {
     logError = error instanceof Error ? error.message : String(error);
   }
-  await rm6(join15(options.cwd, plan.removeDir), { recursive: true, force: true });
+  await rm6(join19(options.cwd, plan.removeDir), { recursive: true, force: true });
   const dropped = await dropLocalPreviews(options.cwd, plan.dropTitles);
   if (options.json) {
     deps.log(
@@ -9189,11 +10484,11 @@ async function runKeep(options, deps) {
 
 // src/run-new.ts
 import { existsSync as existsSync6 } from "fs";
-import { mkdir as mkdir11, readFile as readFile14, writeFile as writeFile12 } from "fs/promises";
-import { dirname as dirname11, join as join16 } from "path";
+import { mkdir as mkdir11, readFile as readFile18, writeFile as writeFile13 } from "fs/promises";
+import { dirname as dirname13, join as join20 } from "path";
 async function readIfPresent2(path) {
   try {
-    return await readFile14(path, "utf8");
+    return await readFile18(path, "utf8");
   } catch {
     return null;
   }
@@ -9201,7 +10496,7 @@ async function readIfPresent2(path) {
 async function runNew(options, deps) {
   let from;
   if (options.from !== void 0) {
-    const contents = await readIfPresent2(join16(options.cwd, options.from));
+    const contents = await readIfPresent2(join20(options.cwd, options.from));
     if (contents === null) {
       const message2 = `${options.from} does not exist, so there is nothing to use as the baseline.`;
       if (options.json) deps.log(JSON.stringify({ ok: false, error: message2 }));
@@ -9212,8 +10507,8 @@ async function runNew(options, deps) {
   }
   const plan = planNew({
     surface: options.surface,
-    packageJson: await readIfPresent2(join16(options.cwd, "package.json")),
-    gitignore: await readIfPresent2(join16(options.cwd, ".gitignore")),
+    packageJson: await readIfPresent2(join20(options.cwd, "package.json")),
+    gitignore: await readIfPresent2(join20(options.cwd, ".gitignore")),
     from
   });
   const fail = (error) => {
@@ -9243,7 +10538,7 @@ async function runNew(options, deps) {
     deps.log(plan.instructions);
     return { exitCode: 0, written: [] };
   }
-  const existing = plan.writes.filter((write2) => existsSync6(join16(options.cwd, write2.path)));
+  const existing = plan.writes.filter((write2) => existsSync6(join20(options.cwd, write2.path)));
   if (existing.length > 0) {
     return fail(
       `${existing[0]?.path} already exists. Delete it first, or pick another surface name.`
@@ -9251,13 +10546,13 @@ async function runNew(options, deps) {
   }
   const written = [];
   for (const write2 of plan.writes) {
-    const target = join16(options.cwd, write2.path);
-    await mkdir11(dirname11(target), { recursive: true });
-    await writeFile12(target, write2.contents, "utf8");
+    const target = join20(options.cwd, write2.path);
+    await mkdir11(dirname13(target), { recursive: true });
+    await writeFile13(target, write2.contents, "utf8");
     written.push(write2.path);
   }
   if (plan.gitignore !== null) {
-    await writeFile12(join16(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    await writeFile13(join20(options.cwd, ".gitignore"), plan.gitignore, "utf8");
     written.push(".gitignore");
   }
   if (options.json) {
@@ -9285,21 +10580,21 @@ async function runNew(options, deps) {
 }
 
 // src/run-previews.ts
-import { readFile as readFile15, writeFile as writeFile13 } from "fs/promises";
-import { join as join17 } from "path";
+import { readFile as readFile19, writeFile as writeFile14 } from "fs/promises";
+import { join as join21 } from "path";
 function envelope(deps, ok, body) {
   deps.log(JSON.stringify({ ok, ...body }));
 }
 async function ensureIgnored(cwd) {
-  const path = join17(cwd, ".gitignore");
+  const path = join21(cwd, ".gitignore");
   let current = null;
   try {
-    current = await readFile15(path, "utf8");
+    current = await readFile19(path, "utf8");
   } catch {
     current = null;
   }
   const next = ignoreEntry(current);
-  if (next !== null) await writeFile13(path, next, "utf8");
+  if (next !== null) await writeFile14(path, next, "utf8");
 }
 async function runAdd(options, deps) {
   const loaded = await loadConfig(options.cwd);
@@ -9522,7 +10817,7 @@ async function findLeglas(cwd, port, request) {
       signal: AbortSignal.timeout(2e3)
     });
     if (health.status !== 200) return { ok: false, error: NOT_RUNNING };
-    const answered = await health.text().then((text2) => JSON.parse(text2)).catch(() => ({}));
+    const answered = await health.text().then((text3) => JSON.parse(text3)).catch(() => ({}));
     if (answered === null) return { ok: false, error: NOT_RUNNING };
     if (isJsonObject(answered) && isString2(answered.cwd) && !await sameDirectory(answered.cwd, cwd)) {
       return {
@@ -9954,24 +11249,24 @@ function installShutdown(stop, target = process) {
 
 // src/run-watch.ts
 import { spawn as spawn4 } from "child_process";
-import { mkdir as mkdir12, readFile as readFile16, writeFile as writeFile14 } from "fs/promises";
-import { dirname as dirname12, join as join18 } from "path";
+import { mkdir as mkdir12, readFile as readFile20, writeFile as writeFile15 } from "fs/promises";
+import { dirname as dirname14, join as join22 } from "path";
 var POLL_MS2 = 2e3;
 var HEARTBEAT_TIMEOUT_MS = 1e3;
 async function saveTemplate(cwd, run4) {
-  const path = join18(cwd, WATCH_PATH);
+  const path = join22(cwd, WATCH_PATH);
   let config = {};
   try {
-    const parsed = JSON.parse(await readFile16(path, "utf8"));
+    const parsed = JSON.parse(await readFile20(path, "utf8"));
     if (isJsonObject(parsed)) config = parsed;
   } catch {
   }
   config.run = run4;
-  await mkdir12(dirname12(path), { recursive: true });
-  await writeFile14(path, `${JSON.stringify(config, null, 2)}
+  await mkdir12(dirname14(path), { recursive: true });
+  await writeFile15(path, `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
-function spawnAgent(command, args, cwd) {
+function spawnAgent(command, args, cwd, json) {
   return new Promise((resolve5) => {
     let settled = false;
     const settle = (outcome) => {
@@ -9979,7 +11274,10 @@ function spawnAgent(command, args, cwd) {
       settled = true;
       resolve5(outcome);
     };
-    const child = spawn4(command, args, { cwd, stdio: "inherit" });
+    const child = spawn4(command, args, {
+      cwd,
+      stdio: json ? ["inherit", 2, "inherit"] : "inherit"
+    });
     child.on("error", (error) => settle({ ok: false, error: error.message }));
     child.on(
       "close",
@@ -9990,6 +11288,13 @@ function spawnAgent(command, args, cwd) {
   });
 }
 async function runWatch(options, deps) {
+  const json = options.json === true;
+  const emit = (event) => deps.log(JSON.stringify(event));
+  const refuse2 = (error) => {
+    if (json) deps.log(JSON.stringify({ ok: false, error }));
+    else deps.error(error);
+    return { exitCode: 1 };
+  };
   const saved = options.run === void 0 ? await readAgentChoice(options.cwd) : { agent: null, run: null };
   const raw = options.run ?? saved.run;
   let template;
@@ -9997,10 +11302,7 @@ async function runWatch(options, deps) {
   let synthesizedAgent = null;
   if (raw !== null) {
     const parsed = parseTemplate(raw);
-    if (!parsed.ok) {
-      deps.error(parsed.error);
-      return { exitCode: 1 };
-    }
+    if (!parsed.ok) return refuse2(parsed.error);
     template = parsed.template;
     shownCommand2 = raw;
   } else if (saved.agent !== null && saved.agent !== "custom") {
@@ -10012,10 +11314,9 @@ async function runWatch(options, deps) {
     shownCommand2 = [template.command, ...template.args].join(" ");
     synthesizedAgent = adapter.name;
   } else {
-    deps.error(
+    return refuse2(
       'Watch needs an agent command the first time: pick an agent in the interface, or pass --run "claude -p {prompt}".'
     );
-    return { exitCode: 1 };
   }
   if (options.run !== void 0) await saveTemplate(options.cwd, options.run).catch(() => {
   });
@@ -10031,26 +11332,36 @@ async function runWatch(options, deps) {
     } catch {
     }
   };
-  if (synthesizedAgent !== null) {
-    deps.log(`Using ${synthesizedAgent}, chosen in the interface.`);
+  if (json) {
+    emit({ event: "watching", command: shownCommand2, agent: synthesizedAgent });
+  } else {
+    if (synthesizedAgent !== null) {
+      deps.log(`Using ${synthesizedAgent}, chosen in the interface.`);
+    }
+    deps.log(`Watching for change requests. Each one runs: ${shownCommand2}`);
+    deps.log("Stop with Ctrl-C.");
   }
-  deps.log(`Watching for change requests. Each one runs: ${shownCommand2}`);
-  deps.log("Stop with Ctrl-C.");
   const failed = /* @__PURE__ */ new Set();
   let stopped = false;
   let busy = false;
   let announced = false;
   let inflight = null;
   const handle = async (request) => {
-    deps.log("");
-    deps.log(`  ${request.title}: ${request.intent}`);
-    if (request.target !== null) deps.log(`    ${request.target}`);
+    const { id, title, intent, target } = request;
+    if (json) {
+      emit({ event: "started", id, title, intent, target });
+    } else {
+      deps.log("");
+      deps.log(`  ${title}: ${intent}`);
+      if (target !== null) deps.log(`    ${target}`);
+    }
     await markPickedUp(options.cwd, request.id);
     const { command, args } = commandFor(template, request.prompt);
-    const outcome = await spawnAgent(command, args, options.cwd);
+    const outcome = await spawnAgent(command, args, options.cwd, json);
     if (outcome.ok && outcome.code === 0) {
       await removeRequest(options.cwd, request.id);
-      deps.log(`  done    ${request.title}`);
+      if (json) emit({ event: "done", id, title });
+      else deps.log(`  done    ${title}`);
       return;
     }
     failed.add(request.id);
@@ -10060,8 +11371,12 @@ async function runWatch(options, deps) {
       exitCode: outcome.ok ? outcome.code : null
     });
     await markFailed(options.cwd, request.id, failure);
-    deps.error(`  failed  ${request.title}: ${failure.message}`);
-    deps.error("  Left in the queue and not retried.");
+    if (json) {
+      emit({ event: "failed", id, title, code: failure.code, reason: failure.message });
+    } else {
+      deps.error(`  failed  ${title}: ${failure.message}`);
+      deps.error("  Left in the queue and not retried.");
+    }
   };
   const tick = async () => {
     if (stopped) return;
@@ -10080,7 +11395,9 @@ async function runWatch(options, deps) {
         await inflight;
       }
     } catch (error) {
-      deps.error(`  ! ${error instanceof Error ? error.message : String(error)}`);
+      const message2 = error instanceof Error ? error.message : String(error);
+      if (json) emit({ event: "error", message: message2 });
+      else deps.error(`  ! ${message2}`);
     } finally {
       inflight = null;
       busy = false;
@@ -10095,7 +11412,10 @@ async function runWatch(options, deps) {
       process.off("SIGINT", stop);
       process.off("SIGTERM", stop);
       void Promise.resolve(inflight).catch(() => {
-      }).then(() => heartbeat(false)).then(() => resolve5({ exitCode: 0 }));
+      }).then(() => heartbeat(false)).then(() => {
+        if (json) emit({ event: "stopped" });
+        resolve5({ exitCode: 0 });
+      });
     };
     process.on("SIGINT", stop);
     process.on("SIGTERM", stop);
@@ -10106,13 +11426,13 @@ async function runWatch(options, deps) {
 }
 
 // src/run-classify.ts
-import { stat as stat4 } from "fs/promises";
-import { join as join19 } from "path";
+import { stat as stat5 } from "fs/promises";
+import { join as join23 } from "path";
 async function runClassify(options, deps) {
   const declared = await Promise.all(
     options.changes.map(async (change) => ({
       ...change,
-      exists: await stat4(join19(options.cwd, change.path)).then(
+      exists: await stat5(join23(options.cwd, change.path)).then(
         () => true,
         () => false
       )
@@ -10141,13 +11461,13 @@ async function runClassify(options, deps) {
 import { existsSync as existsSync7 } from "fs";
 import { realpath as realpath4 } from "fs/promises";
 import { createRequire } from "module";
-import { basename as basename6, dirname as dirname13, join as join20, relative as relative5, resolve as resolve4 } from "path";
+import { basename as basename6, dirname as dirname15, join as join24, relative as relative7, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 
 // src/dev-server-owner.ts
 import { execFile as execFile2 } from "child_process";
 import { realpath as realpath3 } from "fs/promises";
-import { basename as basename5, isAbsolute as isAbsolute2, relative as relative4, resolve as resolve3 } from "path";
+import { basename as basename5, isAbsolute as isAbsolute4, relative as relative6, resolve as resolve3 } from "path";
 import { promisify as promisify2 } from "util";
 var run2 = promisify2(execFile2);
 var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
@@ -10216,8 +11536,8 @@ async function inspectLocalDevServer(origin) {
   }
 }
 function isInside(parent, child) {
-  const path = relative4(resolve3(parent), resolve3(child));
-  return path === "" || !path.startsWith("..") && !isAbsolute2(path);
+  const path = relative6(resolve3(parent), resolve3(child));
+  return path === "" || !path.startsWith("..") && !isAbsolute4(path);
 }
 function devServerOwnerWarning(origin, projectRoot, owners) {
   const port = localDevServerPort(origin);
@@ -10230,11 +11550,11 @@ function devServerOwnerWarning(origin, projectRoot, owners) {
 
 // src/run.ts
 function findShellDir() {
-  const bundled = join20(dirname13(fileURLToPath(import.meta.url)), "shell");
-  if (existsSync7(join20(bundled, "index.html"))) return bundled;
+  const bundled = join24(dirname15(fileURLToPath(import.meta.url)), "shell");
+  if (existsSync7(join24(bundled, "index.html"))) return bundled;
   try {
     const require2 = createRequire(import.meta.url);
-    return dirname13(require2.resolve("@leglas/shell/dist/index.html"));
+    return dirname15(require2.resolve("@leglas/shell/dist/index.html"));
   } catch {
     return null;
   }
@@ -10245,7 +11565,7 @@ function shellWord(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
 function embeddedLeglasCommand() {
-  const entry = join20(dirname13(fileURLToPath(import.meta.url)), "bin.js");
+  const entry = join24(dirname15(fileURLToPath(import.meta.url)), "bin.js");
   if (!existsSync7(entry)) return "npx -y leglas";
   return [process.execPath, entry].map(shellWord).join(" ");
 }
@@ -10284,7 +11604,7 @@ async function runWithServices(options, deps, services = {}) {
   const fileMounts = /* @__PURE__ */ new Map();
   for (const preview of merged?.previews ?? []) {
     if (preview.file !== void 0) {
-      const absolute = join20(options.cwd, preview.file);
+      const absolute = join24(options.cwd, preview.file);
       if (!existsSync7(absolute)) {
         previewErrors.push(
           `"${preview.title}" names file ${preview.file}, which does not exist. The preview is skipped.`
@@ -10295,7 +11615,7 @@ async function runWithServices(options, deps, services = {}) {
       for (let suffix = 2; fileMounts.has(slug); suffix += 1) {
         slug = `${worktreeSlug(preview.title) || "file"}-${suffix}`;
       }
-      fileMounts.set(slug, dirname13(absolute));
+      fileMounts.set(slug, dirname15(absolute));
       previews.push({
         ...preview,
         url: `${FILES_PREFIX}/${slug}/${encodeURIComponent(basename6(absolute))}`
@@ -10307,8 +11627,8 @@ async function runWithServices(options, deps, services = {}) {
   const config = merged === null ? null : { ...merged, previews };
   const configWarnings = [];
   const projectRoot = await realpath4(
-    loaded.path === null ? options.cwd : dirname13(loaded.path)
-  ).catch(() => resolve4(loaded.path === null ? options.cwd : dirname13(loaded.path)));
+    loaded.path === null ? options.cwd : dirname15(loaded.path)
+  ).catch(() => resolve4(loaded.path === null ? options.cwd : dirname15(loaded.path)));
   const ownerWarning = needsApp && app === null ? (services.inspectLocalDevServer ?? inspectLocalDevServer)(devServer).then((owners) => devServerOwnerWarning(devServer, projectRoot, owners)).catch(() => null) : Promise.resolve(null);
   const serverOptions = {
     config,
@@ -10346,7 +11666,7 @@ async function runWithServices(options, deps, services = {}) {
       })
     );
   } else {
-    const configLabel = loaded.path === null ? "no config file, previewing the app root" : relative5(options.cwd, loaded.path) || loaded.path;
+    const configLabel = loaded.path === null ? "no config file, previewing the app root" : relative7(options.cwd, loaded.path) || loaded.path;
     deps.log(`Leglas   ${url}`);
     deps.log(
       `app      ${devServer}${app !== null ? "  (started by Leglas)" : health.reachable ? "" : "  (not reachable)"}`