create-adjacent 0.1.0

package/dist/index.js

@@ -0,0 +1,2498 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// ../../node_modules/.bun/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
+var require_src = __commonJS((exports, module) => {
+  var ESC2 = "\x1B";
+  var CSI2 = `${ESC2}[`;
+  var beep = "\x07";
+  var cursor = {
+    to(x, y) {
+      if (!y)
+        return `${CSI2}${x + 1}G`;
+      return `${CSI2}${y + 1};${x + 1}H`;
+    },
+    move(x, y) {
+      let ret = "";
+      if (x < 0)
+        ret += `${CSI2}${-x}D`;
+      else if (x > 0)
+        ret += `${CSI2}${x}C`;
+      if (y < 0)
+        ret += `${CSI2}${-y}A`;
+      else if (y > 0)
+        ret += `${CSI2}${y}B`;
+      return ret;
+    },
+    up: (count = 1) => `${CSI2}${count}A`,
+    down: (count = 1) => `${CSI2}${count}B`,
+    forward: (count = 1) => `${CSI2}${count}C`,
+    backward: (count = 1) => `${CSI2}${count}D`,
+    nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+    prevLine: (count = 1) => `${CSI2}F`.repeat(count),
+    left: `${CSI2}G`,
+    hide: `${CSI2}?25l`,
+    show: `${CSI2}?25h`,
+    save: `${ESC2}7`,
+    restore: `${ESC2}8`
+  };
+  var scroll = {
+    up: (count = 1) => `${CSI2}S`.repeat(count),
+    down: (count = 1) => `${CSI2}T`.repeat(count)
+  };
+  var erase = {
+    screen: `${CSI2}2J`,
+    up: (count = 1) => `${CSI2}1J`.repeat(count),
+    down: (count = 1) => `${CSI2}J`.repeat(count),
+    line: `${CSI2}2K`,
+    lineEnd: `${CSI2}K`,
+    lineStart: `${CSI2}1K`,
+    lines(count) {
+      let clear = "";
+      for (let i = 0;i < count; i++)
+        clear += this.line + (i < count - 1 ? cursor.up() : "");
+      if (count)
+        clear += cursor.left;
+      return clear;
+    }
+  };
+  module.exports = { cursor, scroll, erase, beep };
+});
+
+// ../adjacent-cli/dist/arguments.js
+function resolveCreateOptions(projectName, options) {
+  const name = (projectName ?? "").trim();
+  if (name.length === 0) {
+    throw new Error("A project name is required, for example: adj create my-app");
+  }
+  const directory = options.directory?.trim();
+  return {
+    ...directory === undefined || directory.length === 0 ? null : { directory },
+    install: options.install ?? true,
+    projectName: name
+  };
+}
+// ../adjacent-cli/dist/create.js
+import { relative as relative4, resolve as resolve4 } from "node:path";
+
+// ../adjacent-cli/dist/destination.js
+import { readdir, stat } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+var IGNORED_ENTRIES = new Set([".DS_Store", ".git"]);
+function resolveDestination(projectName, directory, cwd) {
+  if (directory === undefined)
+    return resolve(cwd, projectName);
+  const trimmed = directory.trim();
+  if (trimmed.length === 0) {
+    throw new Error("--directory needs a path, for example: --directory ./apps/my-app");
+  }
+  return isAbsolute(trimmed) ? resolve(trimmed) : resolve(cwd, trimmed);
+}
+async function assertDestinationUsable(destination) {
+  const entry = await stat(destination).catch(() => {
+    return;
+  });
+  if (!entry)
+    return { existed: false };
+  if (!entry.isDirectory()) {
+    throw new Error(`Cannot create a project at ${destination} because a file of that name already exists.`);
+  }
+  const contents = (await readdir(destination)).filter((name) => !IGNORED_ENTRIES.has(name));
+  if (contents.length > 0) {
+    throw new Error(`The directory ${destination} is not empty. Choose another name, pass --directory, or empty it first.`);
+  }
+  return { existed: true };
+}
+
+// ../adjacent-cli/dist/init.js
+import { readFile as readFile4 } from "node:fs/promises";
+import { dirname as dirname3, join as join5, relative as relative3, resolve as resolve3, sep as sep3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// ../adjacent-cli/dist/dependencies.js
+import { readFileSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+var ADJACENT_PACKAGES = [
+  { directory: "adjacent-core", name: "adjacent-core" },
+  { directory: "adjacent-next", name: "adjacent-next" },
+  { directory: "adjacent-react", name: "adjacent-react" },
+  { directory: "adjacent-ui", name: "adjacent-ui" }
+];
+function readOwnVersion() {
+  const manifest = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+  const { version } = JSON.parse(readFileSync(manifest, "utf8"));
+  return version;
+}
+var ADJACENT_VERSION = readOwnVersion();
+var PUBLISHED_ADJACENT_RANGE = `^${ADJACENT_VERSION}`;
+function matchesWorkspaceGlob(path, glob) {
+  const pattern = glob.split("/").map((segment) => segment === "**" ? "[^\\0]*" : segment === "*" ? "[^/]+" : escapeSegment(segment)).join("/");
+  return new RegExp(`^${pattern}$`).test(path);
+}
+function escapeSegment(segment) {
+  return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function workspaceSpecifiers() {
+  return Object.fromEntries(ADJACENT_PACKAGES.map(({ name }) => [name, "workspace:*"]));
+}
+function toSpecifierPath(path) {
+  return path.split(sep).join("/");
+}
+function linkedSpecifier(packagesRoot, directory, projectRoot) {
+  const target = join(packagesRoot, directory);
+  if (projectRoot === undefined)
+    return `file:${toSpecifierPath(target)}`;
+  const workspaceRoot = dirname(packagesRoot);
+  const fromWorkspace = relative(workspaceRoot, projectRoot);
+  const inCheckout = fromWorkspace !== "" && !fromWorkspace.startsWith("..") && !fromWorkspace.startsWith(sep);
+  return inCheckout ? `file:${toSpecifierPath(relative(projectRoot, target))}` : `file:${toSpecifierPath(target)}`;
+}
+function linkedSpecifiers(packagesRoot, projectRoot) {
+  return Object.fromEntries(ADJACENT_PACKAGES.map(({ directory, name }) => [
+    name,
+    linkedSpecifier(packagesRoot, directory, projectRoot)
+  ]));
+}
+function publishedSpecifiers() {
+  return Object.fromEntries(ADJACENT_PACKAGES.map(({ name }) => [name, PUBLISHED_ADJACENT_RANGE]));
+}
+function resolveAdjacentDependencies(options = {}) {
+  const { packagesRoot, projectRoot, workspaceMember } = options;
+  if (packagesRoot === undefined) {
+    return { dependencies: publishedSpecifiers(), linked: false, pathLinked: false };
+  }
+  if (workspaceMember) {
+    return { dependencies: workspaceSpecifiers(), linked: true, pathLinked: false };
+  }
+  const specifiers = linkedSpecifiers(packagesRoot, projectRoot);
+  return { dependencies: specifiers, linked: true, overrides: specifiers, pathLinked: true };
+}
+
+// ../adjacent-cli/dist/edits.js
+import { mkdir, readFile, rmdir, stat as stat2, unlink, writeFile } from "node:fs/promises";
+import { dirname as dirname2, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+async function exists(path) {
+  return stat2(path).then(() => true, () => false);
+}
+function assertInsideProject(root, path) {
+  const relation = relative2(root, path);
+  if (relation === "" || relation.startsWith("..") || relation.startsWith(sep2)) {
+    throw new Error(`Refusing to touch a path outside the project: ${path}`);
+  }
+}
+function createProjectEdits(root) {
+  const projectRoot = resolve2(root);
+  const added = [];
+  const rewritten = [];
+  const skipped = [];
+  const createdDirectories = [];
+  const restores = [];
+  async function ensureDirectory(path) {
+    if (await exists(path))
+      return;
+    if (!path.startsWith(projectRoot))
+      return;
+    await ensureDirectory(dirname2(path));
+    if (await exists(path))
+      return;
+    await mkdir(path);
+    createdDirectories.push(path);
+  }
+  function target(relativePath) {
+    const path = resolve2(projectRoot, relativePath);
+    assertInsideProject(projectRoot, path);
+    return path;
+  }
+  return {
+    root: projectRoot,
+    async addFile(relativePath, contents) {
+      const path = target(relativePath);
+      if (await exists(path)) {
+        skipped.push(relativePath);
+        return false;
+      }
+      await ensureDirectory(dirname2(path));
+      await writeFile(path, contents);
+      restores.push({ contents: undefined, path });
+      added.push(relativePath);
+      return true;
+    },
+    readFile: (relativePath) => readFile(target(relativePath), "utf8").catch(() => {
+      return;
+    }),
+    async removeFile(relativePath) {
+      const path = target(relativePath);
+      const original = await readFile(path).catch(() => {
+        return;
+      });
+      if (original === undefined)
+        return;
+      restores.push({ contents: original, path });
+      await unlink(path);
+    },
+    async rewriteFile(relativePath, contents) {
+      const path = target(relativePath);
+      const original = await readFile(path).catch(() => {
+        return;
+      });
+      await ensureDirectory(dirname2(path));
+      await writeFile(path, contents);
+      if (original === undefined) {
+        restores.push({ contents: undefined, path });
+        added.push(relativePath);
+      } else {
+        restores.push({ contents: original, path });
+        rewritten.push(relativePath);
+      }
+    },
+    async rollback() {
+      for (const restore of [...restores].reverse()) {
+        assertInsideProject(projectRoot, restore.path);
+        if (restore.contents === undefined) {
+          await unlink(restore.path).catch(() => {
+            return;
+          });
+        } else {
+          await writeFile(restore.path, restore.contents).catch(() => {
+            return;
+          });
+        }
+      }
+      for (const directory of [...createdDirectories].reverse()) {
+        assertInsideProject(projectRoot, directory);
+        await rmdir(directory).catch(() => {
+          return;
+        });
+      }
+      restores.length = 0;
+      createdDirectories.length = 0;
+      added.length = 0;
+      rewritten.length = 0;
+    },
+    summary: () => ({
+      added: [...added],
+      rewritten: [...rewritten],
+      skipped: [...skipped]
+    })
+  };
+}
+
+// ../adjacent-cli/dist/package-manager.js
+import { stat as stat3 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// ../adjacent-cli/dist/process.js
+import { spawn } from "node:child_process";
+async function runCommand(command, args, options = {}) {
+  return new Promise((resolve3, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stderr = [];
+    const stdout = [];
+    child.stderr.on("data", (chunk) => stderr.push(chunk));
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.once("error", (error) => reject(error));
+    child.once("exit", (code) => {
+      const result = {
+        stderr: Buffer.concat(stderr).toString().trim(),
+        stdout: Buffer.concat(stdout).toString().trim()
+      };
+      if (code === 0) {
+        resolve3(result);
+      } else {
+        reject(new Error(`${command} ${args.join(" ")} failed (${code ?? "signal"}): ${result.stderr || result.stdout}`));
+      }
+    });
+  });
+}
+async function runInheritedCommand(command, args, options = {}) {
+  const exitCode = await new Promise((resolve3, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["ignore", "inherit", "inherit"]
+    });
+    child.once("error", (error) => reject(error));
+    child.once("exit", (code, signal) => resolve3(code ?? (signal ? 1 : 0)));
+  });
+  if (exitCode !== 0) {
+    throw new Error(`${command} ${args.join(" ")} exited with code ${exitCode}.`);
+  }
+}
+
+// ../adjacent-cli/dist/package-manager.js
+var LOCKFILES = [
+  ["bun", "bun.lock"],
+  ["bun", "bun.lockb"],
+  ["pnpm", "pnpm-lock.yaml"],
+  ["yarn", "yarn.lock"],
+  ["npm", "package-lock.json"]
+];
+var MANAGERS = {
+  bun: {
+    exec: (specifier, args) => ({ args: [specifier, ...args], command: "bunx" }),
+    install: ({ isolated = false } = {}) => ({
+      args: isolated ? ["install", "--linker=isolated"] : ["install"],
+      command: "bun"
+    }),
+    name: "bun",
+    run: (script, args = []) => ({ args: ["run", script, ...args], command: "bun" }),
+    scaffoldFlag: "--use-bun"
+  },
+  npm: {
+    exec: (specifier, args) => ({
+      args: ["--yes", specifier, ...args],
+      command: "npx"
+    }),
+    install: () => ({ args: ["install"], command: "npm" }),
+    name: "npm",
+    run: (script, args = []) => ({
+      args: ["run", script, ...args.length > 0 ? ["--", ...args] : []],
+      command: "npm"
+    }),
+    scaffoldFlag: "--use-npm"
+  },
+  pnpm: {
+    exec: (specifier, args) => ({ args: ["dlx", specifier, ...args], command: "pnpm" }),
+    install: () => ({ args: ["install"], command: "pnpm" }),
+    name: "pnpm",
+    run: (script, args = []) => ({ args: ["run", script, ...args], command: "pnpm" }),
+    scaffoldFlag: "--use-pnpm"
+  },
+  yarn: {
+    exec: (specifier, args) => ({ args: ["dlx", specifier, ...args], command: "yarn" }),
+    install: () => ({ args: ["install"], command: "yarn" }),
+    name: "yarn",
+    run: (script, args = []) => ({ args: [script, ...args], command: "yarn" }),
+    scaffoldFlag: "--use-yarn"
+  }
+};
+function parseUserAgent(userAgent) {
+  if (!userAgent)
+    return;
+  const [first] = userAgent.split("/");
+  return first !== undefined && first in MANAGERS ? first : undefined;
+}
+async function detectFromLockfile(projectRoot) {
+  for (const [name, lockfile] of LOCKFILES) {
+    const found = await stat3(join2(projectRoot, lockfile)).catch(() => {
+      return;
+    });
+    if (found?.isFile())
+      return name;
+  }
+  return;
+}
+async function isInstalled(command) {
+  return runCommand(command, ["--version"]).then(() => true, () => false);
+}
+async function resolvePackageManager(options = {}) {
+  const { projectRoot, userAgent = process.env.npm_config_user_agent } = options;
+  const fromLockfile = projectRoot ? await detectFromLockfile(projectRoot) : undefined;
+  if (fromLockfile)
+    return MANAGERS[fromLockfile];
+  const fromAgent = parseUserAgent(userAgent);
+  if (fromAgent)
+    return MANAGERS[fromAgent];
+  if (await isInstalled("bun"))
+    return MANAGERS.bun;
+  return MANAGERS.npm;
+}
+
+// ../../node_modules/.bun/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
+import { styleText } from "node:util";
+import { stdout, stdin } from "node:process";
+import * as l from "node:readline";
+import l__default from "node:readline";
+
+// ../../node_modules/.bun/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// ../../node_modules/.bun/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = /\p{M}+/gu;
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer:
+    while (true) {
+      if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+        const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+        lengthExtra = 0;
+        for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+          const codePoint = char.codePointAt(0) || 0;
+          if (isFullWidth(codePoint)) {
+            widthExtra = FULL_WIDTH_WIDTH;
+          } else if (isWideNotCJKTNotEmoji(codePoint)) {
+            widthExtra = WIDE_WIDTH;
+          } else {
+            widthExtra = REGULAR_WIDTH;
+          }
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          lengthExtra += char.length;
+          width += widthExtra;
+        }
+        unmatchedStart = unmatchedEnd = 0;
+      }
+      if (index >= length) {
+        break outer;
+      }
+      for (let i = 0, l = PARSE_BLOCKS.length;i < l; i++) {
+        const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+        BLOCK_RE.lastIndex = index;
+        if (BLOCK_RE.test(input)) {
+          lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+          widthExtra = lengthExtra * BLOCK_WIDTH;
+          if (width + widthExtra > truncationLimit) {
+            truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+          }
+          if (width + widthExtra > LIMIT) {
+            truncationEnabled = true;
+            break outer;
+          }
+          width += widthExtra;
+          unmatchedStart = indexPrev;
+          unmatchedEnd = index;
+          index = indexPrev = BLOCK_RE.lastIndex;
+          continue outer;
+        }
+      }
+      index += 1;
+    }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// ../../node_modules/.bun/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default(input, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// ../../node_modules/.bun/fast-wrap-ansi@0.2.2/node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "›";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === undefined ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== undefined && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default2(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0;index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default2(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join(`
+`);
+  let inSurrogate = false;
+  for (let i = 0;i < preString.length; i++) {
+    const character = preString[i];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== undefined) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? undefined : code;
+      } else if (groups?.uri !== undefined) {
+        escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+      }
+    }
+    if (preString[i + 1] === `
+`) {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : undefined;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === `
+`) {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join(`
+`);
+}
+
+// ../../node_modules/.bun/@clack+core@1.4.3/node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+import { ReadStream } from "node:tty";
+function findCursor(s, o, l2) {
+  if (!l2.some((r) => !r.disabled))
+    return s;
+  const t = s + o, n = Math.max(l2.length - 1, 0), e = t < 0 ? n : t > n ? 0 : t;
+  return l2[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l2) : e;
+}
+function findTextCursor(s, o, l2, i) {
+  const t = i.split(`
+`);
+  let n = 0, e = s;
+  for (const r of t) {
+    if (e <= r.length)
+      break;
+    e -= r.length + 1, n++;
+  }
+  for (n = Math.max(0, Math.min(t.length - 1, n + l2)), e = Math.min(e, t[n].length) + o;e < 0 && n > 0; )
+    n--, e += t[n].length + 1;
+  for (;e > t[n].length && n < t.length - 1; )
+    e -= t[n].length + 1, n++;
+  e = Math.max(0, Math.min(t[n].length, e));
+  let h = 0;
+  for (let r = 0;r < n; r++)
+    h += t[r].length + 1;
+  return h + e;
+}
+var a$1 = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var t = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var settings = {
+  actions: new Set(a$1),
+  aliases: /* @__PURE__ */ new Map([
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["\x03", "cancel"],
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n, e) => `There are only ${n} days in ${e}`,
+      afterMin: (n) => `Date must be on or after ${n.toISOString().slice(0, 10)}`,
+      beforeMax: (n) => `Date must be on or before ${n.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isActionKey(n, e) {
+  if (typeof n == "string")
+    return settings.aliases.get(n) === e;
+  for (const s of n)
+    if (s !== undefined && isActionKey(s, e))
+      return true;
+  return false;
+}
+function diffLines(i, s) {
+  if (i === s)
+    return;
+  const e = i.split(`
+`), t2 = s.split(`
+`), r = Math.max(e.length, t2.length), f = [];
+  for (let n = 0;n < r; n++)
+    e[n] !== t2[n] && f.push(n);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t2.length,
+    numLines: r
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = Symbol("clack:cancel");
+function setRawMode(e, r) {
+  const o = e;
+  o.isTTY && o.setRawMode(r);
+}
+function block({
+  input: e = stdin,
+  output: r = stdout,
+  overwrite: o = true,
+  hideCursor: t2 = true
+} = {}) {
+  const s = l.createInterface({
+    input: e,
+    output: r,
+    prompt: "",
+    tabSize: 1
+  });
+  l.emitKeypressEvents(e, s), e instanceof ReadStream && e.isTTY && e.setRawMode(true);
+  const n = (f, { name: a, sequence: p }) => {
+    const c = String(f);
+    if (isActionKey([c, a, p], "cancel")) {
+      t2 && r.write(import_sisteransi.cursor.show), process.exit(0);
+      return;
+    }
+    if (!o)
+      return;
+    const i = a === "return" ? 0 : -1, m = a === "return" ? -1 : 0;
+    l.moveCursor(r, i, m, () => {
+      l.clearLine(r, 1, () => {
+        e.once("keypress", n);
+      });
+    });
+  };
+  return t2 && r.write(import_sisteransi.cursor.hide), e.once("keypress", n), () => {
+    e.off("keypress", n), t2 && r.write(import_sisteransi.cursor.show), e instanceof ReadStream && e.isTTY && !R && e.setRawMode(false), s.terminal = false, s.close();
+  };
+}
+var getColumns = (e) => ("columns" in e) && typeof e.columns == "number" ? e.columns : 80;
+var getRows = (e) => ("rows" in e) && typeof e.rows == "number" ? e.rows : 20;
+function runValidation(e, n) {
+  if ("~standard" in e) {
+    const a = e["~standard"].validate(n);
+    if (a instanceof Promise)
+      throw new TypeError("Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic.");
+    return a.issues?.at(0)?.message;
+  }
+  return e(n);
+}
+
+class V {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map;
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t2, e = true) {
+    const { input: i = stdin, output: n = stdout, render: s, signal: r, ...o } = t2;
+    this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = s.bind(this), this._track = e, this._abortSignal = r, this.input = i, this.output = n;
+  }
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  setSubscriber(t2, e) {
+    const i = this._subscribers.get(t2) ?? [];
+    i.push(e), this._subscribers.set(t2, i);
+  }
+  on(t2, e) {
+    this.setSubscriber(t2, { cb: e });
+  }
+  once(t2, e) {
+    this.setSubscriber(t2, { cb: e, once: true });
+  }
+  emit(t2, ...e) {
+    const i = this._subscribers.get(t2) ?? [], n = [];
+    for (const s of i)
+      s.cb(...e), s.once && n.push(() => i.splice(i.indexOf(s), 1));
+    for (const s of n)
+      s();
+  }
+  prompt() {
+    return new Promise((t2) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t2(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener("abort", () => {
+          this.state = "cancel", this.close();
+        }, { once: true });
+      }
+      this.rl = l__default.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      }), this.rl.prompt(), this.opts.initialUserInput !== undefined && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(t2, e) {
+    return t2 === "\t";
+  }
+  _shouldSubmit(t2, e) {
+    return true;
+  }
+  _setValue(t2) {
+    this.value = t2, this.emit("value", this.value);
+  }
+  _setUserInput(t2, e) {
+    this.userInput = t2 ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  onKeypress(t2, e) {
+    if (this._track && e.name !== "return" && (e.name && this._isActionKey(t2, e) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t2 && (t2.toLowerCase() === "y" || t2.toLowerCase() === "n") && this.emit("confirm", t2.toLowerCase() === "y"), this.emit("key", t2, e), e?.name === "return" && this._shouldSubmit(t2, e)) {
+      if (this.opts.validate) {
+        const i = runValidation(this.opts.validate, this.value);
+        i && (this.error = i instanceof Error ? i.message : i, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    isActionKey([t2, e?.name, e?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = undefined, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t2 = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t2 * -1));
+  }
+  render() {
+    const t2 = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t2 !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const e = diffLines(this._prevFrame, t2), i = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const n = Math.max(0, e.numLinesAfter - i), s = Math.max(0, e.numLinesBefore - i);
+          let r = e.lines.find((o) => o >= n);
+          if (r === undefined) {
+            this._prevFrame = t2;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, r - s)), this.output.write(import_sisteransi.erase.lines(1));
+            const o = t2.split(`
+`);
+            this.output.write(o[r]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, o.length - r - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (n < s)
+              r = n;
+            else {
+              const h = r - s;
+              h > 0 && this.output.write(import_sisteransi.cursor.move(0, h));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f = t2.split(`
+`).slice(r);
+            this.output.write(f.join(`
+`)), this._prevFrame = t2;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t2), this.state === "initial" && (this.state = "active"), this._prevFrame = t2;
+    }
+  }
+}
+function p$1(l2, e) {
+  if (l2 === undefined || e.length === 0)
+    return 0;
+  const i = e.findIndex((s) => s.value === l2);
+  return i !== -1 ? i : 0;
+}
+function g(l2, e) {
+  return (e.label ?? String(e.value)).toLowerCase().includes(l2.toLowerCase());
+}
+function m(l2, e) {
+  if (e)
+    return l2 ? e : e[0];
+}
+var T$1 = class T extends V {
+  filteredOptions;
+  multiple;
+  isNavigating = false;
+  selectedValues = [];
+  focusedValue;
+  #e = 0;
+  #s = "";
+  #t;
+  #i;
+  #n;
+  get cursor() {
+    return this.#e;
+  }
+  get userInputWithCursor() {
+    if (!this.userInput)
+      return styleText(["inverse", "hidden"], "_");
+    if (this._cursor >= this.userInput.length)
+      return `${this.userInput}█`;
+    const e = this.userInput.slice(0, this.cursor), t2 = this.userInput.slice(this.cursor, this.cursor + 1), i = this.userInput.slice(this.cursor + 1);
+    return `${e}${styleText("inverse", t2)}${i}`;
+  }
+  get options() {
+    return typeof this.#i == "function" ? this.#i() : this.#i;
+  }
+  constructor(e) {
+    super(e), this.#i = e.options, this.#n = e.placeholder;
+    const t2 = this.options;
+    this.filteredOptions = [...t2], this.multiple = e.multiple === true, this.#t = typeof e.options == "function" ? e.filter : e.filter ?? g;
+    let i;
+    if (e.initialValue && Array.isArray(e.initialValue) ? this.multiple ? i = e.initialValue : i = e.initialValue.slice(0, 1) : !this.multiple && this.options.length > 0 && (i = [this.options[0]?.value]), i)
+      for (const s of i) {
+        const n = t2.findIndex((o) => o.value === s);
+        n !== -1 && (this.toggleSelected(s), this.#e = n);
+      }
+    this.focusedValue = this.options[this.#e]?.value, this.on("key", (s, n) => this.#l(s, n)), this.on("userInput", (s) => this.#u(s));
+  }
+  _isActionKey(e, t2) {
+    return e === "\t" || this.multiple && this.isNavigating && t2.name === "space" && e !== undefined && e !== "";
+  }
+  #l(e, t2) {
+    const i = t2.name === "up", s = t2.name === "down", n = t2.name === "return", o = this.userInput === "" || this.userInput === "\t", u = this.#n, a = this.options, f = u !== undefined && u !== "" && a.some((r) => !r.disabled && (this.#t ? this.#t(u, r) : true));
+    if (t2.name === "tab" && o && f) {
+      this.userInput === "\t" && this._clearUserInput(), this._setUserInput(u, true), this.isNavigating = false;
+      return;
+    }
+    i || s ? (this.#e = findCursor(this.#e, i ? -1 : 1, this.filteredOptions), this.focusedValue = this.filteredOptions[this.#e]?.value, this.multiple || (this.selectedValues = [this.focusedValue]), this.isNavigating = true) : n ? this.value = m(this.multiple, this.selectedValues) : this.multiple ? this.focusedValue !== undefined && (t2.name === "tab" || this.isNavigating && t2.name === "space") ? this.toggleSelected(this.focusedValue) : this.isNavigating = false : (this.focusedValue && (this.selectedValues = [this.focusedValue]), this.isNavigating = false);
+  }
+  deselectAll() {
+    this.selectedValues = [];
+  }
+  toggleSelected(e) {
+    this.filteredOptions.length !== 0 && (this.multiple ? this.selectedValues.includes(e) ? this.selectedValues = this.selectedValues.filter((t2) => t2 !== e) : this.selectedValues = [...this.selectedValues, e] : this.selectedValues = [e]);
+  }
+  #u(e) {
+    if (e !== this.#s) {
+      this.#s = e;
+      const t2 = this.options;
+      e && this.#t ? this.filteredOptions = t2.filter((n) => this.#t?.(e, n)) : this.filteredOptions = [...t2];
+      const i = p$1(this.focusedValue, this.filteredOptions);
+      this.#e = findCursor(i, 0, this.filteredOptions);
+      const s = this.filteredOptions[this.#e];
+      s && !s.disabled ? this.focusedValue = s.value : this.focusedValue = undefined, this.multiple || (this.focusedValue !== undefined ? this.toggleSelected(this.focusedValue) : this.deselectAll());
+    }
+  }
+};
+var _ = {
+  Y: { type: "year", len: 4 },
+  M: { type: "month", len: 2 },
+  D: { type: "day", len: 2 }
+};
+function M(r) {
+  return [...r].map((t2) => _[t2]);
+}
+function P(r) {
+  const i = new Intl.DateTimeFormat(r, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(new Date(2000, 0, 15)), s = [];
+  let n = "/";
+  for (const e of i)
+    e.type === "literal" ? n = e.value.trim() || e.value : (e.type === "year" || e.type === "month" || e.type === "day") && s.push({ type: e.type, len: e.type === "year" ? 4 : 2 });
+  return { segments: s, separator: n };
+}
+function p(r) {
+  return Number.parseInt((r || "0").replace(/_/g, "0"), 10) || 0;
+}
+function f(r) {
+  return {
+    year: p(r.year),
+    month: p(r.month),
+    day: p(r.day)
+  };
+}
+function c(r, t2) {
+  return new Date(r || 2001, t2 || 1, 0).getDate();
+}
+function b(r) {
+  const { year: t2, month: i, day: s } = f(r);
+  if (!t2 || t2 < 0 || t2 > 9999 || !i || i < 1 || i > 12 || !s || s < 1)
+    return;
+  const n = new Date(Date.UTC(t2, i - 1, s));
+  if (!(n.getUTCFullYear() !== t2 || n.getUTCMonth() !== i - 1 || n.getUTCDate() !== s))
+    return { year: t2, month: i, day: s };
+}
+function C(r) {
+  const t2 = b(r);
+  return t2 ? new Date(Date.UTC(t2.year, t2.month - 1, t2.day)) : undefined;
+}
+function T2(r, t2, i, s) {
+  const n = i ? {
+    year: i.getUTCFullYear(),
+    month: i.getUTCMonth() + 1,
+    day: i.getUTCDate()
+  } : null, e = s ? {
+    year: s.getUTCFullYear(),
+    month: s.getUTCMonth() + 1,
+    day: s.getUTCDate()
+  } : null;
+  return r === "year" ? { min: n?.year ?? 1, max: e?.year ?? 9999 } : r === "month" ? {
+    min: n && t2.year === n.year ? n.month : 1,
+    max: e && t2.year === e.year ? e.month : 12
+  } : {
+    min: n && t2.year === n.year && t2.month === n.month ? n.day : 1,
+    max: e && t2.year === e.year && t2.month === e.month ? e.day : c(t2.year, t2.month)
+  };
+}
+
+class U extends V {
+  #i;
+  #o;
+  #t;
+  #h;
+  #u;
+  #e = { segmentIndex: 0, positionInSegment: 0 };
+  #n = true;
+  #s = null;
+  inlineError = "";
+  get segmentCursor() {
+    return { ...this.#e };
+  }
+  get segmentValues() {
+    return { ...this.#t };
+  }
+  get segments() {
+    return this.#i;
+  }
+  get separator() {
+    return this.#o;
+  }
+  get formattedValue() {
+    return this.#l(this.#t);
+  }
+  #l(t2) {
+    return this.#i.map((i) => t2[i.type]).join(this.#o);
+  }
+  #r() {
+    this._setUserInput(this.#l(this.#t)), this._setValue(C(this.#t) ?? undefined);
+  }
+  constructor(t2) {
+    const i = t2.format ? { segments: M(t2.format), separator: t2.separator ?? "/" } : P(t2.locale), s = t2.separator ?? i.separator, n = t2.format ? M(t2.format) : i.segments, e = t2.initialValue ?? t2.defaultValue, m2 = e ? {
+      year: String(e.getUTCFullYear()).padStart(4, "0"),
+      month: String(e.getUTCMonth() + 1).padStart(2, "0"),
+      day: String(e.getUTCDate()).padStart(2, "0")
+    } : { year: "____", month: "__", day: "__" }, o = n.map((a) => m2[a.type]).join(s);
+    super({ ...t2, initialUserInput: o }, false), this.#i = n, this.#o = s, this.#t = m2, this.#h = t2.minDate, this.#u = t2.maxDate, this.#r(), this.on("cursor", (a) => this.#f(a)), this.on("key", (a, u) => this.#y(a, u)), this.on("finalize", () => this.#p(t2));
+  }
+  #a() {
+    const t2 = Math.max(0, Math.min(this.#e.segmentIndex, this.#i.length - 1)), i = this.#i[t2];
+    if (i)
+      return this.#e.positionInSegment = Math.max(0, Math.min(this.#e.positionInSegment, i.len - 1)), { segment: i, index: t2 };
+  }
+  #m(t2) {
+    this.inlineError = "", this.#s = null;
+    const i = this.#a();
+    i && (this.#e.segmentIndex = Math.max(0, Math.min(this.#i.length - 1, i.index + t2)), this.#e.positionInSegment = 0, this.#n = true);
+  }
+  #d(t2) {
+    const i = this.#a();
+    if (!i)
+      return;
+    const { segment: s } = i, n = this.#t[s.type], e = !n || n.replace(/_/g, "") === "", m2 = Number.parseInt((n || "0").replace(/_/g, "0"), 10) || 0, o = T2(s.type, f(this.#t), this.#h, this.#u);
+    let a;
+    e ? a = t2 === 1 ? o.min : o.max : a = Math.max(Math.min(o.max, m2 + t2), o.min), this.#t = {
+      ...this.#t,
+      [s.type]: a.toString().padStart(s.len, "0")
+    }, this.#n = true, this.#s = null, this.#r();
+  }
+  #f(t2) {
+    if (t2)
+      switch (t2) {
+        case "right":
+          return this.#m(1);
+        case "left":
+          return this.#m(-1);
+        case "up":
+          return this.#d(1);
+        case "down":
+          return this.#d(-1);
+      }
+  }
+  #y(t2, i) {
+    if (i?.name === "backspace" || i?.sequence === "" || i?.sequence === "\b" || t2 === "" || t2 === "\b") {
+      this.inlineError = "";
+      const n = this.#a();
+      if (!n)
+        return;
+      if (!this.#t[n.segment.type].replace(/_/g, "")) {
+        this.#m(-1);
+        return;
+      }
+      this.#t[n.segment.type] = "_".repeat(n.segment.len), this.#n = true, this.#e.positionInSegment = 0, this.#r();
+      return;
+    }
+    if (i?.name === "tab") {
+      this.inlineError = "";
+      const n = this.#a();
+      if (!n)
+        return;
+      const e = i.shift ? -1 : 1, m2 = n.index + e;
+      m2 >= 0 && m2 < this.#i.length && (this.#e.segmentIndex = m2, this.#e.positionInSegment = 0, this.#n = true);
+      return;
+    }
+    if (t2 && /^[0-9]$/.test(t2)) {
+      const n = this.#a();
+      if (!n)
+        return;
+      const { segment: e } = n, m2 = !this.#t[e.type].replace(/_/g, "");
+      if (this.#n && this.#s !== null && !m2) {
+        const h = this.#s + t2, d = { ...this.#t, [e.type]: h }, g2 = this.#g(d, e);
+        if (g2) {
+          this.inlineError = g2, this.#s = null, this.#n = false;
+          return;
+        }
+        this.inlineError = "", this.#t[e.type] = h, this.#s = null, this.#n = false, this.#r(), n.index < this.#i.length - 1 && (this.#e.segmentIndex = n.index + 1, this.#e.positionInSegment = 0, this.#n = true);
+        return;
+      }
+      this.#n && !m2 && (this.#t[e.type] = "_".repeat(e.len), this.#e.positionInSegment = 0), this.#n = false, this.#s = null;
+      const o = this.#t[e.type], a = o.indexOf("_"), u = a >= 0 ? a : Math.min(this.#e.positionInSegment, e.len - 1);
+      if (u < 0 || u >= e.len)
+        return;
+      let l2 = o.slice(0, u) + t2 + o.slice(u + 1), D = false;
+      if (u === 0 && o === "__" && (e.type === "month" || e.type === "day")) {
+        const h = Number.parseInt(t2, 10);
+        l2 = `0${t2}`, D = h <= (e.type === "month" ? 1 : 2);
+      }
+      if (e.type === "year" && (l2 = (o.replace(/_/g, "") + t2).padStart(e.len, "_")), !l2.includes("_")) {
+        const h = { ...this.#t, [e.type]: l2 }, d = this.#g(h, e);
+        if (d) {
+          this.inlineError = d;
+          return;
+        }
+      }
+      this.inlineError = "", this.#t[e.type] = l2;
+      const y = l2.includes("_") ? undefined : b(this.#t);
+      if (y) {
+        const { year: h, month: d } = y, g2 = c(h, d);
+        this.#t = {
+          year: String(Math.max(0, Math.min(9999, h))).padStart(4, "0"),
+          month: String(Math.max(1, Math.min(12, d))).padStart(2, "0"),
+          day: String(Math.max(1, Math.min(g2, y.day))).padStart(2, "0")
+        };
+      }
+      this.#r();
+      const S = l2.indexOf("_");
+      D ? (this.#n = true, this.#s = t2) : S >= 0 ? this.#e.positionInSegment = S : a >= 0 && n.index < this.#i.length - 1 ? (this.#e.segmentIndex = n.index + 1, this.#e.positionInSegment = 0, this.#n = true) : this.#e.positionInSegment = Math.min(u + 1, e.len - 1);
+    }
+  }
+  #g(t2, i) {
+    const { month: s, day: n } = f(t2);
+    if (i.type === "month" && (s < 0 || s > 12))
+      return settings.date.messages.invalidMonth;
+    if (i.type === "day" && (n < 0 || n > 31))
+      return settings.date.messages.invalidDay(31, "any month");
+  }
+  #p(t2) {
+    const { year: i, month: s, day: n } = f(this.#t);
+    if (i && s && n) {
+      const e = c(i, s);
+      this.#t = {
+        ...this.#t,
+        day: String(Math.min(n, e)).padStart(2, "0")
+      };
+    }
+    this.value = C(this.#t) ?? t2.defaultValue ?? undefined;
+  }
+}
+var u$2 = class u extends V {
+  options;
+  cursor = 0;
+  #t;
+  getGroupItems(t2) {
+    return this.options.filter((r) => r.group === t2);
+  }
+  isGroupSelected(t2) {
+    const r = this.getGroupItems(t2), e = this.value;
+    return e === undefined ? false : r.every((s) => e.includes(s.value));
+  }
+  toggleValue() {
+    const t2 = this.options[this.cursor];
+    if (t2 !== undefined)
+      if (this.value === undefined && (this.value = []), t2.group === true) {
+        const r = t2.value, e = this.getGroupItems(r);
+        this.isGroupSelected(r) ? this.value = this.value.filter((s) => e.findIndex((i) => i.value === s) === -1) : this.value = [...this.value, ...e.map((s) => s.value)], this.value = Array.from(new Set(this.value));
+      } else {
+        const r = this.value.includes(t2.value);
+        this.value = r ? this.value.filter((e) => e !== t2.value) : [...this.value, t2.value];
+      }
+  }
+  constructor(t2) {
+    super(t2, false);
+    const { options: r } = t2;
+    this.#t = t2.selectableGroups !== false, this.options = Object.entries(r).flatMap(([e, s]) => [
+      { value: e, group: true, label: e },
+      ...s.map((i) => ({ ...i, group: e }))
+    ]), this.value = [...t2.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: e }) => e === t2.cursorAt), this.#t ? 0 : 1), this.on("cursor", (e) => {
+      switch (e) {
+        case "left":
+        case "up": {
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          const s = this.options[this.cursor]?.group === true;
+          !this.#t && s && (this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1);
+          break;
+        }
+        case "down":
+        case "right": {
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          const s = this.options[this.cursor]?.group === true;
+          !this.#t && s && (this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1);
+          break;
+        }
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+};
+var o = /* @__PURE__ */ new Set(["up", "down", "left", "right"]);
+
+class h extends V {
+  #t = false;
+  #s;
+  focused = "editor";
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${t2}█`;
+    const s = t2.slice(0, this.cursor), r = t2.slice(this.cursor, this.cursor + 1), i = t2.slice(this.cursor + 1);
+    return r === `
+` ? `${s}█
+${i}` : `${s}${styleText("inverse", r)}${i}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  #r(t2) {
+    if (this.userInput.length === 0) {
+      this._setUserInput(t2);
+      return;
+    }
+    this._setUserInput(this.userInput.slice(0, this.cursor) + t2 + this.userInput.slice(this.cursor));
+  }
+  #i(t2) {
+    const s = this.value ?? "";
+    switch (t2) {
+      case "up":
+        this._cursor = findTextCursor(this._cursor, 0, -1, s);
+        return;
+      case "down":
+        this._cursor = findTextCursor(this._cursor, 0, 1, s);
+        return;
+      case "left":
+        this._cursor = findTextCursor(this._cursor, -1, 0, s);
+        return;
+      case "right":
+        this._cursor = findTextCursor(this._cursor, 1, 0, s);
+        return;
+    }
+  }
+  _shouldSubmit(t2, s) {
+    if (this.#s)
+      return this.focused === "submit" ? true : (this.#r(`
+`), this._cursor++, false);
+    const r = this.#t;
+    return this.#t = true, r && this.cursor === this.userInput.length ? (this.userInput[this.cursor - 1] === `
+` && (this._setUserInput(this.userInput.slice(0, this.cursor - 1) + this.userInput.slice(this.cursor)), this._cursor--), true) : (this.#r(`
+`), this._cursor++, false);
+  }
+  constructor(t2) {
+    const s = t2.initialUserInput ?? t2.initialValue;
+    super({
+      ...t2,
+      initialUserInput: s
+    }, false), s !== undefined && (this._cursor = s.length), this.#s = t2.showSubmit ?? false, this.on("key", (r, i) => {
+      if (i?.name && o.has(i.name)) {
+        this.#t = false, this.#i(i.name);
+        return;
+      }
+      if (r === "\t" && this.#s) {
+        this.focused = this.focused === "editor" ? "submit" : "editor";
+        return;
+      }
+      if (i?.name !== "return") {
+        if (this.#t = false, i?.name === "backspace" && this.cursor > 0) {
+          this._setUserInput(this.userInput.slice(0, this.cursor - 1) + this.userInput.slice(this.cursor)), this._cursor--;
+          return;
+        }
+        if (i?.name === "delete" && this.cursor < this.userInput.length) {
+          this._setUserInput(this.userInput.slice(0, this.cursor) + this.userInput.slice(this.cursor + 1));
+          return;
+        }
+        r && (this.#s && this.focused === "submit" && (this.focused = "editor"), this.#r(r ?? ""), this._cursor++);
+      }
+    }), this.on("userInput", (r) => {
+      this._setValue(r);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t2.defaultValue), this.value === undefined && (this.value = "");
+    });
+  }
+}
+
+// ../../node_modules/.bun/@clack+prompts@1.7.0/node_modules/@clack/prompts/dist/index.mjs
+import { styleText as styleText2, stripVTControlCharacters } from "node:util";
+import process$1 from "node:process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+function isUnicodeSupported() {
+  if (process$1.platform !== "win32") {
+    return process$1.env.TERM !== "linux";
+  }
+  return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode = isUnicodeSupported();
+var isCI = () => process.env.CI === "true";
+var unicodeOr = (o2, e) => unicode ? o2 : e;
+var S_STEP_ACTIVE = unicodeOr("◆", "*");
+var S_STEP_CANCEL = unicodeOr("■", "x");
+var S_STEP_ERROR = unicodeOr("▲", "x");
+var S_STEP_SUBMIT = unicodeOr("◇", "o");
+var S_BAR_START = unicodeOr("┌", "T");
+var S_BAR = unicodeOr("│", "|");
+var S_BAR_END = unicodeOr("└", "—");
+var S_BAR_START_RIGHT = unicodeOr("┐", "T");
+var S_BAR_END_RIGHT = unicodeOr("┘", "—");
+var S_RADIO_ACTIVE = unicodeOr("●", ">");
+var S_RADIO_INACTIVE = unicodeOr("○", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("◻", "[•]");
+var S_CHECKBOX_SELECTED = unicodeOr("◼", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("◻", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("▪", "•");
+var S_BAR_H = unicodeOr("─", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("╮", "+");
+var S_CONNECT_LEFT = unicodeOr("├", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("╯", "+");
+var S_CORNER_BOTTOM_LEFT = unicodeOr("╰", "+");
+var S_CORNER_TOP_LEFT = unicodeOr("╭", "+");
+var S_INFO = unicodeOr("●", "•");
+var S_SUCCESS = unicodeOr("◆", "*");
+var S_WARN = unicodeOr("▲", "!");
+var S_ERROR = unicodeOr("■", "x");
+var MULTISELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "↑/↓")} to navigate`,
+  `${styleText2("dim", "Space:")} select`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var log = {
+  message: (s = [], {
+    symbol: e = styleText2("gray", S_BAR),
+    secondarySymbol: r2 = styleText2("gray", S_BAR),
+    output: m2 = process.stdout,
+    spacing: l2 = 1,
+    withGuide: c2
+  } = {}) => {
+    const t2 = [], o2 = c2 ?? settings.withGuide, f2 = o2 ? r2 : "", O = o2 ? `${e}  ` : "", u3 = o2 ? `${r2}  ` : "";
+    for (let i = 0;i < l2; i++)
+      t2.push(f2);
+    const g2 = Array.isArray(s) ? s : s.split(`
+`);
+    if (g2.length > 0) {
+      const [i, ...y] = g2;
+      i.length > 0 ? t2.push(`${O}${i}`) : t2.push(o2 ? e : "");
+      for (const p2 of y)
+        p2.length > 0 ? t2.push(`${u3}${p2}`) : t2.push(o2 ? r2 : "");
+    }
+    m2.write(`${t2.join(`
+`)}
+`);
+  },
+  info: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("blue", S_INFO) });
+  },
+  success: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("green", S_SUCCESS) });
+  },
+  step: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("green", S_STEP_SUBMIT) });
+  },
+  warn: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("yellow", S_WARN) });
+  },
+  warning: (s, e) => {
+    log.warn(s, e);
+  },
+  error: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("red", S_ERROR) });
+  }
+};
+var intro = (o2 = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_START)}  ` : "";
+  i.write(`${e}${o2}
+`);
+};
+var outro = (o2 = "", t2) => {
+  const i = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR)}
+${styleText2("gray", S_BAR_END)}  ` : "";
+  i.write(`${e}${o2}
+
+`);
+};
+var W = (l2) => styleText2("magenta", l2);
+var spinner = ({
+  indicator: l2 = "dots",
+  onCancel: h2,
+  output: n2 = process.stdout,
+  cancelMessage: G,
+  errorMessage: O,
+  frames: E = unicode ? ["◒", "◐", "◓", "◑"] : ["•", "o", "O", "0"],
+  delay: F = unicode ? 80 : 120,
+  signal: m2,
+  ...I
+} = {}) => {
+  const u3 = isCI();
+  let M2, T3, d = false, S = false, s = "", p2, w = performance.now();
+  const x = getColumns(n2), k = I?.styleFrame ?? W, g2 = (e) => {
+    const r2 = e > 1 ? O ?? settings.messages.error : G ?? settings.messages.cancel;
+    S = e === 1, d && (a2(r2, e), S && typeof h2 == "function" && h2());
+  }, f2 = () => g2(2), i = () => g2(1), A = () => {
+    process.on("uncaughtExceptionMonitor", f2), process.on("unhandledRejection", f2), process.on("SIGINT", i), process.on("SIGTERM", i), process.on("exit", g2), m2 && m2.addEventListener("abort", i);
+  }, H = () => {
+    process.removeListener("uncaughtExceptionMonitor", f2), process.removeListener("unhandledRejection", f2), process.removeListener("SIGINT", i), process.removeListener("SIGTERM", i), process.removeListener("exit", g2), m2 && m2.removeEventListener("abort", i);
+  }, y = () => {
+    if (p2 === undefined)
+      return;
+    u3 && n2.write(`
+`);
+    const r2 = wrapAnsi(p2, x, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    r2.length > 1 && n2.write(import_sisteransi2.cursor.up(r2.length - 1)), n2.write(import_sisteransi2.cursor.to(0)), n2.write(import_sisteransi2.erase.down());
+  }, C2 = (e) => e.replace(/\.+$/, ""), _2 = (e) => {
+    const r2 = (performance.now() - e) / 1000, t2 = Math.floor(r2 / 60), o2 = Math.floor(r2 % 60);
+    return t2 > 0 ? `[${t2}m ${o2}s]` : `[${o2}s]`;
+  }, N = I.withGuide ?? settings.withGuide, P2 = (e = "") => {
+    d = true, M2 = block({ output: n2 }), s = C2(e), w = performance.now(), N && n2.write(`${styleText2("gray", S_BAR)}
+`);
+    let r2 = 0, t2 = 0;
+    A(), T3 = setInterval(() => {
+      if (u3 && s === p2)
+        return;
+      y(), p2 = s;
+      const o2 = k(E[r2]);
+      let v;
+      if (u3)
+        v = `${o2}  ${s}...`;
+      else if (l2 === "timer")
+        v = `${o2}  ${s} ${_2(w)}`;
+      else {
+        const B = ".".repeat(Math.floor(t2)).slice(0, 3);
+        v = `${o2}  ${s}${B}`;
+      }
+      const j = wrapAnsi(v, x, {
+        hard: true,
+        trim: false
+      });
+      n2.write(j), r2 = r2 + 1 < E.length ? r2 + 1 : 0, t2 = t2 < 4 ? t2 + 0.125 : 0;
+    }, F);
+  }, a2 = (e = "", r2 = 0, t2 = false) => {
+    if (!d)
+      return;
+    d = false, clearInterval(T3), y();
+    const o2 = r2 === 0 ? styleText2("green", S_STEP_SUBMIT) : r2 === 1 ? styleText2("red", S_STEP_CANCEL) : styleText2("red", S_STEP_ERROR);
+    s = e ?? s, t2 || (l2 === "timer" ? n2.write(`${o2}  ${s} ${_2(w)}
+`) : n2.write(`${o2}  ${s}
+`)), H(), M2();
+  };
+  return {
+    start: P2,
+    stop: (e = "") => a2(e, 0),
+    message: (e = "") => {
+      s = C2(e ?? s);
+    },
+    cancel: (e = "") => a2(e, 1),
+    error: (e = "") => a2(e, 2),
+    clear: () => a2("", 0, true),
+    get isCancelled() {
+      return S;
+    }
+  };
+};
+var u3 = {
+  light: unicodeOr("─", "-"),
+  heavy: unicodeOr("━", "="),
+  block: unicodeOr("█", "#")
+};
+var SELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "↑/↓")} to navigate`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var i = `${styleText2("gray", S_BAR)}  `;
+
+// ../adjacent-cli/dist/ui.js
+function intro2(message) {
+  if (process.stdout.isTTY)
+    intro(message);
+  else
+    console.log(message);
+}
+function step(message) {
+  log.step(message);
+}
+function success(message) {
+  log.success(message);
+}
+function outro2(message) {
+  if (process.stdout.isTTY)
+    outro(message);
+  else
+    console.log(message);
+}
+async function task(message, operation) {
+  if (!process.stdout.isTTY) {
+    step(message);
+    return operation();
+  }
+  const progress = spinner();
+  progress.start(message);
+  try {
+    const result = await operation();
+    progress.stop(message);
+    return result;
+  } catch (error) {
+    progress.stop(`Failed: ${message}`);
+    throw error;
+  }
+}
+
+// ../adjacent-cli/dist/reporter.js
+var TERMINAL_REPORTER = { intro: intro2, outro: outro2, step, success, task };
+
+// ../adjacent-cli/dist/rewrite.js
+var ADJACENT_NEXT = "adjacent-next";
+function hasImportFrom(source, module) {
+  return new RegExp(`from\\s+["']${module.replace("/", "\\/")}["']`).test(source);
+}
+function addImport(source, statement) {
+  if (source.includes(statement))
+    return source;
+  const imports = [...source.matchAll(/^import\s[^\n]*;[ \t]*$/gm)];
+  const last = imports.at(-1);
+  if (last === undefined || last.index === undefined) {
+    return `${statement}
+${source}`;
+  }
+  const end = last.index + last[0].length;
+  return `${source.slice(0, end)}
+${statement}${source.slice(end)}`;
+}
+var NEXT_CONFIG_OPTIONS = `{
+  connectivityRecovery: true,
+  partialPrefetching: true,
+}`;
+function createNextConfig() {
+  return `import { withAdjacent } from "${ADJACENT_NEXT}";
+
+export default withAdjacent(${NEXT_CONFIG_OPTIONS});
+`;
+}
+function wrapNextConfig(source) {
+  if (source.includes("withAdjacent"))
+    return { kind: "unchanged" };
+  const identifier = /^export\s+default\s+([A-Za-z_$][\w$]*)\s*;?\s*$/m.exec(source);
+  if (identifier?.[1]) {
+    const wrapped = source.replace(identifier[0], `export default withAdjacent({
+  connectivityRecovery: true,
+  partialPrefetching: true,
+  ${identifier[1] === "nextConfig" ? "nextConfig" : `nextConfig: ${identifier[1]}`},
+});`);
+    return {
+      contents: addImport(wrapped, `import { withAdjacent } from "${ADJACENT_NEXT}";`),
+      kind: "rewritten"
+    };
+  }
+  const inline = /^export\s+default\s+(\{[\s\S]*\})\s*(?:as\s+\w+\s*)?;?\s*$/m.exec(source);
+  if (inline?.[1]) {
+    const wrapped = source.replace(inline[0], `export default withAdjacent({
+  connectivityRecovery: true,
+  partialPrefetching: true,
+  nextConfig: ${inline[1]},
+});`);
+    return {
+      contents: addImport(wrapped, `import { withAdjacent } from "${ADJACENT_NEXT}";`),
+      kind: "rewritten"
+    };
+  }
+  return {
+    instruction: `Wrap the Next.js config so Adjacent can configure development origins, headers, and package transpilation:
+
+` + `  import { withAdjacent } from "${ADJACENT_NEXT}";
+
+` + `  export default withAdjacent({
+` + `    connectivityRecovery: true,
+` + `    partialPrefetching: true,
+` + `    nextConfig: yourExistingConfig,
+` + `  });`,
+    kind: "manual"
+  };
+}
+var LAYOUT_INSTRUCTION = (configImportPath) => `Wrap the root layout so Adjacent can supply metadata and inject its browser runtime:
+
+` + `  import { createAdjacent, withAdjacentLayout } from "${ADJACENT_NEXT}";
+` + `  import config from "${configImportPath}";
+
+` + `  const adjacent = createAdjacent(config);
+` + `  export const { metadata, viewport } = adjacent;
+
+` + `  function RootLayout({ children }) { /* your existing layout */ }
+
+` + `  export default withAdjacentLayout(adjacent)(RootLayout);`;
+var METADATA_TYPE_IMPORT = /^import\s+type\s*\{\s*Metadata\s*\}\s*from\s*"next";\n/m;
+var SCAFFOLDED_METADATA = /^export\s+const\s+metadata(?:\s*:\s*Metadata)?\s*=\s*\{[^{}]*\};?\n+/m;
+function dropScaffoldedMetadata(source) {
+  const without = source.replace(SCAFFOLDED_METADATA, "");
+  if (without === source || /\bMetadata\b/.test(without.replace(METADATA_TYPE_IMPORT, ""))) {
+    return without;
+  }
+  return without.replace(METADATA_TYPE_IMPORT, "");
+}
+function wrapRootLayout(source, { configImportPath, scaffolded = false }) {
+  if (source.includes("withAdjacentLayout"))
+    return { kind: "unchanged" };
+  const defaultExport = /^export\s+default\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/m.exec(source);
+  if (!defaultExport?.[1]) {
+    return { instruction: LAYOUT_INSTRUCTION(configImportPath), kind: "manual" };
+  }
+  const layoutName = defaultExport[1];
+  let contents = scaffolded ? dropScaffoldedMetadata(source) : source;
+  const metadataExport = /^export\s+const\s+metadata(\s*:\s*Metadata)?\s*=/m.exec(contents);
+  const hasOwnMetadata = metadataExport !== null;
+  if (metadataExport) {
+    contents = contents.replace(metadataExport[0], `const applicationMetadata${metadataExport[1] ?? ""} =`);
+  }
+  if (/^export\s+const\s+viewport\b/m.test(contents)) {
+    return { instruction: LAYOUT_INSTRUCTION(configImportPath), kind: "manual" };
+  }
+  contents = contents.replace(defaultExport[0], defaultExport[0].replace(/^export\s+default\s+/, ""));
+  contents = addImport(contents, `import { createAdjacent, withAdjacentLayout } from "${ADJACENT_NEXT}";`);
+  if (!hasImportFrom(contents, configImportPath)) {
+    contents = addImport(contents, `import config from "${configImportPath}";`);
+  }
+  const creation = hasOwnMetadata ? `const adjacent = createAdjacent(config, { metadata: applicationMetadata });` : `const adjacent = createAdjacent(config);`;
+  return {
+    contents: `${contents.trimEnd()}
+
+${creation}
+
+export const { metadata, viewport } = adjacent;
+
+` + `export default withAdjacentLayout(adjacent)(${layoutName});
+`,
+    kind: "rewritten"
+  };
+}
+var STYLE_START = "/* adjacent:start */";
+var STYLE_END = "/* adjacent:end */";
+var ADJACENT_TOKENS = `:root {
+  --primary: #171717;
+  --primary-foreground: #ffffff;
+  --secondary: #f4f4f5;
+  --secondary-foreground: #171717;
+  --accent: #f4f4f5;
+  --accent-foreground: #171717;
+  --muted: #f4f4f5;
+  --muted-foreground: #71717a;
+  --destructive: #b3261e;
+  --border: #e4e4e7;
+  --ring: #171717;
+
+  /* The navigation rail is a sidebar, and reads these from 768px up. */
+  --sidebar: #fafafa;
+  --sidebar-foreground: #171717;
+  --sidebar-accent: #e4e4e7;
+  --sidebar-accent-foreground: #171717;
+
+  --radius: 0.625rem;
+  --radius-sm: 0.375rem;
+  --radius-lg: 0.75rem;
+  --radius-full: 9999px;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --primary: #fafafa;
+    --primary-foreground: #0c0c0e;
+    --secondary: #27272a;
+    --secondary-foreground: #fafafa;
+    --accent: #27272a;
+    --accent-foreground: #fafafa;
+    --muted: #27272a;
+    --muted-foreground: #a1a1aa;
+    --destructive: #f2b8b5;
+    --border: #27272a;
+    --ring: #fafafa;
+
+    --sidebar: #17171a;
+    --sidebar-foreground: #fafafa;
+    --sidebar-accent: #27272a;
+    --sidebar-accent-foreground: #fafafa;
+  }
+}`;
+var TAILWIND_THEME = `@theme inline {
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-secondary: var(--secondary);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-accent: var(--accent);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-destructive: var(--destructive);
+  --color-border: var(--border);
+  --color-ring: var(--ring);
+  --color-sidebar: var(--sidebar);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+}`;
+var SHELL_STYLES = `body {
+  /* Keeps iOS from rubber-banding the document out from under fixed chrome. */
+  overscroll-behavior-y: none;
+}
+
+html {
+  /*
+   * Anything scrolled to stops above the navigation rather than under it. The
+   * shell already reserves the room; this covers an anchor jump, a focused
+   * field, and scrollIntoView, which would otherwise ignore it. The same at the
+   * top, where a sticky header would otherwise cover what was scrolled to.
+   */
+  scroll-padding-block-start: var(--adj-header-inset-block-start, 0px);
+  scroll-padding-block-end: var(--adj-navigation-inset-block-end, 0px);
+}
+
+/*
+ * An installed app should not show a browser's scrollbar down its edge. Keyed
+ * on a coarse pointer rather than a narrow width, so a touch device is what
+ * this hides for and a narrow desktop window keeps the scrollbar it needs.
+ * Scrolling itself is untouched: the bar goes, the page still moves.
+ */
+@media (pointer: coarse) {
+  html {
+    /* The standard property, and the one that does the work. */
+    scrollbar-width: none;
+  }
+
+  /*
+   * For iOS Safari before 18.2 and Chrome before 121, which is a real share of
+   * phones. Delete this once the floor is above both and scrollbar-width is
+   * enough on its own.
+   */
+  html::-webkit-scrollbar,
+  body::-webkit-scrollbar {
+    display: none;
+  }
+}`;
+function injectAdjacentStyles(source, { tailwind }) {
+  const block2 = [
+    STYLE_START,
+    "/* Adjacent components read these tokens. Edit them to restyle the app. */",
+    ADJACENT_TOKENS,
+    ...tailwind ? [TAILWIND_THEME] : [],
+    SHELL_STYLES,
+    STYLE_END
+  ].join(`
+
+`);
+  const start = source.indexOf(STYLE_START);
+  if (start !== -1) {
+    const end = source.indexOf(STYLE_END);
+    if (end === -1) {
+      return {
+        instruction: `The Adjacent block in this stylesheet has a ${STYLE_START} marker but no ` + `${STYLE_END} marker, so it cannot be replaced safely. Close the block, or ` + `delete both markers and run this again.`,
+        kind: "manual"
+      };
+    }
+    const replaced = source.slice(0, start) + block2 + source.slice(end + STYLE_END.length);
+    return replaced === source ? { kind: "unchanged" } : { contents: replaced, kind: "rewritten" };
+  }
+  return { contents: `${source.trimEnd()}
+
+${block2}
+`, kind: "rewritten" };
+}
+
+// ../adjacent-cli/dist/template.js
+import { readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+var TEXT_EXTENSIONS = new Set([".css", ".json", ".md", ".svg", ".ts", ".tsx"]);
+var FILENAME_OVERRIDES = {
+  _gitignore: ".gitignore"
+};
+var PLACEHOLDER = /\{\{\s*([a-zA-Z][a-zA-Z0-9]*)\s*\}\}/g;
+var IGNORED_ENTRIES2 = new Set([".DS_Store"]);
+function isTextTemplate(path) {
+  const dot = path.lastIndexOf(".");
+  return dot === -1 ? false : TEXT_EXTENSIONS.has(path.slice(dot));
+}
+function applyTemplateName(name) {
+  return FILENAME_OVERRIDES[name] ?? name;
+}
+function renderTemplate(source, values) {
+  return source.replace(PLACEHOLDER, (_match, key) => {
+    const value = values[key];
+    if (value === undefined) {
+      throw new Error(`The bundled template referenced an unknown value: {{${key}}}`);
+    }
+    return value;
+  });
+}
+async function collectTemplateEntries(templateRoot, base = "") {
+  const entries = await readdir2(join3(templateRoot, base), { withFileTypes: true });
+  const collected = [];
+  for (const entry of entries.sort((a2, b2) => a2.name.localeCompare(b2.name))) {
+    if (IGNORED_ENTRIES2.has(entry.name))
+      continue;
+    const sourcePath = base === "" ? entry.name : `${base}/${entry.name}`;
+    if (entry.isDirectory()) {
+      collected.push(...await collectTemplateEntries(templateRoot, sourcePath));
+      continue;
+    }
+    collected.push({ path: sourcePath });
+  }
+  return collected;
+}
+function toDestinationPath(templateRelativePath) {
+  return templateRelativePath.split("/").map((segment) => applyTemplateName(segment)).join("/");
+}
+async function renderTemplateTree({ relocate, sink, templateRoot, values }) {
+  const entries = await collectTemplateEntries(templateRoot);
+  const written = [];
+  for (const entry of entries) {
+    const source = join3(templateRoot, ...entry.path.split("/"));
+    const mapped = toDestinationPath(entry.path);
+    const destinationPath = relocate ? relocate(mapped) : mapped;
+    const contents = isTextTemplate(entry.path) ? renderTemplate(await readFile2(source, "utf8"), values) : await readFile2(source);
+    if (await sink(destinationPath, contents))
+      written.push(destinationPath);
+  }
+  return written;
+}
+
+// ../adjacent-cli/dist/survey.js
+import { readFile as readFile3, stat as stat4 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+
+// ../adjacent-cli/dist/project-name.js
+var PACKAGE_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SHORT_NAME_LIMIT = 12;
+var RESERVED_NAMES = new Set(["favicon.ico", "node_modules"]);
+var MIN_LENGTH = 2;
+var MAX_LENGTH = 214;
+function fail(name, reason) {
+  throw new Error(`Invalid project name "${name}": ${reason}`);
+}
+function assertProjectName(name) {
+  if (name.trim().length === 0) {
+    throw new Error("A project name is required, for example: adj create my-app");
+  }
+  const value = name.trim();
+  if (value.includes("/") || value.includes("\\")) {
+    fail(value, "a name cannot contain a path separator. Use --directory to choose where the project is written.");
+  }
+  if (value === "." || value === ".." || value.startsWith(".")) {
+    fail(value, "a name cannot begin with a dot.");
+  }
+  if (value.length < MIN_LENGTH) {
+    fail(value, `a name has to be at least ${MIN_LENGTH} characters, because a web app manifest rejects a shorter one.`);
+  }
+  if (value.length > MAX_LENGTH) {
+    fail(value, `a name cannot be longer than ${MAX_LENGTH} characters.`);
+  }
+  if (RESERVED_NAMES.has(value)) {
+    fail(value, "that name is reserved by npm.");
+  }
+  if (value !== value.toLowerCase()) {
+    fail(value, `a name must be lowercase. Try "${value.toLowerCase()}".`);
+  }
+  if (!PACKAGE_NAME.test(value)) {
+    fail(value, "a name must be lowercase letters and digits separated by single hyphens, for example: my-app.");
+  }
+  return value;
+}
+function toTitleCase(word) {
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+function deriveAppName(packageName) {
+  return packageName.split("-").map(toTitleCase).join(" ");
+}
+function deriveShortName(appName) {
+  if (appName.length <= SHORT_NAME_LIMIT)
+    return appName;
+  const [firstWord = appName] = appName.split(" ");
+  return firstWord.slice(0, SHORT_NAME_LIMIT);
+}
+function deriveProjectIdentity(name) {
+  const packageName = assertProjectName(name);
+  const appName = deriveAppName(packageName);
+  return {
+    appName,
+    packageName,
+    shortName: deriveShortName(appName),
+    slug: packageName
+  };
+}
+
+// ../adjacent-cli/dist/survey.js
+var APP_DIRECTORIES = ["app", join4("src", "app")];
+var LAYOUT_NAMES = ["layout.tsx", "layout.jsx", "layout.ts", "layout.js"];
+var NEXT_CONFIG_NAMES = [
+  "next.config.ts",
+  "next.config.mjs",
+  "next.config.js",
+  "next.config.mts"
+];
+var STYLESHEET_NAMES = ["globals.css", "global.css", "index.css"];
+async function exists2(path) {
+  return stat4(path).then(() => true, () => false);
+}
+async function firstExisting(root, candidates) {
+  for (const candidate of candidates) {
+    if (await exists2(join4(root, candidate)))
+      return candidate;
+  }
+  return;
+}
+function readDependencyNames(manifest) {
+  const names = new Set;
+  for (const field of ["dependencies", "devDependencies"]) {
+    const section = manifest[field];
+    if (typeof section === "object" && section !== null) {
+      Object.keys(section).forEach((name) => names.add(name));
+    }
+  }
+  return names;
+}
+function toProjectName(packageName, fallback) {
+  const raw = typeof packageName === "string" ? packageName : "";
+  const withoutScope = raw.includes("/") ? raw.split("/").pop() ?? "" : raw;
+  const cleaned = withoutScope.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+  return cleaned.length > 0 ? cleaned : fallback;
+}
+
+class NotANextApplicationError extends Error {
+}
+async function surveyProject(root) {
+  const manifestPath = join4(root, "package.json");
+  const rawManifest = await readFile3(manifestPath, "utf8").catch(() => {
+    return;
+  });
+  if (rawManifest === undefined) {
+    throw new NotANextApplicationError(`No package.json found in ${root}. Run this inside a Next.js application, or create one with: adj create my-app`);
+  }
+  let packageJson;
+  try {
+    packageJson = JSON.parse(rawManifest);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new NotANextApplicationError(`Could not read ${manifestPath}: ${detail}`);
+  }
+  const dependencies = readDependencyNames(packageJson);
+  if (!dependencies.has("next")) {
+    throw new NotANextApplicationError(`${root} does not depend on Next.js. Adjacent adds to a Next.js application; create one with: adj create my-app`);
+  }
+  const appDirectory = await firstExisting(root, APP_DIRECTORIES);
+  if (appDirectory === undefined) {
+    throw new NotANextApplicationError(`No App Router directory found in ${root}. Adjacent needs an app/ or src/app/ directory; the Pages Router is not supported.`);
+  }
+  const layoutFile = await firstExisting(root, LAYOUT_NAMES.map((name) => join4(appDirectory, name)));
+  if (layoutFile === undefined) {
+    throw new NotANextApplicationError(`No root layout found in ${join4(root, appDirectory)}. Adjacent wraps the root layout, so one has to exist.`);
+  }
+  const globalsCss = await firstExisting(root, STYLESHEET_NAMES.map((name) => join4(appDirectory, name)));
+  return {
+    appDirectory,
+    ...globalsCss === undefined ? null : { globalsCss },
+    hasAdjacentConfig: await exists2(join4(root, "app.config.ts")),
+    hasTailwind: dependencies.has("tailwindcss") || dependencies.has("@tailwindcss/postcss"),
+    identity: deriveProjectIdentity(toProjectName(packageJson.name, "adjacent-app")),
+    layoutFile,
+    ...await firstExisting(root, NEXT_CONFIG_NAMES).then((file) => file === undefined ? null : { nextConfigFile: file }),
+    packageJson,
+    root,
+    typescript: layoutFile.endsWith(".tsx") || layoutFile.endsWith(".ts")
+  };
+}
+
+// ../adjacent-cli/dist/init.js
+function moduleDirectory() {
+  return dirname3(fileURLToPath2(import.meta.url));
+}
+function defaultTemplatesRoot(from = moduleDirectory()) {
+  return resolve3(from, "..", "templates");
+}
+async function findWorkspacePackagesRoot(from = moduleDirectory()) {
+  let current = resolve3(from);
+  while (true) {
+    const candidate = join5(current, "packages", "adjacent-core", "package.json");
+    const manifest = await readFile4(candidate, "utf8").catch(() => {
+      return;
+    });
+    if (manifest !== undefined) {
+      const parsed = JSON.parse(manifest);
+      if (parsed.name === "adjacent-core")
+        return join5(current, "packages");
+    }
+    const parent = dirname3(current);
+    if (parent === current)
+      return;
+    current = parent;
+  }
+}
+async function isWorkspaceMember(workspaceRoot, projectRoot) {
+  const raw = await readFile4(join5(workspaceRoot, "package.json"), "utf8").catch(() => {
+    return;
+  });
+  if (raw === undefined)
+    return false;
+  let globs = [];
+  try {
+    const manifest = JSON.parse(raw);
+    if (Array.isArray(manifest.workspaces)) {
+      globs = manifest.workspaces.filter((glob) => typeof glob === "string");
+    }
+  } catch {
+    return false;
+  }
+  const location = relative3(workspaceRoot, projectRoot).split(sep3).join("/");
+  if (location === "" || location.startsWith(".."))
+    return false;
+  return globs.some((glob) => matchesWorkspaceGlob(location, glob));
+}
+function addAdjacentDependencies(manifest, dependencies) {
+  const existing = typeof manifest.dependencies === "object" && manifest.dependencies !== null ? manifest.dependencies : {};
+  const scripts = typeof manifest.scripts === "object" && manifest.scripts !== null ? manifest.scripts : {};
+  const merged = {
+    ...manifest,
+    dependencies: Object.fromEntries(Object.entries({ ...existing, ...dependencies.dependencies }).sort(([a2], [b2]) => a2.localeCompare(b2))),
+    scripts: {
+      ...scripts,
+      ...scripts.typecheck ? null : { typecheck: "next typegen && tsc --noEmit" }
+    }
+  };
+  if (dependencies.overrides) {
+    const configured = typeof manifest.overrides === "object" && manifest.overrides !== null ? manifest.overrides : {};
+    merged.overrides = { ...configured, ...dependencies.overrides };
+  }
+  return merged;
+}
+async function installDependencies(root, options = {}) {
+  const manager = await resolvePackageManager({ projectRoot: root });
+  const { args, command } = manager.install(options);
+  await runInheritedCommand(command, args, { cwd: root }).catch((error) => {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not install dependencies in ${root}: ${detail}
+` + `Adjacent was added to the project. Install by hand with: ${command} ${args.join(" ")}`);
+  });
+}
+async function applyRewrite({ edits, file, manual, outcome }) {
+  if (outcome.kind === "rewritten") {
+    await edits.rewriteFile(file, outcome.contents);
+    return;
+  }
+  if (outcome.kind === "manual") {
+    manual.push({ file, instruction: outcome.instruction });
+  }
+}
+async function runInit(options, ports = {}) {
+  const report = ports.reporter ?? TERMINAL_REPORTER;
+  const root = resolve3(options.projectRoot);
+  const survey = await surveyProject(root);
+  const templatesRoot = ports.templatesRoot ?? defaultTemplatesRoot();
+  const manager = await resolvePackageManager({ projectRoot: root });
+  const packagesRoot = await findWorkspacePackagesRoot();
+  const dependencies = ports.dependencies ?? resolveAdjacentDependencies({
+    ...packagesRoot === undefined ? null : { packagesRoot },
+    projectRoot: root,
+    workspaceMember: packagesRoot !== undefined && await isWorkspaceMember(dirname3(packagesRoot), root)
+  });
+  const installOptions = { isolated: dependencies.pathLinked };
+  const edits = createProjectEdits(root);
+  const manual = [];
+  const sourceRoot = dirname3(survey.appDirectory);
+  const relocate = (path) => sourceRoot === "." ? path : join5(sourceRoot, path);
+  try {
+    const configFromApp = sourceRoot === "." ? "../app.config" : "../../app.config";
+    const values = {
+      appName: survey.identity.appName,
+      configFromApp,
+      configFromRoute: `../${configFromApp}`,
+      packageName: survey.identity.packageName,
+      shortName: survey.identity.shortName,
+      slug: survey.identity.slug
+    };
+    const injected = await renderTemplateTree({
+      relocate: (path) => path === "app.config.ts" || path.startsWith("public/") ? path : relocate(path),
+      sink: (path, contents) => edits.addFile(path, contents),
+      templateRoot: join5(templatesRoot, "adjacent"),
+      values
+    });
+    const navigationFile = relocate("components/navigation.tsx");
+    if (!injected.includes(navigationFile)) {
+      manual.push({
+        file: navigationFile,
+        instruction: "A file of this name already exists, so Adjacent's navigation was " + `not written and nothing here imports it yet.
+
+` + "Either rename the existing file and run `adj init` again, or build " + "the navigation yourself with `Tabs` and `Tab` from `adjacent-ui`, " + "and render it through the `navigation` prop of `NavigationShell`."
+      });
+    }
+    if (options.scaffold) {
+      await renderTemplateTree({
+        relocate,
+        sink: (path, contents) => edits.addFile(path, contents),
+        templateRoot: join5(templatesRoot, "starter"),
+        values
+      });
+      await edits.removeFile(join5(survey.appDirectory, "page.tsx"));
+    }
+    const nextConfigFile = survey.nextConfigFile ?? "next.config.ts";
+    const nextConfigSource = await edits.readFile(nextConfigFile);
+    if (nextConfigSource === undefined) {
+      await edits.addFile(nextConfigFile, createNextConfig());
+    } else {
+      await applyRewrite({
+        edits,
+        file: nextConfigFile,
+        manual,
+        outcome: wrapNextConfig(nextConfigSource)
+      });
+    }
+    const layoutSource = await edits.readFile(survey.layoutFile);
+    if (layoutSource !== undefined) {
+      await applyRewrite({
+        edits,
+        file: survey.layoutFile,
+        manual,
+        outcome: wrapRootLayout(layoutSource, {
+          configImportPath: sourceRoot === "." ? "../app.config" : "../../app.config",
+          scaffolded: options.scaffold === true
+        })
+      });
+    }
+    if (survey.globalsCss) {
+      const styles = await edits.readFile(survey.globalsCss);
+      if (styles !== undefined) {
+        await applyRewrite({
+          edits,
+          file: survey.globalsCss,
+          manual,
+          outcome: injectAdjacentStyles(styles, { tailwind: survey.hasTailwind })
+        });
+      }
+    }
+    await edits.rewriteFile("package.json", `${JSON.stringify(addAdjacentDependencies(survey.packageJson, dependencies), null, 2)}
+`);
+  } catch (error) {
+    await edits.rollback();
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not add Adjacent to ${root}: ${detail}`);
+  }
+  const summary = edits.summary();
+  report.success(`Added ${summary.added.length} file${summary.added.length === 1 ? "" : "s"} and updated ${summary.rewritten.length}`);
+  let installed = false;
+  if (options.install) {
+    report.step("Installing dependencies with Bun");
+    await (ports.install ?? installDependencies)(root, installOptions);
+    installed = true;
+    report.success("Installed dependencies");
+  }
+  for (const step2 of manual) {
+    report.step(`${step2.file} needs one edit by hand:
+
+${step2.instruction}
+`);
+  }
+  return {
+    added: summary.added,
+    installed,
+    installOptions,
+    manual,
+    packageManager: manager,
+    rewritten: summary.rewritten,
+    root,
+    survey
+  };
+}
+
+// ../adjacent-cli/dist/create.js
+function createNextAppArguments(destination, manager) {
+  return [
+    destination,
+    "--app",
+    "--empty",
+    "--import-alias",
+    "@/*",
+    "--no-eslint",
+    "--no-src-dir",
+    "--tailwind",
+    "--typescript",
+    manager.scaffoldFlag,
+    "--disable-git",
+    "--yes"
+  ];
+}
+async function scaffoldNextApp({ destination }) {
+  const manager = await resolvePackageManager();
+  const { args, command } = manager.exec("create-next-app@latest", createNextAppArguments(destination, manager));
+  await runInheritedCommand(command, args).catch((error) => {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not create the Next.js application at ${destination}: ${detail}`);
+  });
+}
+function describeNextSteps({ cwd, destination, installOptions, installed, packageManager }) {
+  const relativePath = relative4(cwd, destination);
+  const target = relativePath === "" || relativePath.startsWith("..") ? destination : relativePath;
+  const install = packageManager.install(installOptions);
+  const dev = packageManager.run("dev");
+  return [
+    `cd ${target}`,
+    ...installed ? [] : [`${install.command} ${install.args.join(" ")}`],
+    `${dev.command} ${dev.args.join(" ")}`,
+    "adj dev --android"
+  ];
+}
+async function runCreate(options, ports = {}) {
+  const report = ports.reporter ?? TERMINAL_REPORTER;
+  const cwd = options.cwd ?? process.cwd();
+  const identity = deriveProjectIdentity(options.projectName);
+  const destination = resolveDestination(identity.packageName, options.directory, cwd);
+  report.intro("Adjacent project");
+  await assertDestinationUsable(destination);
+  report.step("Creating a Next.js application");
+  await (ports.createNextApp ?? scaffoldNextApp)({
+    destination,
+    projectName: identity.packageName
+  });
+  const result = await runInit({ install: options.install, projectRoot: destination, scaffold: true }, { ...ports, reporter: report });
+  const steps = describeNextSteps({
+    cwd,
+    destination,
+    installOptions: result.installOptions,
+    installed: result.installed,
+    packageManager: result.packageManager
+  });
+  report.step(`Next steps:
+${steps.map((command) => `  ${command}`).join(`
+`)}`);
+  report.outro(`${result.survey.identity.appName} is ready.`);
+  return { ...result, destination: resolve4(destination) };
+}
+// ../adjacent-cli/dist/dev-channel.js
+import { join as join6 } from "node:path";
+var STATE_FILE = join6(".adjacent", "dev.json");
+// ../adjacent-cli/dist/checks.js
+var PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+// ../adjacent-cli/dist/shutdown.js
+var lifecycle = process;
+// src/index.ts
+var USAGE = `Create an Adjacent application.
+
+  npm create adjacent@latest my-app
+  npm create adjacent@latest my-app -- --directory apps/my-app --no-install
+
+Options
+  --directory <path>   Write the project here instead of ./<project-name>
+  --no-install         Skip installing dependencies`;
+function parseArguments(argv) {
+  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+    return { help: true, install: true };
+  }
+  const directoryIndex = argv.indexOf("--directory");
+  const directory = directoryIndex === -1 ? undefined : argv[directoryIndex + 1];
+  const directoryValueIndex = directoryIndex === -1 ? -1 : directoryIndex + 1;
+  const projectName = argv.find((argument, index) => !argument.startsWith("-") && index !== directoryValueIndex);
+  return {
+    ...directory === undefined ? null : { directory },
+    help: false,
+    install: !argv.includes("--no-install"),
+    ...projectName === undefined ? null : { projectName }
+  };
+}
+async function main() {
+  const parsed = parseArguments(process.argv.slice(2));
+  if (parsed.help) {
+    console.log(USAGE);
+    return;
+  }
+  await runCreate(resolveCreateOptions(parsed.projectName, {
+    ...parsed.directory === undefined ? null : { directory: parsed.directory },
+    install: parsed.install
+  }));
+}
+main().catch((error) => {
+  console.error(`Adjacent failed: ${error instanceof Error ? error.message : String(error)}`);
+  process.exitCode = 1;
+});
+export {
+  parseArguments
+};