leglas 0.1.0

package/dist/bin.js

@@ -0,0 +1,2226 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { spawn as spawn2 } from "child_process";
+import { createRequire as createRequire2 } from "module";
+
+// src/args.ts
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["--port", "--user-port", "--config"]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--no-open", "--json"]);
+function parsePort(flag, raw) {
+  if (!/^\d+$/.test(raw)) {
+    return { error: `${flag} needs a number, received ${JSON.stringify(raw)}.` };
+  }
+  const port = Number(raw);
+  if (port < 1 || port > 65535) {
+    return { error: `${flag} must be between 1 and 65535, received ${port}.` };
+  }
+  return port;
+}
+function parseNew(rest) {
+  let surface;
+  let print = false;
+  let json = false;
+  let from;
+  for (let index = 0; index < rest.length; index += 1) {
+    const argument = rest[index];
+    if (argument === "--from" || argument.startsWith("--from=")) {
+      from = argument.includes("=") ? argument.split("=").slice(1).join("=") : rest[index += 1];
+      if (from === void 0 || from === "") {
+        return { kind: "error", message: "--from needs a path, for example --from src/Hero.tsx" };
+      }
+      continue;
+    }
+    if (argument === "--print") {
+      print = true;
+      continue;
+    }
+    if (argument === "--json") {
+      json = true;
+      continue;
+    }
+    if (argument === "--help" || argument === "-h") return { kind: "help" };
+    if (argument.startsWith("-")) {
+      return { kind: "error", message: `leglas new does not take ${argument}.` };
+    }
+    if (surface !== void 0) {
+      return { kind: "error", message: `leglas new takes one surface name, received ${JSON.stringify(argument)} as well.` };
+    }
+    surface = argument;
+  }
+  if (surface === void 0) {
+    return {
+      kind: "error",
+      message: "leglas new needs a surface name, for example: leglas new hero"
+    };
+  }
+  return { kind: "new", surface, print, json, from };
+}
+function parseAdd(rest) {
+  let title;
+  let url;
+  let note;
+  let branch;
+  let file;
+  const tags = [];
+  let json = false;
+  for (let index = 0; index < rest.length; index += 1) {
+    const argument = rest[index];
+    if (argument === "--json") {
+      json = true;
+      continue;
+    }
+    if (argument === "--help" || argument === "-h") return { kind: "help" };
+    const equals = argument.indexOf("=");
+    const flag = equals === -1 ? argument : argument.slice(0, equals);
+    let value;
+    if (equals === -1) {
+      value = rest[index + 1];
+      index += 1;
+    } else {
+      value = argument.slice(equals + 1);
+    }
+    if (!["--title", "--url", "--note", "--tag", "--branch", "--file"].includes(flag)) {
+      return { kind: "error", message: `leglas add does not take ${flag}.` };
+    }
+    if (value === void 0 || value === "") {
+      return { kind: "error", message: `${flag} needs a value.` };
+    }
+    if (flag === "--title") title = value;
+    else if (flag === "--url") url = value;
+    else if (flag === "--note") note = value;
+    else if (flag === "--branch") branch = value;
+    else if (flag === "--file") file = value;
+    else tags.push(value);
+  }
+  if (title === void 0) {
+    return { kind: "error", message: "leglas add needs --title, which is how the preview is identified." };
+  }
+  if (url === void 0 && file === void 0) {
+    return {
+      kind: "error",
+      message: "leglas add needs --url (for example --url '/?v-hero=aurora') or --file for a page Leglas serves itself."
+    };
+  }
+  return {
+    kind: "add",
+    preview: { title, url, note, tags: tags.length > 0 ? tags : void 0, branch, file },
+    json
+  };
+}
+function parseClassify(rest) {
+  const changes = [];
+  let json = false;
+  for (let index = 0; index < rest.length; index += 1) {
+    const argument = rest[index];
+    if (argument === "--json") {
+      json = true;
+      continue;
+    }
+    if (argument === "--help" || argument === "-h") return { kind: "help" };
+    const equals = argument.indexOf("=");
+    const flag = equals === -1 ? argument : argument.slice(0, equals);
+    if (flag !== "--change" && flag !== "--rewrite") {
+      return { kind: "error", message: `leglas classify does not take ${argument}.` };
+    }
+    const value = equals === -1 ? rest[index += 1] : argument.slice(equals + 1);
+    if (value === void 0 || value === "") {
+      return { kind: "error", message: `${flag} needs a path, for example ${flag} package.json` };
+    }
+    changes.push({ path: value, kind: flag === "--change" ? "change" : "rewrite" });
+  }
+  if (changes.length === 0) {
+    return {
+      kind: "error",
+      message: "leglas classify needs what the direction will touch, for example: leglas classify --change package.json --rewrite src/theme.css"
+    };
+  }
+  return { kind: "classify", changes, json };
+}
+function parseArgs(argv) {
+  if (argv[0] === "new") return parseNew(argv.slice(1));
+  if (argv[0] === "add") return parseAdd(argv.slice(1));
+  if (argv[0] === "classify") return parseClassify(argv.slice(1));
+  if (argv[0] === "init") {
+    const rest = argv.slice(1);
+    const unknown = rest.find((argument) => argument !== "--force" && argument !== "--json");
+    if (unknown !== void 0) {
+      return { kind: "error", message: `leglas init does not take ${unknown}.` };
+    }
+    return { kind: "init", force: rest.includes("--force"), json: rest.includes("--json") };
+  }
+  if (argv[0] === "keep") {
+    const rest = argv.slice(1);
+    let title;
+    let to;
+    let json = false;
+    for (let index = 0; index < rest.length; index += 1) {
+      const argument = rest[index];
+      if (argument === "--json") {
+        json = true;
+        continue;
+      }
+      if (argument === "--to" || argument.startsWith("--to=")) {
+        to = argument.includes("=") ? argument.split("=").slice(1).join("=") : rest[index += 1];
+        if (to === void 0 || to === "") {
+          return { kind: "error", message: "--to needs a path, for example --to src/components/hero.tsx" };
+        }
+        continue;
+      }
+      if (argument.startsWith("-")) {
+        return { kind: "error", message: `leglas keep does not take ${argument}.` };
+      }
+      if (title !== void 0) {
+        return { kind: "error", message: "leglas keep takes one direction title." };
+      }
+      title = argument;
+    }
+    if (title === void 0) {
+      return {
+        kind: "error",
+        message: 'leglas keep needs a direction title, for example: leglas keep "Aurora" --to src/components/hero.tsx'
+      };
+    }
+    if (to === void 0) {
+      return { kind: "error", message: "leglas keep needs --to, the path the winner should live at." };
+    }
+    return { kind: "keep", title, to, json };
+  }
+  if (argv[0] === "explore") {
+    const rest = argv.slice(1);
+    let surface;
+    let count = 3;
+    let json = false;
+    for (let index = 0; index < rest.length; index += 1) {
+      const argument = rest[index];
+      if (argument === "--json") {
+        json = true;
+        continue;
+      }
+      if (argument === "--count" || argument.startsWith("--count=")) {
+        const raw = argument.includes("=") ? argument.split("=")[1] : rest[index += 1];
+        if (raw === void 0 || !/^\d+$/.test(raw)) {
+          return { kind: "error", message: "--count needs a number, for example --count 6." };
+        }
+        count = Number(raw);
+        continue;
+      }
+      if (argument.startsWith("-")) {
+        return { kind: "error", message: `leglas explore does not take ${argument}.` };
+      }
+      if (surface !== void 0) {
+        return { kind: "error", message: "leglas explore takes one surface name." };
+      }
+      surface = argument;
+    }
+    if (surface === void 0) {
+      return {
+        kind: "error",
+        message: "leglas explore needs a surface name, for example: leglas explore hero --count 6"
+      };
+    }
+    return { kind: "explore", surface, count, json };
+  }
+  if (argv[0] === "requests") {
+    const rest = argv.slice(1);
+    const unknown = rest.find((argument) => argument !== "--json" && argument !== "--clear");
+    if (unknown !== void 0) {
+      return { kind: "error", message: `leglas requests does not take ${unknown}.` };
+    }
+    return { kind: "requests", json: rest.includes("--json"), clear: rest.includes("--clear") };
+  }
+  if (argv[0] === "list") {
+    const rest = argv.slice(1);
+    const unknown = rest.find((argument) => argument !== "--json");
+    if (unknown !== void 0) {
+      return { kind: "error", message: `leglas list does not take ${unknown}.` };
+    }
+    return { kind: "list", json: rest.includes("--json") };
+  }
+  const options = {
+    port: void 0,
+    userPort: void 0,
+    configPath: void 0,
+    open: true,
+    json: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--help" || argument === "-h") return { kind: "help" };
+    if (argument === "--version" || argument === "-v") return { kind: "version" };
+    if (BOOLEAN_FLAGS.has(argument)) {
+      if (argument === "--no-open") options.open = false;
+      if (argument === "--json") options.json = true;
+      continue;
+    }
+    const equals = argument.indexOf("=");
+    const flag = equals === -1 ? argument : argument.slice(0, equals);
+    if (!VALUE_FLAGS.has(flag)) {
+      return {
+        kind: "error",
+        message: argument.startsWith("-") ? `Unknown flag ${argument}. Run leglas --help to see the options.` : `Unexpected argument ${JSON.stringify(argument)}. leglas takes flags only.`
+      };
+    }
+    let value;
+    if (equals === -1) {
+      value = argv[index + 1];
+      index += 1;
+    } else {
+      value = argument.slice(equals + 1);
+    }
+    if (value === void 0 || value === "" || value.startsWith("--")) {
+      return { kind: "error", message: `${flag} needs a value.` };
+    }
+    if (flag === "--config") {
+      options.configPath = value;
+      continue;
+    }
+    const port = parsePort(flag, value);
+    if (typeof port !== "number") return { kind: "error", message: port.error };
+    if (flag === "--port") options.port = port;
+    else options.userPort = port;
+  }
+  return { kind: "run", options };
+}
+
+// src/run-classify.ts
+import { stat } from "fs/promises";
+import { join as join6 } from "path";
+
+// ../server/dist/config.js
+var DEFAULT_DEV_SERVER = "http://localhost:3000";
+var DEFAULT_INSTALL_COMMAND = "npm install";
+var IMPLICIT_PREVIEW = { title: "App", url: "/" };
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isValidOrigin(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function isSafeBranch(value) {
+  if (value === "" || value.startsWith("-"))
+    return false;
+  if (value.split("/").some((segment) => segment === "." || segment === ".."))
+    return false;
+  return /^[A-Za-z0-9._/-]+$/.test(value);
+}
+function isValidPreviewUrl(value) {
+  return value.startsWith("/") || isValidOrigin(value);
+}
+function isSafePreviewFile(value) {
+  if (value === "" || value.startsWith("/") || value.startsWith("\\"))
+    return false;
+  if (/^[A-Za-z]:/.test(value))
+    return false;
+  return !value.split(/[/\\]/).some((segment) => segment === "..");
+}
+function normalizeConfig(raw, options = {}) {
+  const requireDevCommand = options.requireDevCommand ?? true;
+  const errors = [];
+  const source = raw === void 0 || raw === null ? {} : raw;
+  if (!isRecord(source)) {
+    return { config: null, errors: ["Config must export an object."] };
+  }
+  const devServer = source["devServer"] ?? DEFAULT_DEV_SERVER;
+  if (typeof devServer !== "string" || !isValidOrigin(devServer)) {
+    errors.push(`devServer must be an http(s) URL, received ${JSON.stringify(devServer)}.`);
+  }
+  const rawPreviews = source["previews"] ?? [IMPLICIT_PREVIEW];
+  if (!Array.isArray(rawPreviews)) {
+    errors.push(`previews must be an array, received ${JSON.stringify(rawPreviews)}.`);
+    return { config: null, errors };
+  }
+  const previews = [];
+  const seenTitles = /* @__PURE__ */ new Set();
+  rawPreviews.forEach((entry, index) => {
+    const at = `previews[${index}]`;
+    if (!isRecord(entry)) {
+      errors.push(`${at} must be an object.`);
+      return;
+    }
+    const title = entry["title"];
+    const url = entry["url"];
+    const file = entry["file"];
+    if (typeof title !== "string" || title.trim() === "") {
+      errors.push(`${at} needs a title; the rail has nothing to show without one.`);
+    } else if (seenTitles.has(title)) {
+      errors.push(`${at} repeats the title ${JSON.stringify(title)}; titles must be unique.`);
+    } else {
+      seenTitles.add(title);
+    }
+    if (file !== void 0) {
+      if (typeof file !== "string" || !isSafePreviewFile(file)) {
+        errors.push(`${at} has an unusable file ${JSON.stringify(file)}; use a path inside the project, like "directions/hero.html".`);
+      }
+      if (url !== void 0) {
+        errors.push(`${at} names a file and a url; a file preview's url is assigned by Leglas.`);
+      }
+    } else if (typeof url !== "string" || url.trim() === "") {
+      errors.push(`${at} needs a url.`);
+    } else if (!isValidPreviewUrl(url)) {
+      errors.push(`${at} has url ${JSON.stringify(url)}; use a root-relative path ("/pricing") or a full URL.`);
+    }
+    const branch = entry["branch"];
+    if (branch !== void 0) {
+      if (typeof branch !== "string" || !isSafeBranch(branch)) {
+        errors.push(`${at} has an unusable branch ${JSON.stringify(branch)}; use a plain git branch name.`);
+      } else if (typeof url === "string" && !url.startsWith("/")) {
+        errors.push(`${at} names a branch and an absolute url; a branch preview is served by Leglas, so its url must be a path.`);
+      }
+      if (file !== void 0) {
+        errors.push(`${at} names a branch and a file; a file preview is served by Leglas itself and has no checkout.`);
+      }
+    }
+    const tags = entry["tags"];
+    previews.push({
+      title: typeof title === "string" ? title : "",
+      url: typeof url === "string" ? url : "",
+      note: typeof entry["note"] === "string" ? entry["note"] : void 0,
+      tags: Array.isArray(tags) ? tags.filter((tag) => typeof tag === "string") : [],
+      ...typeof branch === "string" ? { branch } : {},
+      ...typeof file === "string" ? { file } : {}
+    });
+  });
+  const devCommand = source["devCommand"];
+  if (devCommand !== void 0 && typeof devCommand !== "string") {
+    errors.push("devCommand must be a string.");
+  } else if (typeof devCommand === "string" && !devCommand.includes("{port}")) {
+    errors.push(`devCommand must include {port}, so Leglas can start each checkout on a free port. Received ${JSON.stringify(devCommand)}.`);
+  }
+  if (requireDevCommand && previews.some((preview) => preview.branch !== void 0) && devCommand === void 0) {
+    errors.push("A preview names a branch, so devCommand is required: Leglas has to start that checkout itself.");
+  }
+  const installCommand = source["installCommand"] ?? DEFAULT_INSTALL_COMMAND;
+  if (typeof installCommand !== "string" || installCommand.trim() === "") {
+    errors.push("installCommand must be a non-empty string.");
+  }
+  if (errors.length > 0)
+    return { config: null, errors };
+  return {
+    config: {
+      devServer,
+      previews,
+      devCommand: typeof devCommand === "string" ? devCommand : void 0,
+      installCommand
+    },
+    errors: []
+  };
+}
+
+// ../server/dist/classify.js
+var MANIFESTS = /* @__PURE__ */ new Set([
+  "package.json",
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb",
+  "npm-shrinkwrap.json",
+  "pnpm-workspace.yaml"
+]);
+function basename(path) {
+  const segments = path.split("/");
+  return segments[segments.length - 1] ?? path;
+}
+function isManifest(path) {
+  return MANIFESTS.has(basename(path));
+}
+function isBuildConfig(path) {
+  const name = basename(path);
+  if (name.startsWith("leglas.config."))
+    return false;
+  if (/^tsconfig[^/]*\.json$/.test(name))
+    return true;
+  if (name === ".env" || name.startsWith(".env."))
+    return true;
+  if (name === ".babelrc" || name.startsWith(".babelrc."))
+    return true;
+  if (name === "turbo.json")
+    return true;
+  return /\.config\.[a-z]+$/i.test(name);
+}
+function isExplorationFile(path) {
+  return path.startsWith(".leglas/") || path.includes("/.leglas/");
+}
+var CHECKOUT_STEPS = [
+  "Build the direction on its own branch: git switch -c <branch>, commit it there, switch back.",
+  'Register it: leglas add --title "<title>" --url "/" --branch <branch>.',
+  "Make sure the config sets devCommand (with {port}), so Leglas can start the checkout."
+];
+var IN_APP_STEPS = [
+  "Author it additively under .leglas/variants/<surface>/, beside the existing directions.",
+  'Register it: leglas add --title "<title>" --url "/?v-<surface>=<direction>".'
+];
+function classifyDirection(input) {
+  const checkout = (reason) => ({ level: "checkout", reason, steps: CHECKOUT_STEPS });
+  const manifest = input.changes.find((change) => isManifest(change.path));
+  if (manifest !== void 0) {
+    return checkout(`${manifest.path} changes the dependency set, and one running server cannot hold two.`);
+  }
+  const config = input.changes.find((change) => isBuildConfig(change.path));
+  if (config !== void 0) {
+    return checkout(`${config.path} is build configuration, which applies to every direction in the one server.`);
+  }
+  const rewrite = input.changes.find((change) => change.kind === "rewrite" && change.exists && !isExplorationFile(change.path));
+  if (rewrite !== void 0) {
+    return checkout(`${rewrite.path} already renders for the other directions; rewriting it makes them contend for one file.`);
+  }
+  return {
+    level: "in-app",
+    reason: "Everything declared adds beside what exists, so it renders from the running server.",
+    steps: IN_APP_STEPS
+  };
+}
+
+// ../server/dist/find-config.js
+import { existsSync } from "fs";
+import { dirname, join, parse } from "path";
+var CONFIG_BASENAMES = [
+  "leglas.config.ts",
+  "leglas.config.mjs",
+  "leglas.config.js",
+  "leglas.config.json"
+];
+function findConfigFile(startDir) {
+  const { root } = parse(startDir);
+  let dir = startDir;
+  for (; ; ) {
+    for (const basename4 of CONFIG_BASENAMES) {
+      const candidate = join(dir, basename4);
+      if (existsSync(candidate))
+        return candidate;
+    }
+    if (dir === root)
+      return null;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+
+// ../server/dist/load-config.js
+import { readFile } from "fs/promises";
+import { relative } from "path";
+import { pathToFileURL } from "url";
+async function loadConfig(cwd) {
+  const path = findConfigFile(cwd);
+  if (path === null) {
+    return { ...normalizeConfig(void 0), path: null };
+  }
+  const label = relative(cwd, path) || path;
+  let exported;
+  try {
+    if (path.endsWith(".json")) {
+      exported = JSON.parse(await readFile(path, "utf8"));
+    } else {
+      const module = await import(pathToFileURL(path).href);
+      if (!("default" in module)) {
+        return { config: null, errors: [`${label} has no default export.`], path };
+      }
+      exported = module.default;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { config: null, errors: [`${label} could not be loaded: ${message}`], path };
+  }
+  const result2 = normalizeConfig(exported);
+  return {
+    config: result2.config,
+    errors: result2.errors.map((error) => `${label}: ${error}`),
+    path
+  };
+}
+
+// ../server/dist/local-previews.js
+import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
+var LOCAL_PREVIEWS_PATH = ".leglas/previews.json";
+async function readLocalPreviews(cwd) {
+  const path = join2(cwd, LOCAL_PREVIEWS_PATH);
+  let raw;
+  try {
+    raw = await readFile2(path, "utf8");
+  } catch {
+    return { previews: [], errors: [] };
+  }
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(raw);
+  } catch (error) {
+    return {
+      previews: [],
+      errors: [
+        `${LOCAL_PREVIEWS_PATH} is not valid JSON (${error instanceof Error ? error.message : String(error)}). Delete it to start over; nothing shared is lost.`
+      ]
+    };
+  }
+  const result2 = normalizeConfig(parsed2, { requireDevCommand: false });
+  if (result2.config === null) {
+    return { previews: [], errors: result2.errors.map((error) => `${LOCAL_PREVIEWS_PATH}: ${error}`) };
+  }
+  return {
+    previews: result2.config.previews.map((preview) => ({ ...preview, local: true })),
+    errors: []
+  };
+}
+async function addLocalPreview(cwd, input, shared) {
+  const existing = await readLocalPreviews(cwd);
+  if (existing.errors.length > 0) {
+    return { ok: false, error: existing.errors.join(" ") };
+  }
+  const taken = [...shared, ...existing.previews].some((preview) => preview.title === input.title);
+  if (taken) {
+    return {
+      ok: false,
+      error: `A preview called ${JSON.stringify(input.title)} already exists. Titles identify previews, so they have to be unique.`
+    };
+  }
+  const candidate = {
+    title: input.title,
+    ...input.url === void 0 ? {} : { url: input.url },
+    ...input.note === void 0 ? {} : { note: input.note },
+    ...input.tags === void 0 ? {} : { tags: input.tags },
+    ...input.branch === void 0 ? {} : { branch: input.branch },
+    ...input.file === void 0 ? {} : { file: input.file }
+  };
+  const check = normalizeConfig({ previews: [candidate] }, { requireDevCommand: false });
+  if (check.config === null) {
+    return { ok: false, error: check.errors.join(" ") };
+  }
+  const path = join2(cwd, LOCAL_PREVIEWS_PATH);
+  await mkdir(dirname2(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify({ previews: [...existing.previews.map(toStored), candidate] }, null, 2)}
+`, "utf8");
+  return { ok: true };
+}
+function toStored(preview) {
+  const { local: _local, url, ...rest } = preview;
+  return preview.file !== void 0 && url === "" ? rest : { url, ...rest };
+}
+async function dropLocalPreviews(cwd, titles) {
+  const existing = await readLocalPreviews(cwd);
+  const keep = existing.previews.filter((preview) => !titles.includes(preview.title));
+  if (keep.length === existing.previews.length)
+    return 0;
+  const path = join2(cwd, LOCAL_PREVIEWS_PATH);
+  await mkdir(dirname2(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify({ previews: keep.map(toStored) }, null, 2)}
+`, "utf8");
+  return existing.previews.length - keep.length;
+}
+
+// ../server/dist/proxy.js
+import http, {} from "http";
+import net from "net";
+function createProxyHandler(options) {
+  const target = new URL(options.target);
+  const host = target.hostname;
+  const port = Number(target.port || (target.protocol === "https:" ? 443 : 80));
+  const authority = target.port ? `${host}:${target.port}` : host;
+  function upstreamHeaders(req) {
+    return { ...req.headers, host: authority };
+  }
+  function rewriteLocation(location, publicOrigin) {
+    if (location === void 0)
+      return void 0;
+    for (const origin of [`${target.protocol}//${authority}`, `${target.protocol}//localhost:${port}`]) {
+      if (location.startsWith(origin))
+        return publicOrigin + location.slice(origin.length);
+    }
+    return location;
+  }
+  return {
+    request(req, res, publicOrigin) {
+      const upstream = http.request({ host, port, method: req.method, path: req.url, headers: upstreamHeaders(req) }, (upstreamRes) => {
+        const headers = { ...upstreamRes.headers };
+        const location = rewriteLocation(typeof headers.location === "string" ? headers.location : void 0, publicOrigin);
+        if (location !== void 0)
+          headers.location = location;
+        res.writeHead(upstreamRes.statusCode ?? 502, headers);
+        upstreamRes.pipe(res);
+      });
+      upstream.on("error", (error) => {
+        if (res.headersSent)
+          return res.destroy();
+        res.writeHead(502, { "content-type": "text/plain" });
+        res.end(`Leglas could not reach the dev server at ${options.target} (${error.message}).
+Start it, or point Leglas somewhere else with --user-port.`);
+      });
+      req.pipe(upstream);
+    },
+    upgrade(req, socket, head) {
+      const upstream = net.connect(port, host, () => {
+        const headers = Object.entries(upstreamHeaders(req)).map(([key, value]) => `${key}: ${Array.isArray(value) ? value.join(", ") : value}\r
+`).join("");
+        upstream.write(`${req.method} ${req.url} HTTP/1.1\r
+${headers}\r
+`);
+        if (head.length > 0)
+          upstream.write(head);
+        upstream.pipe(socket);
+        socket.pipe(upstream);
+      });
+      const shutdown2 = () => {
+        upstream.destroy();
+        socket.destroy();
+      };
+      upstream.on("error", shutdown2);
+      upstream.on("close", shutdown2);
+      socket.on("error", shutdown2);
+      socket.on("close", shutdown2);
+    }
+  };
+}
+
+// ../server/dist/worktree.js
+import { execFile, spawn } from "child_process";
+import { rm } from "fs/promises";
+import net2 from "net";
+import { join as join3 } from "path";
+import { promisify } from "util";
+var run = promisify(execFile);
+var WORKTREES_DIR = ".leglas/worktrees";
+var INSTALL_TIMEOUT_MS = 3e5;
+function worktreeSlug(branch) {
+  return branch.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function substitutePort(command, port) {
+  return command.split("{port}").join(String(port));
+}
+async function freePort() {
+  return new Promise((resolve, reject) => {
+    const probe2 = net2.createServer();
+    probe2.once("error", reject);
+    probe2.listen(0, "127.0.0.1", () => {
+      const address = probe2.address();
+      const port = typeof address === "object" && address !== null ? address.port : 0;
+      probe2.close(() => resolve(port));
+    });
+  });
+}
+function answers(port) {
+  return new Promise((resolve) => {
+    const socket = net2.connect(port, "127.0.0.1");
+    const settle = (value) => {
+      socket.destroy();
+      resolve(value);
+    };
+    socket.setTimeout(400);
+    socket.once("connect", () => settle(true));
+    socket.once("timeout", () => settle(false));
+    socket.once("error", () => settle(false));
+  });
+}
+async function startWorktree(options) {
+  const readyTimeoutMs = options.readyTimeoutMs ?? 9e4;
+  const path = join3(options.cwd, WORKTREES_DIR, worktreeSlug(options.branch));
+  const log = options.onLog ?? (() => {
+  });
+  await rm(path, { recursive: true, force: true });
+  await run("git", ["worktree", "prune"], { cwd: options.cwd }).catch(() => {
+  });
+  try {
+    await run("git", ["worktree", "add", "--detach", path, options.branch], { cwd: options.cwd });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not check out ${options.branch}: ${detail.split("\n").slice(-2).join(" ").trim()}`);
+  }
+  const cleanup = async () => {
+    await run("git", ["worktree", "remove", "--force", path], { cwd: options.cwd }).catch(() => {
+    });
+    await rm(path, { recursive: true, force: true }).catch(() => {
+    });
+  };
+  try {
+    log(`installing ${options.branch}`);
+    await run(options.installCommand, {
+      cwd: path,
+      shell: true,
+      timeout: INSTALL_TIMEOUT_MS,
+      maxBuffer: 32 * 1024 * 1024
+    });
+  } catch (error) {
+    await cleanup();
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Install failed in ${options.branch}: ${detail.split("\n")[0]}`);
+  }
+  try {
+    const app = await startAppProcess({
+      cwd: path,
+      devCommand: options.devCommand,
+      label: options.branch,
+      readyTimeoutMs,
+      onLog: log
+    });
+    return {
+      branch: options.branch,
+      path,
+      port: app.port,
+      url: app.url,
+      stop: async () => {
+        await app.stop();
+        await cleanup();
+      }
+    };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+async function startAppProcess(options) {
+  const readyTimeoutMs = options.readyTimeoutMs ?? 9e4;
+  const log = options.onLog ?? (() => {
+  });
+  const port = await freePort();
+  let child;
+  try {
+    child = spawn(substitutePort(options.devCommand, port), {
+      cwd: options.cwd,
+      shell: true,
+      // Own process group, so stopping kills the shell and whatever it spawned
+      // rather than orphaning a dev server holding the port.
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error) {
+    throw new Error(`Could not start ${options.label}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let exited = null;
+  child.once("exit", (code) => {
+    exited = code ?? 0;
+  });
+  child.stdout?.on("data", (chunk) => log(chunk.toString().trimEnd()));
+  child.stderr?.on("data", (chunk) => log(chunk.toString().trimEnd()));
+  const stop = async () => {
+    try {
+      if (child.pid !== void 0 && exited === null)
+        process.kill(-child.pid, "SIGTERM");
+    } catch {
+      child.kill("SIGTERM");
+    }
+  };
+  const deadline = Date.now() + readyTimeoutMs;
+  while (Date.now() < deadline) {
+    if (exited !== null) {
+      throw new Error(`${options.label} did not start: its dev command exited with code ${exited}.`);
+    }
+    if (await answers(port)) {
+      return { port, url: `http://127.0.0.1:${port}`, stop };
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  await stop();
+  throw new Error(`${options.label} did not start within ${Math.round(readyTimeoutMs / 1e3)}s. Check that its dev command serves the port it is given.`);
+}
+
+// ../server/dist/requests.js
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
+var SAFE_SEGMENT = /^[a-z0-9][a-z0-9-]*$/i;
+function targetFor(url) {
+  if (!url.startsWith("/"))
+    return null;
+  const query = url.slice(url.indexOf("?") + 1);
+  if (!url.includes("?"))
+    return null;
+  for (const pair of query.split("&")) {
+    const [rawKey, rawValue] = pair.split("=");
+    if (rawKey === void 0 || rawValue === void 0)
+      continue;
+    if (!rawKey.startsWith("v-"))
+      continue;
+    const surface = rawKey.slice(2);
+    const option = decodeURIComponent(rawValue);
+    if (!SAFE_SEGMENT.test(surface) || !SAFE_SEGMENT.test(option))
+      return null;
+    return `.leglas/variants/${surface}/${option}.tsx`;
+  }
+  return null;
+}
+function composeRequest(preview, intent) {
+  const target = preview.file ?? targetFor(preview.url);
+  const cleaned = intent.trim();
+  const where = target === null ? `The direction is titled "${preview.title}" and renders at ${preview.url}. Find what produces it.` : `It lives at ${target}.`;
+  const prompt = `In this project, change only the "${preview.title}" design direction. ${where}
+
+What to change: ${cleaned}
+
+Leave every other direction exactly as it is; they are alternatives being compared side by side, so changing a sibling destroys the comparison. The direction is already registered, so nothing needs re-registering. Keep the change additive: do not rewrite shared components that other directions rely on.`;
+  return { prompt, target };
+}
+var REQUESTS_PATH = ".leglas/requests.json";
+async function readRequests(cwd) {
+  try {
+    const raw = await readFile3(join4(cwd, REQUESTS_PATH), "utf8");
+    const parsed2 = JSON.parse(raw);
+    return Array.isArray(parsed2.requests) ? parsed2.requests : [];
+  } catch {
+    return [];
+  }
+}
+async function writeQueue(cwd, requests) {
+  const path = join4(cwd, REQUESTS_PATH);
+  await mkdir2(dirname3(path), { recursive: true });
+  await writeFile2(path, `${JSON.stringify({ requests }, null, 2)}
+`, "utf8");
+}
+async function appendRequest(cwd, request) {
+  await writeQueue(cwd, [...await readRequests(cwd), request]);
+}
+async function clearRequests(cwd) {
+  await writeQueue(cwd, []);
+}
+
+// ../server/dist/server.js
+import { createReadStream, existsSync as existsSync2, statSync } from "fs";
+import http2 from "http";
+import net3 from "net";
+import { extname, join as join5, normalize } from "path";
+var LEGLAS_PREFIX = "/leglas";
+var DEFAULT_PORT = 4100;
+var PORT_ATTEMPTS = 20;
+var CONTENT_TYPES = {
+  ".css": "text/css; charset=utf-8",
+  ".gif": "image/gif",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+var FILES_PREFIX = `${LEGLAS_PREFIX}/files`;
+function sendJson(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store"
+  });
+  res.end(payload);
+}
+function probe(target, timeoutMs = 1e3) {
+  return new Promise((resolve) => {
+    let url;
+    try {
+      url = new URL(target);
+    } catch {
+      return resolve(false);
+    }
+    const port = Number(url.port || (url.protocol === "https:" ? 443 : 80));
+    const socket = net3.connect(port, url.hostname);
+    const settle = (reachable) => {
+      socket.destroy();
+      resolve(reachable);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => settle(true));
+    socket.once("timeout", () => settle(false));
+    socket.once("error", () => settle(false));
+  });
+}
+function serveFrom(res, dir, relativePath) {
+  const relative3 = normalize(relativePath).replace(/^(\.\.[/\\])+/, "");
+  const candidate = join5(dir, relative3);
+  if (!candidate.startsWith(dir))
+    return false;
+  if (!existsSync2(candidate) || !statSync(candidate).isFile())
+    return false;
+  res.writeHead(200, {
+    "content-type": CONTENT_TYPES[extname(candidate)] ?? "application/octet-stream",
+    "cache-control": "no-store"
+  });
+  createReadStream(candidate).pipe(res);
+  return true;
+}
+function serveShellFile(res, shellDir, urlPath) {
+  const relative3 = normalize(urlPath.slice(LEGLAS_PREFIX.length)).replace(/^(\.\.[/\\])+/, "");
+  const isRoot = relative3 === "" || relative3 === "." || relative3 === "/";
+  return serveFrom(res, shellDir, isRoot ? "index.html" : relative3);
+}
+var PLACEHOLDER = `<!doctype html>
+<meta charset="utf-8">
+<title>Leglas</title>
+<body style="font:14px/1.6 ui-sans-serif,system-ui;padding:3rem;max-width:34rem">
+<h1 style="font-size:1rem">Leglas</h1>
+<p>The server is running and proxying your app. The interface has not been
+built into this install yet.</p>
+<p><a href="/leglas/api/config">/leglas/api/config</a> \xB7
+<a href="/leglas/api/health">/leglas/api/health</a></p>
+</body>`;
+function listen(server, port) {
+  return new Promise((resolve, reject) => {
+    const onError = (error) => {
+      server.removeListener("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.removeListener("error", onError);
+      const address = server.address();
+      resolve(typeof address === "object" && address !== null ? address.port : port);
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, "127.0.0.1");
+  });
+}
+async function bind(server, requested) {
+  if (requested === 0)
+    return listen(server, 0);
+  for (let attempt = 0; attempt < PORT_ATTEMPTS; attempt += 1) {
+    try {
+      return await listen(server, requested + attempt);
+    } catch (error) {
+      if (error.code !== "EADDRINUSE")
+        throw error;
+    }
+  }
+  throw new Error(`No free port between ${requested} and ${requested + PORT_ATTEMPTS - 1}.`);
+}
+async function startServer(options) {
+  const { config, configErrors = [], shellDir = null, project = "", cwd = process.cwd(), fileMounts = /* @__PURE__ */ new Map() } = options;
+  const target = config?.devServer ?? "http://localhost:3000";
+  const proxy = createProxyHandler({ target });
+  const server = http2.createServer((req, res) => {
+    const url = req.url ?? "/";
+    const path = url.split("?")[0] ?? "/";
+    if (path === `${LEGLAS_PREFIX}/api/config`) {
+      return sendJson(res, 200, {
+        project,
+        devServer: target,
+        previews: config?.previews ?? [],
+        errors: configErrors
+      });
+    }
+    if (path === `${LEGLAS_PREFIX}/api/request` && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      return void req.on("end", () => {
+        let parsed2;
+        try {
+          parsed2 = JSON.parse(body || "{}");
+        } catch {
+          return sendJson(res, 400, { ok: false, error: "Body must be JSON." });
+        }
+        const preview = (config?.previews ?? []).find((entry) => entry.title === parsed2.title);
+        if (!preview || !parsed2.intent?.trim()) {
+          return sendJson(res, 400, { ok: false, error: "Unknown preview, or empty request." });
+        }
+        const composed = composeRequest(preview, parsed2.intent);
+        void appendRequest(cwd, {
+          title: preview.title,
+          url: preview.url,
+          intent: parsed2.intent.trim(),
+          ...composed
+        }).then(() => sendJson(res, 200, { ok: true, ...composed })).catch(() => sendJson(res, 200, { ok: true, ...composed, queued: false }));
+      });
+    }
+    if (path === `${LEGLAS_PREFIX}/api/health`) {
+      return void probe(target).then((reachable) => sendJson(res, 200, { devServer: target, reachable }));
+    }
+    if (path.startsWith(`${FILES_PREFIX}/`)) {
+      const rest = path.slice(FILES_PREFIX.length + 1);
+      const slash = rest.indexOf("/");
+      const slug = slash === -1 ? rest : rest.slice(0, slash);
+      let relative3 = slash === -1 ? "" : rest.slice(slash + 1);
+      try {
+        relative3 = decodeURIComponent(relative3);
+      } catch {
+        relative3 = "";
+      }
+      const dir = fileMounts.get(slug);
+      if (dir !== void 0 && relative3 !== "" && serveFrom(res, dir, relative3))
+        return;
+      res.writeHead(404, { "content-type": "text/plain; charset=utf-8", "cache-control": "no-store" });
+      return res.end("Leglas: no such preview file.");
+    }
+    if (path === LEGLAS_PREFIX || path.startsWith(`${LEGLAS_PREFIX}/`)) {
+      if (shellDir !== null && serveShellFile(res, shellDir, path))
+        return;
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
+      return res.end(PLACEHOLDER);
+    }
+    return proxy.request(req, res, `http://localhost:${port}`);
+  });
+  const sockets = /* @__PURE__ */ new Set();
+  server.on("connection", (socket) => {
+    sockets.add(socket);
+    socket.once("close", () => sockets.delete(socket));
+  });
+  server.on("upgrade", (req, socket, head) => {
+    const path = (req.url ?? "/").split("?")[0] ?? "/";
+    if (path.startsWith(`${LEGLAS_PREFIX}/`))
+      return socket.destroy();
+    proxy.upgrade(req, socket, head);
+  });
+  const port = await bind(server, options.port ?? DEFAULT_PORT);
+  return {
+    port,
+    url: `http://localhost:${port}`,
+    close: () => new Promise((done) => {
+      for (const socket of sockets)
+        socket.destroy();
+      sockets.clear();
+      server.closeAllConnections();
+      server.close(() => done());
+    })
+  };
+}
+
+// src/run-classify.ts
+async function runClassify(options, deps) {
+  const declared = await Promise.all(
+    options.changes.map(async (change) => ({
+      ...change,
+      exists: await stat(join6(options.cwd, change.path)).then(
+        () => true,
+        () => false
+      )
+    }))
+  );
+  const placement = classifyDirection({ changes: declared });
+  if (options.json) {
+    deps.log(
+      JSON.stringify({
+        ok: true,
+        level: placement.level,
+        reason: placement.reason,
+        steps: placement.steps
+      })
+    );
+    return { exitCode: 0 };
+  }
+  deps.log(`  ${placement.level}`);
+  deps.log(`  ${placement.reason}`);
+  deps.log("");
+  placement.steps.forEach((step, index) => deps.log(`  ${index + 1}. ${step}`));
+  return { exitCode: 0 };
+}
+
+// src/baseline.ts
+var NAMED_EXPORT = /export\s+(?:async\s+)?(?:function|const|class)\s+([A-Z][A-Za-z0-9_]*)/;
+var DEFAULT_EXPORT = /export\s+default\s+(?:async\s+)?(?:function|class)\s+([A-Z][A-Za-z0-9_]*)/;
+var BARE_DEFAULT = /export\s+default\s/;
+function baselineFrom(surface, sourcePath, sourceContents) {
+  const normalised = sourcePath.replace(/\\/g, "/");
+  const withoutExtension = normalised.replace(/\.[jt]sx?$/, "");
+  const importPath = `../../../${withoutExtension}`;
+  const defaultMatch = DEFAULT_EXPORT.exec(sourceContents);
+  const namedMatch = NAMED_EXPORT.exec(sourceContents);
+  let name;
+  let importLine;
+  if (namedMatch?.[1]) {
+    name = namedMatch[1];
+    importLine = `import { ${name} } from "${importPath}";`;
+  } else if (defaultMatch?.[1]) {
+    name = defaultMatch[1];
+    importLine = `import ${name} from "${importPath}";`;
+  } else if (BARE_DEFAULT.test(sourceContents)) {
+    name = `${surface.charAt(0).toUpperCase()}${surface.slice(1)}Current`;
+    importLine = `import ${name} from "${importPath}";`;
+  } else {
+    return null;
+  }
+  return {
+    contents: `// The current design, re-exported from ${normalised} rather than copied,
+// so this baseline stays live: change that component and the comparison
+// changes with it.
+${importLine}
+
+export function Current() {
+  return <${name} />;
+}
+`
+  };
+}
+
+// src/ignore.ts
+var IGNORED = ".leglas/";
+function ignoreEntry(current) {
+  const lines = (current ?? "").split("\n").map((line) => line.trim());
+  if (lines.some((line) => line === IGNORED || line === ".leglas")) return null;
+  const body = (current ?? "").replace(/\n*$/, "");
+  const preamble = body === "" ? "" : `${body}
+
+`;
+  return `${preamble}# Leglas exploration: variant code, caches, logs.
+${IGNORED}
+`;
+}
+
+// src/new.ts
+function detectFramework(packageJson) {
+  if (!packageJson) return "react";
+  try {
+    const parsed2 = JSON.parse(packageJson);
+    const deps = { ...parsed2.dependencies, ...parsed2.devDependencies };
+    return "next" in deps ? "next" : "react";
+  } catch {
+    return "react";
+  }
+}
+function surfaceSlug(surface) {
+  return surface.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+function titleCase(slug) {
+  return slug.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function nextSwitcher(slug) {
+  return `// Generated by leglas new. Plain application code: it imports nothing
+// from Leglas, so deleting the tool leaves this working.
+//
+// Add a direction by dropping a component beside this file and listing it in
+// DIRECTIONS. Everything renders from one running server, so switching is
+// instant.
+import { Current } from "./current";
+import { ${titleCase(slug).replace(/\s/g, "")}A } from "./${slug}-a";
+
+const DIRECTIONS = {
+  current: Current,
+  "${slug}-a": ${titleCase(slug).replace(/\s/g, "")}A,
+} as const;
+
+type Direction = keyof typeof DIRECTIONS;
+const FALLBACK: Direction = "current";
+
+type SearchParams = Record<string, string | string[] | undefined>;
+
+/**
+ * Production always renders the fallback, whatever the URL says, so a branch
+ * point that reaches a deployed build cannot expose an unreleased direction.
+ */
+export function resolve${titleCase(slug).replace(/\s/g, "")}(searchParams: SearchParams): Direction {
+  if (process.env.NODE_ENV === "production") return FALLBACK;
+  const raw = searchParams["v-${slug}"];
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  return value !== undefined && value in DIRECTIONS ? (value as Direction) : FALLBACK;
+}
+
+export function ${titleCase(slug).replace(/\s/g, "")}Switch({ searchParams }: { searchParams: SearchParams }) {
+  const Direction = DIRECTIONS[resolve${titleCase(slug).replace(/\s/g, "")}(searchParams)];
+  return <Direction />;
+}
+`;
+}
+function reactSwitcher(slug) {
+  const name = titleCase(slug).replace(/\s/g, "");
+  return `// Generated by leglas new. Plain application code: it imports nothing
+// from Leglas, so deleting the tool leaves this working.
+//
+// Add a direction by dropping a component beside this file and listing it in
+// DIRECTIONS. Everything renders from one running server, so switching is
+// instant.
+import { Current } from "./current";
+import { ${name}A } from "./${slug}-a";
+
+const DIRECTIONS = {
+  current: Current,
+  "${slug}-a": ${name}A,
+} as const;
+
+type Direction = keyof typeof DIRECTIONS;
+const FALLBACK: Direction = "current";
+
+/**
+ * Typed locally rather than relying on bundler-provided globals, so this file
+ * compiles in any project without extra type packages installed.
+ */
+function isProduction(): boolean {
+  const meta = import.meta as ImportMeta & { env?: { PROD?: boolean } };
+  if (meta.env?.PROD === true) return true;
+  const runtime = globalThis as { process?: { env?: { NODE_ENV?: string } } };
+  return runtime.process?.env?.NODE_ENV === "production";
+}
+
+/**
+ * Production always renders the fallback, whatever the URL says, so a branch
+ * point that reaches a deployed build cannot expose an unreleased direction.
+ */
+export function resolve${name}(): Direction {
+  if (isProduction()) return FALLBACK;
+  const value = new URLSearchParams(window.location.search).get("v-${slug}");
+  return value !== null && value in DIRECTIONS ? (value as Direction) : FALLBACK;
+}
+
+export function ${name}Switch() {
+  const Direction = DIRECTIONS[resolve${name}()];
+  return <Direction />;
+}
+`;
+}
+function placeholder(label, note) {
+  return `export function ${label}() {
+  return (
+    <div style={{ padding: "3rem", fontFamily: "system-ui" }}>
+      <p>${note}</p>
+    </div>
+  );
+}
+`;
+}
+function planNew(options) {
+  const slug = surfaceSlug(options.surface);
+  const framework = detectFramework(options.packageJson);
+  const name = titleCase(slug).replace(/\s/g, "");
+  const dir = `.leglas/variants/${slug}`;
+  const writes = [
+    {
+      path: `${dir}/switch.tsx`,
+      contents: framework === "next" ? nextSwitcher(slug) : reactSwitcher(slug)
+    },
+    {
+      path: `${dir}/current.tsx`,
+      contents: (options.from ? baselineFrom(slug, options.from.path, options.from.contents) : null)?.contents ?? placeholder(
+        "Current",
+        `Re-export what your ${slug} renders today, for example: import { ${name} } from "../../../src/${name}" and return <${name} />. Re-exporting rather than copying keeps this baseline live.`
+      )
+    },
+    {
+      path: `${dir}/${slug}-a.tsx`,
+      contents: placeholder(`${name}A`, `A first direction for ${slug}. Change it and watch it reload.`)
+    }
+  ];
+  const gitignore = ignoreEntry(options.gitignore);
+  const usage = framework === "next" ? `<${name}Switch searchParams={await searchParams} />` : `<${name}Switch />`;
+  return {
+    writes,
+    gitignore,
+    previews: [
+      { title: "Current", url: `/?v-${slug}=current` },
+      { title: `${titleCase(slug)} A`, url: `/?v-${slug}=${slug}-a` }
+    ],
+    instructions: `One change is left to you, where your ${slug} renders. Import ${name}Switch from ${dir}/switch and use it in place of the current element:
+
+  ${usage}
+
+Rewriting your component automatically is how a tool breaks a codebase it does not understand, so this step stays yours.
+`
+  };
+}
+
+// src/briefs.ts
+var ALL_BRIEFS = [
+  {
+    slug: "quiet",
+    name: "Quiet",
+    brief: "Reduce until almost nothing is left. Generous whitespace, a single focal element, and typography carrying the whole hierarchy. Remove decoration rather than softening it.",
+    avoid: "Adding a subtle gradient or a lighter shade and calling the result minimal."
+  },
+  {
+    slug: "image-led",
+    name: "Image-led",
+    brief: "Let imagery be the page. Full-bleed visual, text as a restrained overlay, and a composition that follows the artwork rather than sitting beside it.",
+    avoid: "Keeping the existing layout and enlarging the picture inside it."
+  },
+  {
+    slug: "kinetic",
+    name: "Kinetic",
+    brief: "Motion carries the hierarchy. Something continuous and ambient, with elements arriving in a deliberate sequence. Honour prefers-reduced-motion with a still composition that still works.",
+    avoid: "A fade-in on scroll bolted onto the current design."
+  },
+  {
+    slug: "editorial",
+    name: "Editorial",
+    brief: "Compose it like a magazine spread. Asymmetric grid, large display type with tight leading, rules and captions, imagery treated as a plate rather than a background.",
+    avoid: "A centred headline above a centred paragraph."
+  },
+  {
+    slug: "dense",
+    name: "Dense",
+    brief: "Information forward. Tighter rhythm, smaller type, several entry points visible at once, and the confidence that the reader wants more rather than less.",
+    avoid: "The same layout with the padding reduced."
+  },
+  {
+    slug: "high-contrast",
+    name: "High contrast",
+    brief: "Commit to a hard palette: near-black against one saturated accent, or the whole thing inverted. Define shapes with edges rather than gradients.",
+    avoid: "Darkening the existing palette by a few steps."
+  },
+  {
+    slug: "material",
+    name: "Material",
+    brief: "Give it depth and surface. Layered planes, grain or noise, shadow used structurally to stack elements, a sense that the parts are physical objects.",
+    avoid: "One drop shadow on an otherwise flat card."
+  },
+  {
+    slug: "type-led",
+    name: "Type-led",
+    brief: "Remove imagery entirely. Build the composition from letterforms: extreme scale contrast, a second typeface earning its place, text as the visual itself.",
+    avoid: "Keeping the image and setting the headline larger."
+  },
+  {
+    slug: "playful",
+    name: "Playful",
+    brief: "Deliberate imperfection. Rotation, overlap, irregular or hand-made elements, and one colour that ought not to work but does.",
+    avoid: "Increasing the border radius and little else."
+  },
+  {
+    slug: "systemic",
+    name: "Systemic",
+    brief: "Make the structure visible. Modular blocks on a stated grid, consistent module sizes, alignment itself as the aesthetic.",
+    avoid: "Adding borders around the sections that already exist."
+  }
+];
+function briefsFor(count) {
+  if (!Number.isFinite(count) || count <= 0) return [];
+  return ALL_BRIEFS.slice(0, Math.min(Math.floor(count), ALL_BRIEFS.length));
+}
+function planBriefs(surface, count) {
+  const slug = surfaceSlug(surface);
+  const chosen = briefsFor(count);
+  const previews = chosen.map((brief) => ({
+    title: brief.name,
+    url: `/?v-${slug}=${brief.slug}`
+  }));
+  const commands = chosen.map(
+    (brief) => `leglas add --title ${JSON.stringify(brief.name)} --url ${JSON.stringify(
+      `/?v-${slug}=${brief.slug}`
+    )} --note ${JSON.stringify(`${brief.brief.split(".")[0]}.`)}`
+  );
+  const instructions = `Build ${chosen.length} direction${chosen.length === 1 ? "" : "s"} for "${surface}", one per angle below.
+
+Each goes in its own file under .leglas/variants/${slug}/, named after its slug, and is listed in the DIRECTIONS map in that folder's switch file. If the surface has no switch file yet, run \`leglas new ${slug}\` first.
+
+Keep them distinct from each other. The point of exploring several at once is that they disagree; directions that converge on one look waste the exercise. Read each angle's "avoid" line before starting, because it names the obvious reading that collapses the difference.
+
+Then register them:
+
+` + commands.map((command) => `  ${command}`).join("\n");
+  return { previews, commands, instructions };
+}
+
+// src/run-explore.ts
+function runExplore(options, deps) {
+  const chosen = briefsFor(options.count);
+  if (chosen.length === 0) {
+    deps.log(
+      options.json ? JSON.stringify({ ok: false, error: "Ask for at least one direction." }) : "Ask for at least one direction, for example --count 4."
+    );
+    return { exitCode: 1 };
+  }
+  const plan = planBriefs(options.surface, options.count);
+  if (options.json) {
+    deps.log(
+      JSON.stringify({
+        ok: true,
+        surface: options.surface,
+        directions: chosen,
+        previews: plan.previews,
+        commands: plan.commands,
+        instructions: plan.instructions
+      })
+    );
+    return { exitCode: 0 };
+  }
+  if (options.count > ALL_BRIEFS.length) {
+    deps.log(
+      `Asked for ${options.count}; there are ${ALL_BRIEFS.length} distinct angles, so ${ALL_BRIEFS.length} follow.`
+    );
+    deps.log("");
+  }
+  for (const brief of chosen) {
+    deps.log(`${brief.name}`);
+    deps.log(`  ${brief.brief}`);
+    deps.log(`  Avoid: ${brief.avoid}`);
+    deps.log("");
+  }
+  deps.log(plan.instructions);
+  return { exitCode: 0 };
+}
+
+// src/run-init.ts
+import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { join as join7 } from "path";
+
+// src/init.ts
+var AGENTS_MARKER_START = "<!-- leglas:start -->";
+var AGENTS_MARKER_END = "<!-- leglas:end -->";
+var AGENTS_SECTION = `${AGENTS_MARKER_START}
+
+## Design directions (Leglas)
+
+This project uses Leglas to compare design directions inside the running app.
+A direction is just a URL; the app decides what it renders, and Leglas only
+displays it.
+
+This is small, additive work: a few self-contained files and a command per
+direction. Build it directly. A planning or approval step before implementing
+costs more than the work itself, and the directions on screen are the thing
+being asked for.
+
+When asked for design variations, alternatives, or "a few options":
+
+1. **Add beside what exists. Never replace it.** Every direction has to render
+   from the one dev server that is already running, which is what makes
+   switching between them instant. Two directions that rewrite the same file
+   cannot both exist, and recovering from that costs a rebuild per direction.
+   If a direction cannot be additive, because it must change dependencies,
+   change build configuration, or rewrite an existing file's behaviour, ask
+   where it should live before writing it:
+   \`leglas classify --change package.json --rewrite src/theme.css --json\`.
+   When the answer is \`checkout\`, build the direction on its own git branch
+   and register it with \`leglas add --title "\u2026" --url "/" --branch <branch>\`
+   (the config needs \`devCommand\` with \`{port}\`). Everything below is the
+   ordinary, in-app path.
+2. Run \`leglas explore <surface> --count <n>\` first. It returns distinct
+   angles to build, each with what to avoid, so several directions genuinely
+   disagree instead of becoming shades of one idea. Follow those angles rather
+   than inventing your own variations of the current design.
+3. If the surface has no switcher yet, run
+   \`leglas new <surface> --from <the component that renders it today>\`. It
+   writes one under \`.leglas/variants/<surface>/\` and prints the single line
+   to add where that surface renders. \`--from\` makes the baseline re-export
+   the real component rather than copying it, so it stays live.
+4. Put each direction in its own file beside the others in
+   \`.leglas/variants/<surface>/\`, then list it in the \`DIRECTIONS\` map in
+   that folder's \`switch\` file.
+5. Register each one so it appears in the interface:
+   \`leglas add --title "Aurora" --url "/?v-<surface>=aurora" --note "One line on the idea."\`
+6. Tell the user to open the interface, or to run \`leglas\` if it is not
+   already running.
+
+When the user asks to change one direction, check \`leglas requests --json\`
+first: they may have described it from the interface, and the request names the
+exact file. Clear the queue with \`leglas requests --clear\` once done.
+
+When the user picks a winner, run
+\`leglas keep "<title>" --to <path in real source>\`. It moves that direction
+out of the ignored directory, deletes the rest of the exploration, and drops
+them from the rail. Then change their component to use the kept component
+instead of the switcher.
+
+Useful to know:
+
+- \`.leglas/\` is gitignored. Exploration is disposable and nothing in there
+  ships. Move a direction into real source only when it wins.
+- If the project has no running app yet, a direction can be a plain HTML
+  file: write it under \`.leglas/pages/\` and register it with
+  \`leglas add --title "Aurora" --file .leglas/pages/aurora.html\`. Leglas
+  serves the file itself, so no dev server is needed. Sibling assets in the
+  same directory resolve normally.
+- Titles identify previews and must be unique.
+- \`leglas list\` shows every direction, shared and local.
+- Every command accepts \`--json\` and prints one envelope with a stable exit
+  code, so you can drive it without parsing prose.
+
+${AGENTS_MARKER_END}
+`;
+var STARTER_CONFIG = `// Previews are URLs of your own app. Add one per direction you want to
+// compare, then run \`leglas\`.
+export default {
+  // Where your dev server is. Override at the command line with --user-port.
+  devServer: "http://localhost:3000",
+  previews: [{ title: "Current", url: "/" }],
+};
+`;
+function planInit(options) {
+  const writes = [];
+  const agents = options.agents ?? "";
+  const hasSection = agents.includes(AGENTS_MARKER_START);
+  if (!hasSection) {
+    const preamble = agents.replace(/\n*$/, "");
+    writes.push({
+      path: "AGENTS.md",
+      contents: preamble === "" ? AGENTS_SECTION : `${preamble}
+
+${AGENTS_SECTION}`
+    });
+  } else if (options.force === true) {
+    const start = agents.indexOf(AGENTS_MARKER_START);
+    const end = agents.indexOf(AGENTS_MARKER_END);
+    const after = end === -1 ? "" : agents.slice(end + AGENTS_MARKER_END.length);
+    writes.push({
+      path: "AGENTS.md",
+      contents: `${agents.slice(0, start)}${AGENTS_SECTION.replace(/\n$/, "")}${after}`
+    });
+  }
+  if (options.config === null) {
+    writes.push({ path: "leglas.config.ts", contents: STARTER_CONFIG });
+  }
+  return { writes, gitignore: ignoreEntry(options.gitignore) };
+}
+
+// src/run-init.ts
+async function readIfPresent(path) {
+  try {
+    return await readFile4(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function runInit(options, deps) {
+  const existingConfig = findConfigFile(options.cwd);
+  const plan = planInit({
+    agents: await readIfPresent(join7(options.cwd, "AGENTS.md")),
+    config: existingConfig === null ? null : "present",
+    gitignore: await readIfPresent(join7(options.cwd, ".gitignore")),
+    force: options.force
+  });
+  const touched = [];
+  for (const write of plan.writes) {
+    await writeFile3(join7(options.cwd, write.path), write.contents, "utf8");
+    touched.push(write.path);
+  }
+  if (plan.gitignore !== null) {
+    await writeFile3(join7(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    touched.push(".gitignore");
+  }
+  if (options.json) {
+    deps.log(JSON.stringify({ ok: true, written: touched }));
+    return { exitCode: 0 };
+  }
+  if (touched.length === 0) {
+    deps.log("Already set up. Nothing to change.");
+    return { exitCode: 0 };
+  }
+  for (const path of touched) deps.log(`  wrote  ${path}`);
+  deps.log("");
+  deps.log("Your agents now know how to add design directions to this project.");
+  deps.log("Ask one for a few variations of a surface, then run leglas.");
+  return { exitCode: 0 };
+}
+
+// src/run-keep.ts
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir3, readFile as readFile5, rm as rm2, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname4, join as join8 } from "path";
+
+// src/keep.ts
+import { basename as basename2, extname as extname2, normalize as normalize2 } from "path";
+function surfaceOf(url) {
+  if (!url.startsWith("/") || !url.includes("?")) return null;
+  for (const pair of url.slice(url.indexOf("?") + 1).split("&")) {
+    const key = pair.split("=")[0];
+    if (key?.startsWith("v-")) return key.slice(2);
+  }
+  return null;
+}
+function exportNameFor(to) {
+  const stem = basename2(to, extname2(to));
+  return stem.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function planKeep(options) {
+  const winner = options.previews.find((preview) => preview.title === options.title);
+  if (!winner) {
+    return {
+      ok: false,
+      error: `No direction called ${JSON.stringify(options.title)}. Run leglas list to see them.`
+    };
+  }
+  const from = targetFor(winner.url);
+  const surface = surfaceOf(winner.url);
+  if (from === null || surface === null) {
+    return {
+      ok: false,
+      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("..")) {
+    return { ok: false, error: "The destination has to be inside the project." };
+  }
+  if (to.split(/[/\\]/)[0] === ".leglas") {
+    return {
+      ok: false,
+      error: "The destination cannot be inside .leglas, which is ignored and gets deleted."
+    };
+  }
+  const dropTitles = options.previews.filter((preview) => surfaceOf(preview.url) === surface).map((preview) => preview.title);
+  const exportName = exportNameFor(to);
+  return {
+    ok: true,
+    move: { from, to },
+    removeDir: `.leglas/variants/${surface}`,
+    dropTitles,
+    exportName,
+    instructions: `${options.title} now lives at ${to}, exported as ${exportName}. Point your component at it instead of the switcher, and the exploration is gone:
+
+  <${exportName} />
+`
+  };
+}
+
+// src/run-keep.ts
+function renameExport(source, to) {
+  const match = /export function ([A-Za-z0-9_]+)\s*\(/.exec(source);
+  if (!match || match[1] === void 0) return source;
+  return source.replace(
+    new RegExp(`\\b${match[1]}\\b`, "g"),
+    to
+  );
+}
+async function runKeep(options, deps) {
+  const loaded = await loadConfig(options.cwd);
+  const local = await readLocalPreviews(options.cwd);
+  const previews = [...loaded.config?.previews ?? [], ...local.previews];
+  const plan = planKeep({ title: options.title, previews, to: options.to });
+  const fail = (error) => {
+    if (options.json) deps.log(JSON.stringify({ ok: false, error }));
+    else deps.error(error);
+    return { exitCode: 1 };
+  };
+  if (!plan.ok) return fail(plan.error);
+  const from = join8(options.cwd, plan.move.from);
+  const to = join8(options.cwd, plan.move.to);
+  if (!existsSync3(from)) {
+    return fail(`${plan.move.from} does not exist. Nothing to keep.`);
+  }
+  if (existsSync3(to)) {
+    return fail(`${plan.move.to} already exists. Choose another destination or move it aside.`);
+  }
+  const source = await readFile5(from, "utf8");
+  await mkdir3(dirname4(to), { recursive: true });
+  await writeFile4(to, renameExport(source, plan.exportName), "utf8");
+  await rm2(join8(options.cwd, plan.removeDir), { recursive: true, force: true });
+  const dropped = await dropLocalPreviews(options.cwd, plan.dropTitles);
+  if (options.json) {
+    deps.log(
+      JSON.stringify({
+        ok: true,
+        kept: options.title,
+        to: plan.move.to,
+        exportName: plan.exportName,
+        removed: plan.removeDir,
+        droppedPreviews: dropped,
+        instructions: plan.instructions
+      })
+    );
+    return { exitCode: 0 };
+  }
+  deps.log(`  kept     ${plan.move.to}`);
+  deps.log(`  removed  ${plan.removeDir}`);
+  if (dropped > 0) {
+    deps.log(`  dropped  ${dropped} direction${dropped === 1 ? "" : "s"} from the rail`);
+  }
+  const stillShared = plan.dropTitles.filter(
+    (title) => !local.previews.some((preview) => preview.title === title)
+  );
+  if (stillShared.length > 0) {
+    deps.log("");
+    deps.log(`  Remove these from leglas.config.ts by hand: ${stillShared.join(", ")}`);
+  }
+  deps.log("");
+  deps.log(plan.instructions);
+  return { exitCode: 0 };
+}
+
+// src/run-new.ts
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname5, join as join9 } from "path";
+async function readIfPresent2(path) {
+  try {
+    return await readFile6(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function runNew(options, deps) {
+  let from;
+  if (options.from !== void 0) {
+    const contents = await readIfPresent2(join9(options.cwd, options.from));
+    if (contents === null) {
+      const message = `${options.from} does not exist, so there is nothing to use as the baseline.`;
+      if (options.json) deps.log(JSON.stringify({ ok: false, error: message }));
+      else deps.log(message);
+      return { exitCode: 1, written: [] };
+    }
+    from = { path: options.from, contents };
+  }
+  const plan = planNew({
+    surface: options.surface,
+    packageJson: await readIfPresent2(join9(options.cwd, "package.json")),
+    gitignore: await readIfPresent2(join9(options.cwd, ".gitignore")),
+    from
+  });
+  const fail = (error) => {
+    if (options.json) deps.log(JSON.stringify({ ok: false, error }));
+    else deps.log(error);
+    return { exitCode: 1, written: [] };
+  };
+  if (plan.writes.length === 0) {
+    return fail(`Nothing to scaffold for ${JSON.stringify(options.surface)}.`);
+  }
+  if (options.print) {
+    if (options.json) {
+      deps.log(JSON.stringify({ ok: true, files: plan.writes, instructions: plan.instructions, previews: plan.previews }));
+      return { exitCode: 0, written: [] };
+    }
+    for (const write of plan.writes) {
+      deps.log(`--- ${write.path}`);
+      deps.log(write.contents);
+    }
+    deps.log(plan.instructions);
+    return { exitCode: 0, written: [] };
+  }
+  const existing = plan.writes.filter((write) => existsSync4(join9(options.cwd, write.path)));
+  if (existing.length > 0) {
+    return fail(`${existing[0]?.path} already exists. Delete it first, or pick another surface name.`);
+  }
+  const written = [];
+  for (const write of plan.writes) {
+    const target = join9(options.cwd, write.path);
+    await mkdir4(dirname5(target), { recursive: true });
+    await writeFile5(target, write.contents, "utf8");
+    written.push(write.path);
+  }
+  if (plan.gitignore !== null) {
+    await writeFile5(join9(options.cwd, ".gitignore"), plan.gitignore, "utf8");
+    written.push(".gitignore");
+  }
+  if (options.json) {
+    deps.log(
+      JSON.stringify({ ok: true, written, instructions: plan.instructions, previews: plan.previews })
+    );
+    return { exitCode: 0, written };
+  }
+  for (const path of written) deps.log(`  created  ${path}`);
+  deps.log("");
+  deps.log(plan.instructions);
+  deps.log("Then register them so they appear in the interface:");
+  deps.log("");
+  for (const preview of plan.previews) {
+    deps.log(`  leglas add --title ${JSON.stringify(preview.title)} --url ${JSON.stringify(preview.url)}`);
+  }
+  return { exitCode: 0, written };
+}
+
+// src/run-previews.ts
+import { readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+import { join as join10 } from "path";
+function envelope(deps, ok, body) {
+  deps.log(JSON.stringify({ ok, ...body }));
+}
+async function ensureIgnored(cwd) {
+  const path = join10(cwd, ".gitignore");
+  let current = null;
+  try {
+    current = await readFile7(path, "utf8");
+  } catch {
+    current = null;
+  }
+  const next = ignoreEntry(current);
+  if (next !== null) await writeFile6(path, next, "utf8");
+}
+async function runAdd(options, deps) {
+  const loaded = await loadConfig(options.cwd);
+  const shared = loaded.config?.previews ?? [];
+  const outcome = await addLocalPreview(
+    options.cwd,
+    {
+      title: options.preview.title,
+      url: options.preview.url,
+      note: options.preview.note,
+      tags: options.preview.tags,
+      branch: options.preview.branch,
+      file: options.preview.file
+    },
+    shared
+  );
+  if (!outcome.ok) {
+    if (options.json) envelope(deps, false, { error: outcome.error });
+    else deps.error(outcome.error ?? "Could not add the preview.");
+    return { exitCode: 1 };
+  }
+  await ensureIgnored(options.cwd);
+  const needsDevCommand = options.preview.branch !== void 0 && loaded.config?.devCommand === void 0;
+  if (options.json) {
+    envelope(deps, true, {
+      added: options.preview.title,
+      ...options.preview.url === void 0 ? {} : { url: options.preview.url },
+      local: true,
+      ...options.preview.branch === void 0 ? {} : { branch: options.preview.branch },
+      ...options.preview.file === void 0 ? {} : { file: options.preview.file },
+      ...needsDevCommand ? { warning: "The config sets no devCommand, so Leglas cannot start this branch yet. Add devCommand (with {port}) to the config." } : {}
+    });
+  } else {
+    deps.log(
+      `  added  ${options.preview.title}  ${options.preview.url ?? options.preview.file ?? ""}`
+    );
+    deps.log("");
+    if (needsDevCommand) {
+      deps.log("  ! The config sets no devCommand, so Leglas cannot start this branch yet.");
+      deps.log("    Add devCommand (with {port}) to the config.");
+      deps.log("");
+    }
+    deps.log("Local to this machine. Restart Leglas to see it, or run leglas list.");
+  }
+  return { exitCode: 0 };
+}
+async function runList(options, deps) {
+  const loaded = await loadConfig(options.cwd);
+  const local = await readLocalPreviews(options.cwd);
+  const errors = [...loaded.errors, ...local.errors];
+  const previews = [
+    ...(loaded.config?.previews ?? []).map((preview) => ({ ...preview, local: false })),
+    ...local.previews
+  ];
+  if (options.json) {
+    envelope(deps, errors.length === 0, {
+      previews: previews.map((preview) => ({
+        title: preview.title,
+        url: preview.url,
+        local: preview.local,
+        branch: preview.branch ?? null,
+        file: preview.file ?? null
+      })),
+      errors
+    });
+    return { exitCode: errors.length === 0 ? 0 : 1 };
+  }
+  if (previews.length === 0) {
+    deps.log("No previews yet. Add one with leglas add, or list them in leglas.config.ts.");
+  } else {
+    const width = Math.max(...previews.map((preview) => preview.title.length));
+    for (const preview of previews) {
+      const source = preview.file ?? preview.url;
+      const origin = preview.branch === void 0 ? "" : `  (branch ${preview.branch})`;
+      const scope = preview.local ? "  (local)" : "";
+      deps.log(`  ${preview.title.padEnd(width)}  ${source}${origin}${scope}`);
+    }
+  }
+  for (const error of errors) deps.error(`  ! ${error}`);
+  return { exitCode: errors.length === 0 ? 0 : 1 };
+}
+async function runRequests(options, deps) {
+  if (options.clear) {
+    await clearRequests(options.cwd);
+    if (options.json) envelope(deps, true, { cleared: true });
+    else deps.log("Queue cleared.");
+    return { exitCode: 0 };
+  }
+  const requests = await readRequests(options.cwd);
+  if (options.json) {
+    envelope(deps, true, { requests });
+    return { exitCode: 0 };
+  }
+  if (requests.length === 0) {
+    deps.log("No pending requests.");
+    return { exitCode: 0 };
+  }
+  for (const request of requests) {
+    deps.log(`  ${request.title}: ${request.intent}`);
+    if (request.target !== null) deps.log(`    ${request.target}`);
+  }
+  deps.log("");
+  deps.log("Run leglas requests --json to get the full prompts, then --clear when done.");
+  return { exitCode: 0 };
+}
+
+// src/run.ts
+import { existsSync as existsSync5 } from "fs";
+import { createRequire } from "module";
+import { basename as basename3, dirname as dirname6, join as join11, relative as relative2 } from "path";
+import { fileURLToPath } from "url";
+function findShellDir() {
+  const bundled = join11(dirname6(fileURLToPath(import.meta.url)), "shell");
+  if (existsSync5(join11(bundled, "index.html"))) return bundled;
+  try {
+    const require2 = createRequire(import.meta.url);
+    return dirname6(require2.resolve("@leglas/shell/dist/index.html"));
+  } catch {
+    return null;
+  }
+}
+async function run2(options, deps) {
+  const loaded = await loadConfig(options.cwd);
+  const local = await readLocalPreviews(options.cwd);
+  let devServer = options.userPort === void 0 ? loaded.config?.devServer ?? "http://localhost:3000" : `http://localhost:${options.userPort}`;
+  const merged = loaded.config === null ? null : { ...loaded.config, devServer, previews: [...loaded.config.previews, ...local.previews] };
+  const worktrees = [];
+  const worktreeErrors = [];
+  const previews = [];
+  let app = null;
+  const needsApp = (merged?.previews ?? []).some(
+    (preview) => preview.file === void 0 && preview.branch === void 0 && preview.url.startsWith("/")
+  );
+  if (needsApp && merged?.devCommand !== void 0 && options.userPort === void 0 && !await probe(devServer)) {
+    if (!options.json) deps.log(`  starting your app (${merged.devCommand})\u2026`);
+    try {
+      app = await startAppProcess({
+        cwd: options.cwd,
+        devCommand: merged.devCommand,
+        label: "your app"
+      });
+      devServer = app.url;
+      merged.devServer = app.url;
+    } catch (error) {
+      worktreeErrors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  const fileMounts = /* @__PURE__ */ new Map();
+  for (const preview of merged?.previews ?? []) {
+    if (preview.file !== void 0) {
+      const absolute = join11(options.cwd, preview.file);
+      if (!existsSync5(absolute)) {
+        worktreeErrors.push(
+          `"${preview.title}" names file ${preview.file}, which does not exist. The preview is skipped.`
+        );
+        continue;
+      }
+      let slug = worktreeSlug(preview.title) || "file";
+      for (let suffix = 2; fileMounts.has(slug); suffix += 1) {
+        slug = `${worktreeSlug(preview.title) || "file"}-${suffix}`;
+      }
+      fileMounts.set(slug, dirname6(absolute));
+      previews.push({
+        ...preview,
+        url: `${FILES_PREFIX}/${slug}/${encodeURIComponent(basename3(absolute))}`
+      });
+      continue;
+    }
+    if (preview.branch === void 0) {
+      previews.push(preview);
+      continue;
+    }
+    if (merged?.devCommand === void 0) {
+      worktreeErrors.push(
+        `"${preview.title}" names branch ${preview.branch}, but the config sets no devCommand, so Leglas cannot start that checkout. Add devCommand (with {port}) to the config.`
+      );
+      continue;
+    }
+    if (!options.json) deps.log(`  starting ${preview.branch}\u2026`);
+    try {
+      const worktree = await startWorktree({
+        cwd: options.cwd,
+        branch: preview.branch,
+        installCommand: merged.installCommand,
+        devCommand: merged.devCommand
+      });
+      worktrees.push(worktree);
+      previews.push({ ...preview, url: `${worktree.url}${preview.url}` });
+    } catch (error) {
+      worktreeErrors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  const config = merged === null ? null : { ...merged, previews };
+  const server = await startServer({
+    config,
+    configErrors: [...loaded.errors, ...local.errors, ...worktreeErrors],
+    fileMounts,
+    shellDir: findShellDir(),
+    // The config file identifies the project when there is one; otherwise the
+    // directory does. Either way saved layout survives a port change.
+    project: loaded.path ?? options.cwd,
+    cwd: options.cwd,
+    ...options.port === void 0 ? {} : { port: options.port }
+  });
+  const url = `${server.url}${LEGLAS_PREFIX}`;
+  const previewCount = config?.previews.length ?? 0;
+  const health = await (await fetch(`${server.url}${LEGLAS_PREFIX}/api/health`)).json();
+  if (options.json) {
+    deps.log(
+      JSON.stringify({
+        ok: true,
+        url,
+        port: server.port,
+        devServer,
+        devServerReachable: health.reachable,
+        startedApp: app !== null,
+        previews: previewCount,
+        config: loaded.path,
+        errors: loaded.errors
+      })
+    );
+  } else {
+    const configLabel = loaded.path === null ? "no config file, previewing the app root" : relative2(options.cwd, loaded.path) || loaded.path;
+    deps.log(`Leglas   ${url}`);
+    deps.log(
+      `app      ${devServer}${app !== null ? "  (started by Leglas)" : health.reachable ? "" : "  (not reachable)"}`
+    );
+    deps.log(`config   ${configLabel}`);
+    deps.log(`          ${previewCount} preview${previewCount === 1 ? "" : "s"}`);
+    if (loaded.errors.length + worktreeErrors.length > 0) {
+      deps.log("");
+      for (const error of [...loaded.errors, ...worktreeErrors]) deps.log(`  ! ${error}`);
+      deps.log("  Fix the config and reload; Leglas will pick it up on restart.");
+    }
+    if (!health.reachable && needsApp) {
+      deps.log("");
+      deps.log(`  ! ${devServer} is not reachable. Start your dev server, or`);
+      deps.log("    point Leglas elsewhere with --user-port.");
+      if (merged?.devCommand === void 0) {
+        deps.log("    Set devCommand in the config and Leglas will start it for you.");
+      }
+    }
+  }
+  if (options.open) await deps.open(url);
+  return {
+    exitCode: 0,
+    url,
+    devServer,
+    previewCount,
+    stop: async () => {
+      await Promise.all(worktrees.map((worktree) => worktree.stop().catch(() => {
+      })));
+      await app?.stop().catch(() => {
+      });
+      await server.close();
+    }
+  };
+}
+
+// src/bin.ts
+var HELP = `leglas - compare design directions inside your own running app
+
+Usage
+  leglas init                Prepare a project and teach its agents
+  leglas [options]           Start the server and open the interface
+  leglas new <surface>       Scaffold a branch point for a surface
+  leglas explore <surface>   Print distinct angles for an agent to build
+  leglas classify            Decide where a direction should live
+  leglas add --title T --url U   Register a preview on this machine
+  leglas list                Show every preview, shared and local
+  leglas requests            Show change requests made from the interface
+  leglas keep <title> --to <path>  Keep a winner and end the exploration
+
+Options
+  --user-port <port>   Port your dev server is on (default: from config, or 3000)
+  --port <port>        Port for Leglas itself (default: 4100, next free if taken)
+  --config <path>      Config file to use instead of searching upward
+  --no-open            Do not open the browser
+  --json               Print a single machine-readable envelope
+  -h, --help           Show this
+  -v, --version        Show the version
+
+Options for new
+  --print              Print the scaffold instead of writing it
+  --from <path>        Use an existing component as the baseline
+
+Options for explore
+  --count <n>          How many angles (default 3)
+
+Options for classify
+  --change <path>      A file the direction creates or wires up (repeatable)
+  --rewrite <path>     An existing file whose behaviour it must change (repeatable)
+
+Options for add
+  --note <text>        Second line under the title
+  --tag <text>         Repeatable
+  --branch <name>      Back the preview with a checkout of this git branch
+  --file <path>        Preview a plain HTML file served by Leglas itself
+`;
+function version() {
+  const require2 = createRequire2(import.meta.url);
+  const pkg = require2("../package.json");
+  return pkg.version;
+}
+async function openBrowser(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    spawn2(command, [url], { detached: true, stdio: "ignore" }).unref();
+  } catch {
+  }
+}
+function quietModuleTypeWarning() {
+  const listeners = process.listeners("warning");
+  process.removeAllListeners("warning");
+  process.on("warning", (warning) => {
+    if (warning.code === "MODULE_TYPELESS_PACKAGE_JSON") return;
+    for (const listener of listeners) listener(warning);
+  });
+}
+quietModuleTypeWarning();
+var parsed = parseArgs(process.argv.slice(2));
+if (parsed.kind === "help") {
+  process.stdout.write(HELP);
+  process.exit(0);
+}
+if (parsed.kind === "version") {
+  process.stdout.write(`${version()}
+`);
+  process.exit(0);
+}
+if (parsed.kind === "error") {
+  process.stderr.write(`${parsed.message}
+`);
+  process.exit(2);
+}
+var previewDeps = {
+  log: (line) => process.stdout.write(`${line}
+`),
+  error: (line) => process.stderr.write(`${line}
+`)
+};
+if (parsed.kind === "init") {
+  const outcome = await runInit(
+    { cwd: process.cwd(), force: parsed.force, json: parsed.json },
+    { log: (line) => process.stdout.write(`${line}
+`) }
+  );
+  process.exit(outcome.exitCode);
+}
+if (parsed.kind === "classify") {
+  const outcome = await runClassify(
+    { changes: parsed.changes, json: parsed.json, cwd: process.cwd() },
+    previewDeps
+  );
+  process.exit(outcome.exitCode);
+}
+if (parsed.kind === "add") {
+  const outcome = await runAdd(
+    { preview: parsed.preview, json: parsed.json, cwd: process.cwd() },
+    previewDeps
+  );
+  process.exit(outcome.exitCode);
+}
+if (parsed.kind === "keep") {
+  const outcome = await runKeep(
+    { title: parsed.title, to: parsed.to, json: parsed.json, cwd: process.cwd() },
+    previewDeps
+  );
+  process.exit(outcome.exitCode);
+}
+if (parsed.kind === "explore") {
+  const outcome = runExplore(
+    { surface: parsed.surface, count: parsed.count, json: parsed.json },
+    { log: (line) => process.stdout.write(`${line}
+`) }
+  );
+  process.exit(outcome.exitCode);
+}
+if (parsed.kind === "requests") {
+  const outcome = await runRequests(
+    { json: parsed.json, clear: parsed.clear, cwd: process.cwd() },
+    previewDeps
+  );
+  process.exit(outcome.exitCode);
+}
+if (parsed.kind === "list") {
+  const outcome = await runList({ json: parsed.json, cwd: process.cwd() }, previewDeps);
+  process.exit(outcome.exitCode);
+}
+if (parsed.kind === "new") {
+  const outcome = await runNew(
+    { surface: parsed.surface, print: parsed.print, json: parsed.json, from: parsed.from, cwd: process.cwd() },
+    { log: (line) => process.stdout.write(`${line}
+`) }
+  );
+  process.exit(outcome.exitCode);
+}
+var result = await run2(
+  { ...parsed.options, cwd: process.cwd() },
+  { open: openBrowser, log: (line) => process.stdout.write(`${line}
+`) }
+);
+var stopping = false;
+var shutdown = async () => {
+  if (stopping) return;
+  stopping = true;
+  await result.stop();
+  process.exit(0);
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);