@boon4681/giri 0.0.3-alpha-12 → 0.0.3-alpha-13

package/dist/cli.js

@@ -9,6 +9,9 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -31,6 +34,62 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "node_modules/sisteransi/src/index.js"(exports2, module2) {
+    "use strict";
+    var ESC2 = "\x1B";
+    var CSI2 = `${ESC2}[`;
+    var beep = "\x07";
+    var cursor3 = {
+      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 erase3 = {
+      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 i2 = 0; i2 < count; i2++)
+          clear += this.line + (i2 < count - 1 ? cursor3.up() : "");
+        if (count)
+          clear += cursor3.left;
+        return clear;
+      }
+    };
+    module2.exports = { cursor: cursor3, scroll, erase: erase3, beep };
+  }
+});
+
 // src/loader/_es5.ts
 var es5_exports = {};
 __export(es5_exports, {
@@ -95,8 +154,8 @@ function intrinsicName(type) {
   return type.intrinsicName;
 }
 function isDateType(type) {
-  const symbol = type.getSymbol() ?? type.aliasSymbol;
-  return symbol?.getName() === "Date";
+  const symbol2 = type.getSymbol() ?? type.aliasSymbol;
+  return symbol2?.getName() === "Date";
 }
 function literalValuesOf(types) {
   const values = [];
@@ -128,10 +187,10 @@ function buildObjectSchema(type, ctx) {
   const indexInfo = checker.getIndexInfoOfType(type, import_typescript4.default.IndexKind.String) ?? checker.getIndexInfoOfType(type, import_typescript4.default.IndexKind.Number);
   const properties = {};
   const required = [];
-  for (const symbol of checker.getPropertiesOfType(type)) {
-    const name = symbol.getName();
-    const propType = checker.getTypeOfSymbolAtLocation(symbol, ctx.location);
-    const optional = Boolean(symbol.getFlags() & import_typescript4.default.SymbolFlags.Optional) || Boolean(propType.flags & import_typescript4.default.TypeFlags.Union && propType.types.some((t) => t.flags & import_typescript4.default.TypeFlags.Undefined));
+  for (const symbol2 of checker.getPropertiesOfType(type)) {
+    const name = symbol2.getName();
+    const propType = checker.getTypeOfSymbolAtLocation(symbol2, ctx.location);
+    const optional = Boolean(symbol2.getFlags() & import_typescript4.default.SymbolFlags.Optional) || Boolean(propType.flags & import_typescript4.default.TypeFlags.Union && propType.types.some((t2) => t2.flags & import_typescript4.default.TypeFlags.Undefined));
     properties[name] = walkType(propType, ctx);
     if (!optional) {
       required.push(name);
@@ -152,17 +211,17 @@ function buildObjectSchema(type, ctx) {
   return schema;
 }
 function toJsonReturnType(type, ctx) {
-  const symbol = ctx.checker.getPropertyOfType(type, "toJSON");
-  if (!symbol) {
+  const symbol2 = ctx.checker.getPropertyOfType(type, "toJSON");
+  if (!symbol2) {
     return void 0;
   }
-  const methodType = ctx.checker.getTypeOfSymbolAtLocation(symbol, ctx.location);
+  const methodType = ctx.checker.getTypeOfSymbolAtLocation(symbol2, ctx.location);
   const [signature] = methodType.getCallSignatures();
   return signature ? ctx.checker.getReturnTypeOfSignature(signature) : void 0;
 }
 function defName(type) {
-  const symbol = type.getSymbol() ?? type.aliasSymbol;
-  const name = symbol?.getName();
+  const symbol2 = type.getSymbol() ?? type.aliasSymbol;
+  const name = symbol2?.getName();
   if (name && name !== "__type" && name !== "__object") {
     return name;
   }
@@ -291,8 +350,8 @@ function collectReturnExpressions(fn) {
   return expressions;
 }
 function propertyType(checker, type, name, location) {
-  const symbol = checker.getPropertyOfType(type, name);
-  return symbol ? checker.getTypeOfSymbolAtLocation(symbol, location) : void 0;
+  const symbol2 = checker.getPropertyOfType(type, name);
+  return symbol2 ? checker.getTypeOfSymbolAtLocation(symbol2, location) : void 0;
 }
 function isTypedResponse(checker, type) {
   return Boolean(
@@ -383,7 +442,7 @@ function extractRouteResponses(program, file) {
     const schema = schemas.length === 1 ? schemas[0] : { anyOf: schemas };
     result.responses.push({ status, format, schema });
   }
-  result.responses.sort((a, b) => Number(a.status) - Number(b.status));
+  result.responses.sort((a2, b) => Number(a2.status) - Number(b.status));
   result.warnings = ctx.warnings;
   result.$defs = ctx.defs;
   return result;
@@ -416,20 +475,986 @@ var init_schema = __esm({
 
 // src/cli.ts
 var import_node_child_process = require("child_process");
-var import_node_fs12 = require("fs");
+var import_node_fs13 = require("fs");
 var import_promises5 = require("fs/promises");
-var import_node_path17 = require("path");
-var prompts = __toESM(require("@clack/prompts"));
+var import_node_path18 = require("path");
+
+// node_modules/@clack/core/dist/index.mjs
+var import_node_util = require("util");
+var import_node_process = require("process");
+var l = __toESM(require("readline"), 1);
+var import_node_readline = __toESM(require("readline"), 1);
+
+// node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = /* @__PURE__ */ (() => {
+  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/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 i2 = 0, l2 = PARSE_BLOCKS.length; i2 < l2; i2++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i2];
+      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/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/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "\x9B";
+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 void 0;
+};
+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 === void 0 ? 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 !== void 0 && 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("\n");
+  let inSurrogate = false;
+  for (let i2 = 0; i2 < preString.length; i2++) {
+    const character = preString[i2];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i2 + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== void 0) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? void 0 : code;
+      } else if (groups?.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    }
+    if (preString[i2 + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === "\n") {
+      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((line2) => exec(line2, columns, options)).join("\n");
+}
+
+// node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+var import_node_tty = require("tty");
+function findCursor(s, o2, l2) {
+  if (!l2.some((r2) => !r2.disabled))
+    return s;
+  const t2 = s + o2, n2 = Math.max(l2.length - 1, 0), e = t2 < 0 ? n2 : t2 > n2 ? 0 : t2;
+  return l2[e].disabled ? findCursor(e, o2 < 0 ? -1 : 1, l2) : e;
+}
+var a$2 = ["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$2),
+  aliases: /* @__PURE__ */ new Map([
+    // vim support
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["", "cancel"],
+    // opinionated defaults!
+    ["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: (n2, e) => `There are only ${n2} days in ${e}`,
+      afterMin: (n2) => `Date must be on or after ${n2.toISOString().slice(0, 10)}`,
+      beforeMax: (n2) => `Date must be on or before ${n2.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isActionKey(n2, e) {
+  if (typeof n2 == "string")
+    return settings.aliases.get(n2) === e;
+  for (const s of n2)
+    if (s !== void 0 && isActionKey(s, e))
+      return true;
+  return false;
+}
+function diffLines(i2, s) {
+  if (i2 === s) return;
+  const e = i2.split(`
+`), t2 = s.split(`
+`), r2 = Math.max(e.length, t2.length), f = [];
+  for (let n2 = 0; n2 < r2; n2++)
+    e[n2] !== t2[n2] && f.push(n2);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t2.length,
+    numLines: r2
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = /* @__PURE__ */ Symbol("clack:cancel");
+function isCancel(e) {
+  return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r2) {
+  const o2 = e;
+  o2.isTTY && o2.setRawMode(r2);
+}
+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 wrapTextWithPrefix(e, r2, o2, t2 = o2, s = o2, n2) {
+  const f = getColumns(e ?? import_node_process.stdout);
+  return wrapAnsi(r2, f - o2.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c2, i2, m) => {
+    const d = n2 ? n2(c2, i2) : c2;
+    return i2 === 0 ? `${t2}${d}` : i2 === m.length - 1 ? `${s}${d}` : `${o2}${d}`;
+  }).join(`
+`);
+}
+function runValidation(e, n2) {
+  if ("~standard" in e) {
+    const a2 = e["~standard"].validate(n2);
+    if (a2 instanceof Promise)
+      throw new TypeError(
+        "Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic."
+      );
+    return a2.issues?.at(0)?.message;
+  }
+  return e(n2);
+}
+var V = class {
+  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: i2 = import_node_process.stdin, output: n2 = import_node_process.stdout, render: s, signal: r2, ...o2 } = t2;
+    this.opts = o2, 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 = r2, this.input = i2, this.output = n2;
+  }
+  /**
+   * Unsubscribe all listeners
+   */
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  /**
+   * Set a subscriber with opts
+   * @param event - The event name
+   */
+  setSubscriber(t2, e) {
+    const i2 = this._subscribers.get(t2) ?? [];
+    i2.push(e), this._subscribers.set(t2, i2);
+  }
+  /**
+   * Subscribe to an event
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  on(t2, e) {
+    this.setSubscriber(t2, { cb: e });
+  }
+  /**
+   * Subscribe to an event once
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  once(t2, e) {
+    this.setSubscriber(t2, { cb: e, once: true });
+  }
+  /**
+   * Emit an event with data
+   * @param event - The event name
+   * @param data - The data to pass to the callback
+   */
+  emit(t2, ...e) {
+    const i2 = this._subscribers.get(t2) ?? [], n2 = [];
+    for (const s of i2)
+      s.cb(...e), s.once && n2.push(() => i2.splice(i2.indexOf(s), 1));
+    for (const s of n2)
+      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 = import_node_readline.default.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      }), this.rl.prompt(), this.opts.initialUserInput !== void 0 && 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 === "	";
+  }
+  _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 i2 = runValidation(this.opts.validate, this.value);
+        i2 && (this.error = i2 instanceof Error ? i2.message : i2, 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 = void 0, 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), i2 = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const n2 = Math.max(0, e.numLinesAfter - i2), s = Math.max(0, e.numLinesBefore - i2);
+          let r2 = e.lines.find((o2) => o2 >= n2);
+          if (r2 === void 0) {
+            this._prevFrame = t2;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, r2 - s)), this.output.write(import_sisteransi.erase.lines(1));
+            const o2 = t2.split(`
+`);
+            this.output.write(o2[r2]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, o2.length - r2 - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (n2 < s)
+              r2 = n2;
+            else {
+              const h2 = r2 - s;
+              h2 > 0 && this.output.write(import_sisteransi.cursor.move(0, h2));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f = t2.split(`
+`).slice(r2);
+            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;
+    }
+  }
+};
+var r = class extends V {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t2) {
+    super(t2, false), this.value = !!t2.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (i2) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = i2, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+};
+var a = class extends V {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    this.value = this._selectedValue.value;
+  }
+  constructor(t2) {
+    super(t2, false), this.options = t2.options;
+    const i2 = this.options.findIndex(({ value: s }) => s === t2.initialValue), e = i2 === -1 ? 0 : i2;
+    this.cursor = this.options[e].disabled ? findCursor(e, 1, this.options) : e, this.changeValue(), this.on("cursor", (s) => {
+      switch (s) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+
+// node_modules/@clack/prompts/dist/index.mjs
+var import_node_util2 = require("util");
+var import_node_process2 = __toESM(require("process"), 1);
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_sisteransi2 = __toESM(require_src(), 1);
+function isUnicodeSupported() {
+  if (import_node_process2.default.platform !== "win32") {
+    return import_node_process2.default.env.TERM !== "linux";
+  }
+  return Boolean(import_node_process2.default.env.CI) || Boolean(import_node_process2.default.env.WT_SESSION) || Boolean(import_node_process2.default.env.TERMINUS_SUBLIME) || import_node_process2.default.env.ConEmuTask === "{cmd::Cmder}" || import_node_process2.default.env.TERM_PROGRAM === "Terminus-Sublime" || import_node_process2.default.env.TERM_PROGRAM === "vscode" || import_node_process2.default.env.TERM === "xterm-256color" || import_node_process2.default.env.TERM === "alacritty" || import_node_process2.default.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode = isUnicodeSupported();
+var unicodeOr = (e, o2) => unicode ? e : o2;
+var S_STEP_ACTIVE = unicodeOr("\u25C6", "*");
+var S_STEP_CANCEL = unicodeOr("\u25A0", "x");
+var S_STEP_ERROR = unicodeOr("\u25B2", "x");
+var S_STEP_SUBMIT = unicodeOr("\u25C7", "o");
+var S_BAR_START = unicodeOr("\u250C", "T");
+var S_BAR = unicodeOr("\u2502", "|");
+var S_BAR_END = unicodeOr("\u2514", "\u2014");
+var S_BAR_START_RIGHT = unicodeOr("\u2510", "T");
+var S_BAR_END_RIGHT = unicodeOr("\u2518", "\u2014");
+var S_RADIO_ACTIVE = unicodeOr("\u25CF", ">");
+var S_RADIO_INACTIVE = unicodeOr("\u25CB", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("\u25FB", "[\u2022]");
+var S_CHECKBOX_SELECTED = unicodeOr("\u25FC", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("\u25FB", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("\u25AA", "\u2022");
+var S_BAR_H = unicodeOr("\u2500", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("\u256E", "+");
+var S_CONNECT_LEFT = unicodeOr("\u251C", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("\u256F", "+");
+var S_CORNER_BOTTOM_LEFT = unicodeOr("\u2570", "+");
+var S_CORNER_TOP_LEFT = unicodeOr("\u256D", "+");
+var S_INFO = unicodeOr("\u25CF", "\u2022");
+var S_SUCCESS = unicodeOr("\u25C6", "*");
+var S_WARN = unicodeOr("\u25B2", "!");
+var S_ERROR = unicodeOr("\u25A0", "x");
+var symbol = (e) => {
+  switch (e) {
+    case "initial":
+    case "active":
+      return (0, import_node_util2.styleText)("cyan", S_STEP_ACTIVE);
+    case "cancel":
+      return (0, import_node_util2.styleText)("red", S_STEP_CANCEL);
+    case "error":
+      return (0, import_node_util2.styleText)("yellow", S_STEP_ERROR);
+    case "submit":
+      return (0, import_node_util2.styleText)("green", S_STEP_SUBMIT);
+  }
+};
+var symbolBar = (e) => {
+  switch (e) {
+    case "initial":
+    case "active":
+      return (0, import_node_util2.styleText)("cyan", S_BAR);
+    case "cancel":
+      return (0, import_node_util2.styleText)("red", S_BAR);
+    case "error":
+      return (0, import_node_util2.styleText)("yellow", S_BAR);
+    case "submit":
+      return (0, import_node_util2.styleText)("green", S_BAR);
+  }
+};
+var E$1 = (l2, o2, g, c2, h2, O = false) => {
+  let r2 = o2, w = 0;
+  if (O)
+    for (let i2 = c2 - 1; i2 >= g && (r2 -= l2[i2].length, w++, !(r2 <= h2)); i2--)
+      ;
+  else
+    for (let i2 = g; i2 < c2 && (r2 -= l2[i2].length, w++, !(r2 <= h2)); i2++)
+      ;
+  return { lineCount: r2, removals: w };
+};
+var limitOptions = ({
+  cursor: l2,
+  options: o2,
+  style: g,
+  output: c2 = process.stdout,
+  maxItems: h2 = Number.POSITIVE_INFINITY,
+  columnPadding: O = 0,
+  rowPadding: r2 = 4
+}) => {
+  const i2 = getColumns(c2) - O, I = getRows(c2), C = (0, import_node_util2.styleText)("dim", "..."), x = Math.max(I - r2, 0), m = Math.max(Math.min(h2, x), 5);
+  let p = 0;
+  l2 >= m - 3 && (p = Math.max(
+    Math.min(l2 - m + 3, o2.length - m),
+    0
+  ));
+  let f = m < o2.length && p > 0, u3 = m < o2.length && p + m < o2.length;
+  const W = Math.min(
+    p + m,
+    o2.length
+  ), e = [];
+  let d = 0;
+  f && d++, u3 && d++;
+  const v = p + (f ? 1 : 0), P = W - (u3 ? 1 : 0);
+  for (let t2 = v; t2 < P; t2++) {
+    const n2 = wrapAnsi(g(o2[t2], t2 === l2), i2, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    e.push(n2), d += n2.length;
+  }
+  if (d > x) {
+    let t2 = 0, n2 = 0, s = d;
+    const M = l2 - v;
+    let a2 = x;
+    const T = () => E$1(e, s, 0, M, a2), L = () => E$1(
+      e,
+      s,
+      M + 1,
+      e.length,
+      a2,
+      true
+    );
+    f ? ({ lineCount: s, removals: t2 } = T(), s > a2 && (u3 || (a2 -= 1), { lineCount: s, removals: n2 } = L())) : (u3 || (a2 -= 1), { lineCount: s, removals: n2 } = L(), s > a2 && (a2 -= 1, { lineCount: s, removals: t2 } = T())), t2 > 0 && (f = true, e.splice(0, t2)), n2 > 0 && (u3 = true, e.splice(e.length - n2, n2));
+  }
+  const b = [];
+  f && b.push(C);
+  for (const t2 of e)
+    for (const n2 of t2)
+      b.push(n2);
+  return u3 && b.push(C), b;
+};
+var confirm = (i2) => {
+  const a2 = i2.active ?? "Yes", s = i2.inactive ?? "No";
+  return new r({
+    active: a2,
+    inactive: s,
+    signal: i2.signal,
+    input: i2.input,
+    output: i2.output,
+    initialValue: i2.initialValue ?? true,
+    render() {
+      const e = i2.withGuide ?? settings.withGuide, u3 = `${symbol(this.state)}  `, l2 = e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "", f = wrapTextWithPrefix(
+        i2.output,
+        i2.message,
+        l2,
+        u3
+      ), o2 = `${e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+` : ""}${f}
+`, c2 = this.value ? a2 : s;
+      switch (this.state) {
+        case "submit": {
+          const r2 = e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "";
+          return `${o2}${r2}${(0, import_node_util2.styleText)("dim", c2)}`;
+        }
+        case "cancel": {
+          const r2 = e ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "";
+          return `${o2}${r2}${(0, import_node_util2.styleText)(["strikethrough", "dim"], c2)}${e ? `
+${(0, import_node_util2.styleText)("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = e ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : "", g = e ? (0, import_node_util2.styleText)("cyan", S_BAR_END) : "";
+          return `${o2}${r2}${this.value ? `${(0, import_node_util2.styleText)("green", S_RADIO_ACTIVE)} ${a2}` : `${(0, import_node_util2.styleText)("dim", S_RADIO_INACTIVE)} ${(0, import_node_util2.styleText)("dim", a2)}`}${i2.vertical ? e ? `
+${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : `
+` : ` ${(0, import_node_util2.styleText)("dim", "/")} `}${this.value ? `${(0, import_node_util2.styleText)("dim", S_RADIO_INACTIVE)} ${(0, import_node_util2.styleText)("dim", s)}` : `${(0, import_node_util2.styleText)("green", S_RADIO_ACTIVE)} ${s}`}
+${g}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var log = {
+  message: (s = [], {
+    symbol: e = (0, import_node_util2.styleText)("gray", S_BAR),
+    secondarySymbol: r2 = (0, import_node_util2.styleText)("gray", S_BAR),
+    output: m = process.stdout,
+    spacing: l2 = 1,
+    withGuide: c2
+  } = {}) => {
+    const t2 = [], o2 = c2 ?? settings.withGuide, f = o2 ? r2 : "", O = o2 ? `${e}  ` : "", u3 = o2 ? `${r2}  ` : "";
+    for (let i2 = 0; i2 < l2; i2++)
+      t2.push(f);
+    const g = Array.isArray(s) ? s : s.split(`
+`);
+    if (g.length > 0) {
+      const [i2, ...y] = g;
+      i2.length > 0 ? t2.push(`${O}${i2}`) : t2.push(o2 ? e : "");
+      for (const p of y)
+        p.length > 0 ? t2.push(`${u3}${p}`) : t2.push(o2 ? r2 : "");
+    }
+    m.write(`${t2.join(`
+`)}
+`);
+  },
+  info: (s, e) => {
+    log.message(s, { ...e, symbol: (0, import_node_util2.styleText)("blue", S_INFO) });
+  },
+  success: (s, e) => {
+    log.message(s, { ...e, symbol: (0, import_node_util2.styleText)("green", S_SUCCESS) });
+  },
+  step: (s, e) => {
+    log.message(s, { ...e, symbol: (0, import_node_util2.styleText)("green", S_STEP_SUBMIT) });
+  },
+  warn: (s, e) => {
+    log.message(s, { ...e, symbol: (0, import_node_util2.styleText)("yellow", S_WARN) });
+  },
+  /** alias for `log.warn()`. */
+  warning: (s, e) => {
+    log.warn(s, e);
+  },
+  error: (s, e) => {
+    log.message(s, { ...e, symbol: (0, import_node_util2.styleText)("red", S_ERROR) });
+  }
+};
+var cancel = (o2 = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${(0, import_node_util2.styleText)("gray", S_BAR_END)}  ` : "";
+  i2.write(`${e}${(0, import_node_util2.styleText)("red", o2)}
+
+`);
+};
+var intro = (o2 = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${(0, import_node_util2.styleText)("gray", S_BAR_START)}  ` : "";
+  i2.write(`${e}${o2}
+`);
+};
+var outro = (o2 = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+${(0, import_node_util2.styleText)("gray", S_BAR_END)}  ` : "";
+  i2.write(`${e}${o2}
+
+`);
+};
+var u2 = {
+  light: unicodeOr("\u2500", "-"),
+  heavy: unicodeOr("\u2501", "="),
+  block: unicodeOr("\u2588", "#")
+};
+var c = (e, a2) => e.includes(`
+`) ? e.split(`
+`).map((t2) => a2(t2)).join(`
+`) : a2(e);
+var select = (e) => {
+  const a2 = (t2, d) => {
+    const s = t2.label ?? String(t2.value);
+    switch (d) {
+      case "disabled":
+        return `${(0, import_node_util2.styleText)("gray", S_RADIO_INACTIVE)} ${c(s, (n2) => (0, import_node_util2.styleText)("gray", n2))}${t2.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${t2.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${c(s, (n2) => (0, import_node_util2.styleText)("dim", n2))}`;
+      case "active":
+        return `${(0, import_node_util2.styleText)("green", S_RADIO_ACTIVE)} ${s}${t2.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${t2.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${c(s, (n2) => (0, import_node_util2.styleText)(["strikethrough", "dim"], n2))}`;
+      default:
+        return `${(0, import_node_util2.styleText)("dim", S_RADIO_INACTIVE)} ${c(s, (n2) => (0, import_node_util2.styleText)("dim", n2))}`;
+    }
+  };
+  return new a({
+    options: e.options,
+    signal: e.signal,
+    input: e.input,
+    output: e.output,
+    initialValue: e.initialValue,
+    render() {
+      const t2 = e.withGuide ?? settings.withGuide, d = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, n2 = wrapTextWithPrefix(
+        e.output,
+        e.message,
+        s,
+        d
+      ), u3 = `${t2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}
+` : ""}${n2}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r2 = t2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "", l2 = wrapTextWithPrefix(
+            e.output,
+            a2(this.options[this.cursor], "selected"),
+            r2
+          );
+          return `${u3}${l2}`;
+        }
+        case "cancel": {
+          const r2 = t2 ? `${(0, import_node_util2.styleText)("gray", S_BAR)}  ` : "", l2 = wrapTextWithPrefix(
+            e.output,
+            a2(this.options[this.cursor], "cancelled"),
+            r2
+          );
+          return `${u3}${l2}${t2 ? `
+${(0, import_node_util2.styleText)("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = t2 ? `${(0, import_node_util2.styleText)("cyan", S_BAR)}  ` : "", l2 = t2 ? (0, import_node_util2.styleText)("cyan", S_BAR_END) : "", g = u3.split(`
+`).length, h2 = t2 ? 2 : 1;
+          return `${u3}${r2}${limitOptions({
+            output: e.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: e.maxItems,
+            columnPadding: r2.length,
+            rowPadding: g + h2,
+            style: (p, b) => a2(p, p.disabled ? "disabled" : b ? "active" : "inactive")
+          }).join(`
+${r2}`)}
+${l2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var i = `${(0, import_node_util2.styleText)("gray", S_BAR)}  `;
 
 // src/app.ts
 var import_node_module = __toESM(require("module"));
-var import_node_path3 = require("path");
+var import_node_path4 = require("path");
 
 // src/loader/loader.ts
-var import_prompts = require("@clack/prompts");
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-var import_node_process = require("process");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_node_process3 = require("process");
 
 // src/config/schema.ts
 var import_typebox = require("@sinclair/typebox");
@@ -457,14 +1482,14 @@ var assertES5 = async (unregister) => {
     if ("errors" in e && Array.isArray(e.errors) && e.errors.length > 0) {
       const es5Error = e.errors.filter((it) => it.text?.includes(`("es5") is not supported yet`)).length > 0;
       if (es5Error) {
-        import_prompts.log.error(
+        log.error(
           `Please change compilerOptions.target from 'es5' to 'es6' or above in your tsconfig.json`
         );
-        (0, import_node_process.exit)(1);
+        (0, import_node_process3.exit)(1);
       }
     }
-    import_prompts.log.error(e);
-    (0, import_node_process.exit)(1);
+    log.error(e);
+    (0, import_node_process3.exit)(1);
   }
 };
 var safeRegister = async () => {
@@ -484,10 +1509,10 @@ var safeRegister = async () => {
   await assertES5(res.unregister);
   return res;
 };
-var findConfigPath = (cwd = (0, import_node_path.resolve)()) => {
+var findConfigPath = (cwd = (0, import_node_path2.resolve)()) => {
   for (const name of ["giri.config.ts", "giri.config.js"]) {
-    const path = (0, import_node_path.resolve)(cwd, name);
-    if ((0, import_node_fs.existsSync)(path)) {
+    const path = (0, import_node_path2.resolve)(cwd, name);
+    if ((0, import_node_fs2.existsSync)(path)) {
       return path;
     }
   }
@@ -498,8 +1523,8 @@ var load = async (opts = {}) => {
     if (opts.throwOnError) {
       throw new Error(message);
     }
-    import_prompts.log.error(message);
-    (0, import_node_process.exit)(1);
+    log.error(message);
+    (0, import_node_process3.exit)(1);
   };
   const path = findConfigPath();
   if (!path) {
@@ -518,7 +1543,7 @@ var load = async (opts = {}) => {
     const messages = [...import_value.Value.Errors(configSchema, content)].map((error) => error.message);
     if (!opts.throwOnError) {
       for (const message of messages) {
-        import_prompts.log.error(message);
+        log.error(message);
       }
     }
     fail(messages.join("\n"));
@@ -527,9 +1552,9 @@ var load = async (opts = {}) => {
 };
 
 // src/routes.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_promises = require("fs/promises");
-var import_node_path2 = require("path");
+var import_node_path3 = require("path");
 var import_tinyglobby = require("tinyglobby");
 var import_typescript = __toESM(require("typescript"));
 var METHOD_ORDER = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
@@ -537,7 +1562,7 @@ var METHOD_FROM_FILE = new Map(
   METHOD_ORDER.map((method) => [`+${method.toLowerCase()}`, method])
 );
 function normalizeSlashes(path) {
-  return path.split(import_node_path2.sep).join("/");
+  return path.split(import_node_path3.sep).join("/");
 }
 function isRouteSourceFile(fileName) {
   return /\.(?:[cm]?[jt]s|[jt]sx)$/.test(fileName) && !fileName.endsWith(".d.ts");
@@ -628,7 +1653,7 @@ function hasNamedHandleExport(source) {
 function parseSource(file) {
   return import_typescript.default.createSourceFile(
     file,
-    (0, import_node_fs2.readFileSync)(file, "utf8"),
+    (0, import_node_fs3.readFileSync)(file, "utf8"),
     import_typescript.default.ScriptTarget.Latest,
     true
   );
@@ -665,8 +1690,8 @@ function sharedFileIn(dir, cache) {
     return cache.get(dir);
   }
   for (const ext of ["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts"]) {
-    const file = (0, import_node_path2.join)(dir, `+shared.${ext}`);
-    if ((0, import_node_fs2.existsSync)(file)) {
+    const file = (0, import_node_path3.join)(dir, `+shared.${ext}`);
+    if ((0, import_node_fs3.existsSync)(file)) {
       cache?.set(dir, file);
       return file;
     }
@@ -675,7 +1700,7 @@ function sharedFileIn(dir, cache) {
   return void 0;
 }
 function physicalRouteSegments(routesDir, routeDir) {
-  const rel = (0, import_node_path2.relative)(routesDir, routeDir);
+  const rel = (0, import_node_path3.relative)(routesDir, routeDir);
   if (!rel) {
     return [];
   }
@@ -724,14 +1749,14 @@ function compareRoutes(left, right) {
   const leftRanks = segmentRanks(left.routeSegments);
   const rightRanks = segmentRanks(right.routeSegments);
   const shared = Math.min(leftRanks.length, rightRanks.length);
-  for (let i = 0; i < shared; i++) {
-    const a = leftRanks[i];
-    const b = rightRanks[i];
-    if (a.rank !== b.rank) {
-      return a.rank - b.rank;
+  for (let i2 = 0; i2 < shared; i2++) {
+    const a2 = leftRanks[i2];
+    const b = rightRanks[i2];
+    if (a2.rank !== b.rank) {
+      return a2.rank - b.rank;
     }
-    if (a.rank === 0 && a.text !== b.text) {
-      return a.text.localeCompare(b.text);
+    if (a2.rank === 0 && a2.text !== b.text) {
+      return a2.text.localeCompare(b.text);
     }
   }
   if (leftRanks.length !== rightRanks.length) {
@@ -757,14 +1782,14 @@ function pathFromSegments(segments) {
   };
 }
 async function scanRouteFolders(routesDir) {
-  if (!(0, import_node_fs2.existsSync)(routesDir)) {
+  if (!(0, import_node_fs3.existsSync)(routesDir)) {
     return [];
   }
   const folders = [routesDir];
   const walk = async (dir) => {
     for (const entry of await (0, import_promises.readdir)(dir, { withFileTypes: true })) {
       if (entry.isDirectory() && entry.name !== "node_modules") {
-        const full = (0, import_node_path2.join)(dir, entry.name);
+        const full = (0, import_node_path3.join)(dir, entry.name);
         folders.push(full);
         await walk(full);
       }
@@ -781,13 +1806,13 @@ function sharedFilesForDir(routesDir, dir, cache) {
   const dirs = [routesDir];
   let current = routesDir;
   for (const segment of segments) {
-    current = (0, import_node_path2.join)(current, segment);
+    current = (0, import_node_path3.join)(current, segment);
     dirs.push(current);
   }
   return dirs.map((currentDir) => sharedFileIn(currentDir, cache)).filter((file) => Boolean(file));
 }
 async function scanRoutes(routesDir) {
-  if (!(0, import_node_fs2.existsSync)(routesDir)) {
+  if (!(0, import_node_fs3.existsSync)(routesDir)) {
     return [];
   }
   const files = await (0, import_tinyglobby.glob)("**/+*.{ts,tsx,js,jsx,mjs,cjs,mts,cts}", {
@@ -798,11 +1823,11 @@ async function scanRoutes(routesDir) {
   const routes = [];
   const sharedCache = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const method = methodFromFile((0, import_node_path2.basename)(file));
+    const method = methodFromFile((0, import_node_path3.basename)(file));
     if (!method) {
       continue;
     }
-    const routeDir = (0, import_node_path2.dirname)(file);
+    const routeDir = (0, import_node_path3.dirname)(file);
     const routeSegments = physicalRouteSegments(routesDir, routeDir);
     const { path, params } = pathFromSegments(routeSegments);
     routes.push({
@@ -914,7 +1939,7 @@ function aliasValues(value) {
 }
 function resolveAliasTarget(cwd, target, capture = "") {
   const replaced = target.includes("*") ? target.replaceAll("*", capture) : target;
-  return (0, import_node_path3.isAbsolute)(replaced) ? replaced : (0, import_node_path3.resolve)(cwd, replaced);
+  return (0, import_node_path4.isAbsolute)(replaced) ? replaced : (0, import_node_path4.resolve)(cwd, replaced);
 }
 function matchAlias(request, key) {
   if (key.includes("*")) {
@@ -972,15 +1997,15 @@ function ensureGiriAliasResolver(outDir) {
   const moduleWithResolver = import_node_module.default;
   const originalResolveFilename = moduleWithResolver._resolveFilename;
   moduleWithResolver._resolveFilename = function resolveWithGiriInternalAlias(request, parent, isMain, options) {
-    const mapped = typeof request === "string" && request.startsWith(GIRI_ALIAS_PREFIX) && giriOutDir ? (0, import_node_path3.join)(giriOutDir, request.slice(GIRI_ALIAS_PREFIX.length)) : request;
+    const mapped = typeof request === "string" && request.startsWith(GIRI_ALIAS_PREFIX) && giriOutDir ? (0, import_node_path4.join)(giriOutDir, request.slice(GIRI_ALIAS_PREFIX.length)) : request;
     return originalResolveFilename.call(this, mapped, parent, isMain, options);
   };
 }
 function resolveGiriPaths(config, cwd = process.cwd()) {
   return {
-    cwd: (0, import_node_path3.resolve)(cwd),
-    routesDir: (0, import_node_path3.resolve)(cwd, "src/routes"),
-    outDir: (0, import_node_path3.resolve)(cwd, config.outDir ?? ".giri")
+    cwd: (0, import_node_path4.resolve)(cwd),
+    routesDir: (0, import_node_path4.resolve)(cwd, "src/routes"),
+    outDir: (0, import_node_path4.resolve)(cwd, config.outDir ?? ".giri")
   };
 }
 async function buildGiriApp(config, options = {}) {
@@ -1063,59 +2088,59 @@ async function buildGiriApp(config, options = {}) {
 }
 
 // src/generator/sync.ts
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var import_promises4 = require("fs/promises");
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 
 // src/generator/app-types.ts
-var import_node_fs4 = require("fs");
-var import_node_path5 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path6 = require("path");
 
 // src/generator/util.ts
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_promises2 = require("fs/promises");
-var import_node_path4 = require("path");
+var import_node_path5 = require("path");
 var GENERATED_HEADER = "// Generated by giri sync. Do not edit.";
 function slash(path) {
-  return path.split(import_node_path4.sep).join("/");
+  return path.split(import_node_path5.sep).join("/");
 }
 function importPath(fromFile, toFile) {
-  let path = slash((0, import_node_path4.relative)((0, import_node_path4.dirname)(fromFile), toFile)).replace(/\.d\.ts$/, "");
+  let path = slash((0, import_node_path5.relative)((0, import_node_path5.dirname)(fromFile), toFile)).replace(/\.d\.ts$/, "");
   if (!path.startsWith(".")) {
     path = `./${path}`;
   }
   return path;
 }
 function relativeConfigPath(fromDir, toPath) {
-  let path = slash((0, import_node_path4.relative)(fromDir, toPath));
+  let path = slash((0, import_node_path5.relative)(fromDir, toPath));
   if (!path.startsWith(".")) {
     path = `./${path}`;
   }
   return path;
 }
 function moduleSpecifier(fromDir, target) {
-  let path = slash((0, import_node_path4.relative)(fromDir, target)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+  let path = slash((0, import_node_path5.relative)(fromDir, target)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
   if (!path.startsWith(".")) {
     path = `./${path}`;
   }
   return path;
 }
 function typeFilePath(paths, routeDir) {
-  const sourceDir = (0, import_node_path4.relative)(paths.cwd, routeDir);
-  return (0, import_node_path4.join)(paths.outDir, "types", sourceDir, "$types.d.ts");
+  const sourceDir = (0, import_node_path5.relative)(paths.cwd, routeDir);
+  return (0, import_node_path5.join)(paths.outDir, "types", sourceDir, "$types.d.ts");
 }
 function assertSafeOutDir(paths) {
-  const rel = (0, import_node_path4.relative)(paths.cwd, paths.outDir);
-  if (!rel || rel.startsWith("..") || rel.includes(`..${import_node_path4.sep}`)) {
+  const rel = (0, import_node_path5.relative)(paths.cwd, paths.outDir);
+  if (!rel || rel.startsWith("..") || rel.includes(`..${import_node_path5.sep}`)) {
     throw new Error(`Refusing to sync outside the project root: ${paths.outDir}`);
   }
 }
 var writeCache = /* @__PURE__ */ new Map();
 async function writeGenerated(path, content) {
-  if (writeCache.get(path) === content && (0, import_node_fs3.existsSync)(path)) {
+  if (writeCache.get(path) === content && (0, import_node_fs4.existsSync)(path)) {
     return;
   }
-  await (0, import_promises2.mkdir)((0, import_node_path4.dirname)(path), { recursive: true });
+  await (0, import_promises2.mkdir)((0, import_node_path5.dirname)(path), { recursive: true });
   await (0, import_promises2.writeFile)(path, content);
   writeCache.set(path, content);
 }
@@ -1131,7 +2156,7 @@ async function pruneDir(dir, keep) {
     return;
   }
   for (const entry of entries) {
-    const full = (0, import_node_path4.join)(dir, entry.name);
+    const full = (0, import_node_path5.join)(dir, entry.name);
     if (entry.isDirectory()) {
       await pruneDir(full, keep);
       await (0, import_promises2.rmdir)(full).catch(() => {
@@ -1147,28 +2172,28 @@ async function pruneDir(dir, keep) {
 var MAIN_EXTENSIONS = ["ts", "tsx", "mts", "cts", "js", "jsx", "mjs", "cjs"];
 function findMainFile(cwd) {
   for (const ext of MAIN_EXTENSIONS) {
-    const file = (0, import_node_path5.join)(cwd, "src", `main.${ext}`);
-    if ((0, import_node_fs4.existsSync)(file)) {
+    const file = (0, import_node_path6.join)(cwd, "src", `main.${ext}`);
+    if ((0, import_node_fs5.existsSync)(file)) {
       return file;
     }
   }
   return void 0;
 }
 function moduleSpecifier2(fromDir, target) {
-  let path = slash((0, import_node_path5.relative)(fromDir, target)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+  let path = slash((0, import_node_path6.relative)(fromDir, target)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
   if (!path.startsWith(".")) {
     path = `./${path}`;
   }
   return path;
 }
 async function writeAppTypes(paths) {
-  const file = (0, import_node_path5.join)(paths.outDir, "types", "app.d.ts");
+  const file = (0, import_node_path6.join)(paths.outDir, "types", "app.d.ts");
   const mainFile = findMainFile(paths.cwd);
   if (!mainFile) {
     await writeGenerated(file, [GENERATED_HEADER, "export {};", ""].join("\n"));
     return;
   }
-  const spec = moduleSpecifier2((0, import_node_path5.join)(paths.outDir, "types"), mainFile);
+  const spec = moduleSpecifier2((0, import_node_path6.join)(paths.outDir, "types"), mainFile);
   await writeGenerated(
     file,
     [
@@ -1191,7 +2216,7 @@ async function writeAppTypes(paths) {
 }
 
 // src/generator/manifest.ts
-var import_node_path6 = require("path");
+var import_node_path7 = require("path");
 async function writeManifest(paths, routes, data = {}) {
   const manifest = {
     version: 1,
@@ -1202,10 +2227,10 @@ async function writeManifest(paths, routes, data = {}) {
       return {
         method: route.method,
         path: route.path,
-        file: slash((0, import_node_path6.relative)(paths.cwd, route.file)),
+        file: slash((0, import_node_path7.relative)(paths.cwd, route.file)),
         params: route.params,
-        shared: route.sharedFiles.map((file) => slash((0, import_node_path6.relative)(paths.cwd, file))),
-        types: slash((0, import_node_path6.relative)(paths.cwd, typeFilePath(paths, route.routeDir))),
+        shared: route.sharedFiles.map((file) => slash((0, import_node_path7.relative)(paths.cwd, file))),
+        types: slash((0, import_node_path7.relative)(paths.cwd, typeFilePath(paths, route.routeDir))),
         ...data.hiddenFiles?.has(route.file) ? { hidden: true } : {},
         ...input ? { input } : {},
         ...security && security.security.length > 0 ? { security: security.security } : {},
@@ -1214,12 +2239,12 @@ async function writeManifest(paths, routes, data = {}) {
       };
     })
   };
-  await writeJson((0, import_node_path6.join)(paths.outDir, "manifest.json"), manifest);
+  await writeJson((0, import_node_path7.join)(paths.outDir, "manifest.json"), manifest);
 }
 
 // src/generator/openapi.ts
-var import_node_fs5 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path8 = require("path");
 var REASON = {
   200: "OK",
   201: "Created",
@@ -1303,10 +2328,10 @@ function queryParameters(query) {
   }));
 }
 function readProjectInfo(cwd) {
-  const file = (0, import_node_path7.join)(cwd, "package.json");
-  if ((0, import_node_fs5.existsSync)(file)) {
+  const file = (0, import_node_path8.join)(cwd, "package.json");
+  if ((0, import_node_fs6.existsSync)(file)) {
     try {
-      const pkg = JSON.parse((0, import_node_fs5.readFileSync)(file, "utf8"));
+      const pkg = JSON.parse((0, import_node_fs6.readFileSync)(file, "utf8"));
       return { title: pkg.name ?? "giri API", version: pkg.version ?? "0.0.0" };
     } catch {
     }
@@ -1398,11 +2423,11 @@ function buildOpenApiDocument(paths, routes, data = {}) {
   return document;
 }
 async function writeOpenApi(paths, routes, data = {}) {
-  await writeJson((0, import_node_path7.join)(paths.outDir, "openapi.json"), buildOpenApiDocument(paths, routes, data));
+  await writeJson((0, import_node_path8.join)(paths.outDir, "openapi.json"), buildOpenApiDocument(paths, routes, data));
 }
 
 // src/generator/param-types.ts
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 function paramsType(params) {
   if (params.length === 0) {
     return "{}";
@@ -1426,17 +2451,17 @@ function middlewareInputType(typesDir, sharedFile) {
 }
 function ownSharedFile(dir, sharedFiles) {
   for (let index = sharedFiles.length - 1; index >= 0; index -= 1) {
-    if ((0, import_node_path8.dirname)(sharedFiles[index]) === dir) {
+    if ((0, import_node_path9.dirname)(sharedFiles[index]) === dir) {
       return sharedFiles[index];
     }
   }
   return void 0;
 }
 function varsType(paths, file, dir, sharedFiles) {
-  const typesDir = (0, import_node_path8.dirname)(file);
+  const typesDir = (0, import_node_path9.dirname)(file);
   const parts = [];
   if (dir !== paths.routesDir) {
-    parts.push(`import(${JSON.stringify(importPath(file, typeFilePath(paths, (0, import_node_path8.dirname)(dir))))}).Vars`);
+    parts.push(`import(${JSON.stringify(importPath(file, typeFilePath(paths, (0, import_node_path9.dirname)(dir))))}).Vars`);
   }
   const ownShared = ownSharedFile(dir, sharedFiles);
   if (ownShared) {
@@ -1445,10 +2470,10 @@ function varsType(paths, file, dir, sharedFiles) {
   return parts.length > 0 ? parts.join("\n    & ") : "{}";
 }
 function inputType(paths, file, dir, sharedFiles) {
-  const typesDir = (0, import_node_path8.dirname)(file);
+  const typesDir = (0, import_node_path9.dirname)(file);
   const parts = [];
   if (dir !== paths.routesDir) {
-    parts.push(`import(${JSON.stringify(importPath(file, typeFilePath(paths, (0, import_node_path8.dirname)(dir))))}).Input`);
+    parts.push(`import(${JSON.stringify(importPath(file, typeFilePath(paths, (0, import_node_path9.dirname)(dir))))}).Input`);
   }
   const ownShared = ownSharedFile(dir, sharedFiles);
   if (ownShared) {
@@ -1471,7 +2496,7 @@ function methodExports(typesDir, verbs) {
 async function writeParamTypes(paths, folders) {
   await Promise.all(folders.map(({ dir, params, sharedFiles, verbs }) => {
     const file = typeFilePath(paths, dir);
-    const typesDir = (0, import_node_path8.dirname)(file);
+    const typesDir = (0, import_node_path9.dirname)(file);
     const lines = [
       GENERATED_HEADER,
       `export type Params = ${paramsType(params)};`,
@@ -1492,7 +2517,7 @@ async function writeParamTypes(paths, folders) {
 }
 
 // src/generator/route-meta.ts
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 var import_typescript2 = __toESM(require("typescript"));
 
 // src/generator/inputs.ts
@@ -1607,19 +2632,19 @@ function parseRouteOpenApi(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
   }
-  const o = value;
+  const o2 = value;
   const parsed = {};
-  if ("hidden" in o) {
-    parsed.hidden = Boolean(o.hidden);
+  if ("hidden" in o2) {
+    parsed.hidden = Boolean(o2.hidden);
   }
-  const tags = pick(StringArraySchema, o.tags);
+  const tags = pick(StringArraySchema, o2.tags);
   if (tags) {
     parsed.tags = tags;
   }
-  parsed.summary = pick(StringSchema, o.summary);
-  parsed.description = pick(StringSchema, o.description);
-  parsed.operationId = pick(StringSchema, o.operationId);
-  parsed.deprecated = pick(BooleanSchema, o.deprecated);
+  parsed.summary = pick(StringSchema, o2.summary);
+  parsed.description = pick(StringSchema, o2.description);
+  parsed.operationId = pick(StringSchema, o2.operationId);
+  parsed.deprecated = pick(BooleanSchema, o2.deprecated);
   return parsed;
 }
 
@@ -1802,7 +2827,7 @@ function parseStaticOpenApi(expression) {
 function readStaticModuleMeta(file) {
   let source;
   try {
-    source = import_typescript2.default.createSourceFile(file, (0, import_node_fs6.readFileSync)(file, "utf8"), import_typescript2.default.ScriptTarget.Latest, true);
+    source = import_typescript2.default.createSourceFile(file, (0, import_node_fs7.readFileSync)(file, "utf8"), import_typescript2.default.ScriptTarget.Latest, true);
   } catch {
     return void 0;
   }
@@ -2098,9 +3123,9 @@ async function extractRouteMeta(config, paths, routes) {
 }
 
 // src/generator/route-types.ts
-var import_node_path9 = require("path");
+var import_node_path10 = require("path");
 async function writeRouteTypes(paths, routes) {
-  const file = (0, import_node_path9.join)(paths.outDir, "routes.d.ts");
+  const file = (0, import_node_path10.join)(paths.outDir, "routes.d.ts");
   const lines = [
     GENERATED_HEADER,
     "export interface RouteParams {"
@@ -2118,19 +3143,19 @@ async function writeRouteTypes(paths, routes) {
 }
 
 // src/generator/tsconfig.ts
-var import_node_path10 = require("path");
+var import_node_path11 = require("path");
 function normalizeAlias(alias, paths) {
   const result = {};
   for (const [key, value] of Object.entries(alias ?? {})) {
     const targets = Array.isArray(value) ? value : [value];
     result[key] = targets.map(
-      (target) => relativeConfigPath(paths.outDir, (0, import_node_path10.resolve)(paths.cwd, target))
+      (target) => relativeConfigPath(paths.outDir, (0, import_node_path11.resolve)(paths.cwd, target))
     );
   }
   return result;
 }
 async function writeTsConfig(paths, config) {
-  const file = (0, import_node_path10.join)(paths.outDir, "tsconfig.json");
+  const file = (0, import_node_path11.join)(paths.outDir, "tsconfig.json");
   await writeJson(file, {
     compilerOptions: {
       rootDirs: [
@@ -2149,8 +3174,8 @@ async function writeTsConfig(paths, config) {
       ]
     },
     include: [
-      relativeConfigPath(paths.outDir, (0, import_node_path10.join)(paths.cwd, "src")),
-      relativeConfigPath(paths.outDir, (0, import_node_path10.join)(paths.cwd, "giri.config.ts")),
+      relativeConfigPath(paths.outDir, (0, import_node_path11.join)(paths.cwd, "src")),
+      relativeConfigPath(paths.outDir, (0, import_node_path11.join)(paths.cwd, "giri.config.ts")),
       "./types/**/*.d.ts"
     ]
   });
@@ -2158,9 +3183,9 @@ async function writeTsConfig(paths, config) {
 
 // src/generator/cache.ts
 var import_node_crypto = require("crypto");
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var import_promises3 = require("fs/promises");
-var import_node_path11 = require("path");
+var import_node_path12 = require("path");
 var import_tinyglobby2 = require("tinyglobby");
 var CACHE_VERSION = 1;
 var SYNC_CACHE_NAME = ".sync-cache.json";
@@ -2169,7 +3194,7 @@ function stableConfig(config) {
   return { alias, outDir: config.outDir ?? ".giri" };
 }
 async function syncFingerprint(config, paths) {
-  const outRelative = slash((0, import_node_path11.relative)(paths.cwd, paths.outDir));
+  const outRelative = slash((0, import_node_path12.relative)(paths.cwd, paths.outDir));
   const ignore = ["**/node_modules/**", "**/.git/**"];
   if (outRelative && !outRelative.startsWith("..")) {
     ignore.push(`${outRelative}/**`);
@@ -2198,18 +3223,18 @@ async function syncFingerprint(config, paths) {
     hash.update("\0");
     hash.update(slash(file));
     hash.update("\0");
-    hash.update(await (0, import_promises3.readFile)((0, import_node_path11.resolve)(paths.cwd, file)));
+    hash.update(await (0, import_promises3.readFile)((0, import_node_path12.resolve)(paths.cwd, file)));
   }
   return hash.digest("hex");
 }
 function cachePath(paths) {
-  return (0, import_node_path11.join)(paths.outDir, SYNC_CACHE_NAME);
+  return (0, import_node_path12.join)(paths.outDir, SYNC_CACHE_NAME);
 }
 function serializePath(paths, file) {
-  return slash((0, import_node_path11.relative)(paths.cwd, file));
+  return slash((0, import_node_path12.relative)(paths.cwd, file));
 }
 function deserializePath(paths, file) {
-  return slash((0, import_node_path11.resolve)(paths.cwd, file.split("/").join(import_node_path11.sep)));
+  return slash((0, import_node_path12.resolve)(paths.cwd, file.split("/").join(import_node_path12.sep)));
 }
 function serializeMap(paths, values) {
   return [...values].map(([file, value]) => [serializePath(paths, file), value]);
@@ -2219,7 +3244,7 @@ function deserializeMap(paths, values) {
 }
 async function readSyncCache(paths, fingerprint) {
   const file = cachePath(paths);
-  if (!(0, import_node_fs7.existsSync)(file)) {
+  if (!(0, import_node_fs8.existsSync)(file)) {
     return void 0;
   }
   try {
@@ -2279,8 +3304,8 @@ async function extractResponses(paths, routes) {
   try {
     const { createSchemaProgram: createSchemaProgram2, extractRouteResponses: extractRouteResponses2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
     const files = [...new Set(routes.map((route) => route.file))];
-    const appTypes = (0, import_node_path12.join)(paths.outDir, "types", "app.d.ts");
-    const roots = (0, import_node_fs8.existsSync)(appTypes) ? [...files, appTypes] : files;
+    const appTypes = (0, import_node_path13.join)(paths.outDir, "types", "app.d.ts");
+    const roots = (0, import_node_fs9.existsSync)(appTypes) ? [...files, appTypes] : files;
     const program = createSchemaProgram2(paths, roots);
     for (const file of files) {
       byFile.set(file, extractRouteResponses2(program, file));
@@ -2325,20 +3350,20 @@ async function extractMeta(config, paths, routes) {
 async function syncProject(config, options = {}) {
   const paths = resolveGiriPaths(config, options.cwd);
   assertSafeOutDir(paths);
-  const hadOutDir = (0, import_node_fs8.existsSync)(paths.outDir);
+  const hadOutDir = (0, import_node_fs9.existsSync)(paths.outDir);
   const routes = await scanRoutes(paths.routesDir);
   const folders = await typeFolders(paths, routes);
   const fingerprint = await syncFingerprint(config, paths);
   const cached = await readSyncCache(paths, fingerprint);
   const generatedFiles = [
-    (0, import_node_path12.join)(paths.outDir, "tsconfig.json"),
-    (0, import_node_path12.join)(paths.outDir, "manifest.json"),
-    (0, import_node_path12.join)(paths.outDir, "openapi.json"),
-    (0, import_node_path12.join)(paths.outDir, "routes.d.ts"),
-    (0, import_node_path12.join)(paths.outDir, "types", "app.d.ts"),
+    (0, import_node_path13.join)(paths.outDir, "tsconfig.json"),
+    (0, import_node_path13.join)(paths.outDir, "manifest.json"),
+    (0, import_node_path13.join)(paths.outDir, "openapi.json"),
+    (0, import_node_path13.join)(paths.outDir, "routes.d.ts"),
+    (0, import_node_path13.join)(paths.outDir, "types", "app.d.ts"),
     ...folders.map((folder) => typeFilePath(paths, folder.dir))
   ];
-  if (cached && generatedFiles.every(import_node_fs8.existsSync)) {
+  if (cached && generatedFiles.every(import_node_fs9.existsSync)) {
     return { paths, routes, folders, data: cached };
   }
   await (0, import_promises4.mkdir)(paths.outDir, { recursive: true });
@@ -2357,12 +3382,12 @@ async function syncProject(config, options = {}) {
     await pruneDir(
       paths.outDir,
       /* @__PURE__ */ new Set([
-        (0, import_node_path12.join)(paths.outDir, "tsconfig.json"),
-        (0, import_node_path12.join)(paths.outDir, "manifest.json"),
-        (0, import_node_path12.join)(paths.outDir, "openapi.json"),
-        (0, import_node_path12.join)(paths.outDir, "routes.d.ts"),
-        (0, import_node_path12.join)(paths.outDir, SYNC_CACHE_NAME),
-        (0, import_node_path12.join)(paths.outDir, "types", "app.d.ts"),
+        (0, import_node_path13.join)(paths.outDir, "tsconfig.json"),
+        (0, import_node_path13.join)(paths.outDir, "manifest.json"),
+        (0, import_node_path13.join)(paths.outDir, "openapi.json"),
+        (0, import_node_path13.join)(paths.outDir, "routes.d.ts"),
+        (0, import_node_path13.join)(paths.outDir, SYNC_CACHE_NAME),
+        (0, import_node_path13.join)(paths.outDir, "types", "app.d.ts"),
         ...folders.map((folder) => typeFilePath(paths, folder.dir))
       ])
     );
@@ -2371,30 +3396,30 @@ async function syncProject(config, options = {}) {
 }
 
 // src/generator/watch.ts
-var import_node_fs10 = require("fs");
-var import_node_path15 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_path16 = require("path");
 
 // src/loader/import-graph.ts
-var import_node_fs9 = require("fs");
-var import_node_path13 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path14 = require("path");
 var import_typescript6 = __toESM(require("typescript"));
 var import_tinyglobby3 = require("tinyglobby");
 var RESOLVE_EXTS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 var JS_EXT = /\.(?:c|m)?jsx?$/;
-var toSlash = (path) => path.split(import_node_path13.sep).join("/");
+var toSlash = (path) => path.split(import_node_path14.sep).join("/");
 function probeFile(base) {
-  if ((0, import_node_fs9.existsSync)(base) && (0, import_node_fs9.statSync)(base).isFile()) {
+  if ((0, import_node_fs10.existsSync)(base) && (0, import_node_fs10.statSync)(base).isFile()) {
     return base;
   }
   for (const ext of RESOLVE_EXTS) {
     const candidate = base + ext;
-    if ((0, import_node_fs9.existsSync)(candidate)) {
+    if ((0, import_node_fs10.existsSync)(candidate)) {
       return candidate;
     }
   }
   for (const ext of RESOLVE_EXTS) {
-    const candidate = (0, import_node_path13.join)(base, `index${ext}`);
-    if ((0, import_node_fs9.existsSync)(candidate)) {
+    const candidate = (0, import_node_path14.join)(base, `index${ext}`);
+    if ((0, import_node_fs10.existsSync)(candidate)) {
       return candidate;
     }
   }
@@ -2403,7 +3428,7 @@ function probeFile(base) {
 function resolveSpecifier(specifier, fromFile, alias, cwd) {
   let target;
   if (specifier.startsWith(".")) {
-    target = (0, import_node_path13.resolve)((0, import_node_path13.dirname)(fromFile), specifier);
+    target = (0, import_node_path14.resolve)((0, import_node_path14.dirname)(fromFile), specifier);
   } else {
     const aliased = resolveAliasRequest(specifier, alias, cwd);
     if (aliased === void 0) {
@@ -2423,7 +3448,7 @@ function resolveSpecifier(specifier, fromFile, alias, cwd) {
 function importSpecifiers(file) {
   let source;
   try {
-    source = import_typescript6.default.createSourceFile(file, (0, import_node_fs9.readFileSync)(file, "utf8"), import_typescript6.default.ScriptTarget.Latest, false);
+    source = import_typescript6.default.createSourceFile(file, (0, import_node_fs10.readFileSync)(file, "utf8"), import_typescript6.default.ScriptTarget.Latest, false);
   } catch {
     return [];
   }
@@ -2447,9 +3472,9 @@ function importSpecifiers(file) {
   return specifiers;
 }
 async function buildImportGraph(config, cwd) {
-  const root = (0, import_node_path13.resolve)(cwd);
-  const outDir = (0, import_node_path13.resolve)(root, config.outDir ?? ".giri") + import_node_path13.sep;
-  const outRel = (0, import_node_path13.relative)(root, outDir).split(import_node_path13.sep).join("/").replace(/\/$/, "");
+  const root = (0, import_node_path14.resolve)(cwd);
+  const outDir = (0, import_node_path14.resolve)(root, config.outDir ?? ".giri") + import_node_path14.sep;
+  const outRel = (0, import_node_path14.relative)(root, outDir).split(import_node_path14.sep).join("/").replace(/\/$/, "");
   const files = await (0, import_tinyglobby3.glob)("**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}", {
     cwd: root,
     absolute: true,
@@ -2483,10 +3508,10 @@ async function buildImportGraph(config, cwd) {
 }
 
 // src/loader/module-loader.ts
-var import_node_path14 = require("path");
-var toSlash2 = (path) => path.split(import_node_path14.sep).join("/");
+var import_node_path15 = require("path");
+var toSlash2 = (path) => path.split(import_node_path15.sep).join("/");
 var isProjectModule = (id, root) => {
-  return id.startsWith(root) && !id.includes(`${import_node_path14.sep}node_modules${import_node_path14.sep}`) && !id.includes(`${import_node_path14.sep}.giri${import_node_path14.sep}`);
+  return id.startsWith(root) && !id.includes(`${import_node_path15.sep}node_modules${import_node_path15.sep}`) && !id.includes(`${import_node_path15.sep}.giri${import_node_path15.sep}`);
 };
 var collectDependents = (graph, start) => {
   const out = /* @__PURE__ */ new Set([start]);
@@ -2510,7 +3535,7 @@ var purgeModules = (files) => {
   }
 };
 var purgeProjectModules = (cwd) => {
-  const root = (0, import_node_path14.resolve)(cwd) + import_node_path14.sep;
+  const root = (0, import_node_path15.resolve)(cwd) + import_node_path15.sep;
   for (const id of Object.keys(require.cache)) {
     if (isProjectModule(id, root)) {
       delete require.cache[id];
@@ -2518,9 +3543,9 @@ var purgeProjectModules = (cwd) => {
   }
 };
 var purgeGeneratedModules = (outDir) => {
-  const root = (0, import_node_path14.resolve)(outDir) + import_node_path14.sep;
+  const root = (0, import_node_path15.resolve)(outDir) + import_node_path15.sep;
   for (const id of Object.keys(require.cache)) {
-    if ((0, import_node_path14.resolve)(id).startsWith(root)) {
+    if ((0, import_node_path15.resolve)(id).startsWith(root)) {
       delete require.cache[id];
     }
   }
@@ -2551,11 +3576,11 @@ function createWatchUpdater(config, initial) {
     }
     try {
       const { createSchemaProgram: createSchemaProgram2, extractRouteResponses: extractRouteResponses2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
-      const appTypes = (0, import_node_path15.join)(paths.outDir, "types", "app.d.ts");
+      const appTypes = (0, import_node_path16.join)(paths.outDir, "types", "app.d.ts");
       const files = affected.map((route) => route.file);
       const program = createSchemaProgram2(
         paths,
-        (0, import_node_fs10.existsSync)(appTypes) ? [...files, appTypes] : files
+        (0, import_node_fs11.existsSync)(appTypes) ? [...files, appTypes] : files
       );
       for (const route of affected) {
         data.responsesByFile.set(
@@ -2596,12 +3621,12 @@ function createWatchUpdater(config, initial) {
       if (!filename) {
         return fullResync();
       }
-      const abs = (0, import_node_path15.resolve)((0, import_node_path15.dirname)(paths.routesDir), filename);
+      const abs = (0, import_node_path16.resolve)((0, import_node_path16.dirname)(paths.routesDir), filename);
       const file = slash(abs);
-      if (!(0, import_node_fs10.existsSync)(abs)) {
+      if (!(0, import_node_fs11.existsSync)(abs)) {
         return fullResync();
       }
-      if ((0, import_node_fs10.statSync)(abs).isDirectory()) {
+      if ((0, import_node_fs11.statSync)(abs).isDirectory()) {
         return "skip";
       }
       assertSourceSyntax(abs);
@@ -2609,8 +3634,8 @@ function createWatchUpdater(config, initial) {
       const isShared = routes.some(
         (route) => route.sharedFiles.some((shared) => slash(shared) === file)
       );
-      const isMethodFile = /^\+(?:get|post|put|patch|delete|options|head)\.(?:[cm]?[jt]s|[jt]sx)$/i.test((0, import_node_path15.basename)(file));
-      const isNewRouteStructure = file.startsWith(`${slash(paths.routesDir)}/`) && /^\+(?:get|post|put|patch|delete|options|head|shared)\.(?:[cm]?[jt]s|[jt]sx)$/i.test((0, import_node_path15.basename)(file)) && !isRoute && !isShared;
+      const isMethodFile = /^\+(?:get|post|put|patch|delete|options|head)\.(?:[cm]?[jt]s|[jt]sx)$/i.test((0, import_node_path16.basename)(file));
+      const isNewRouteStructure = file.startsWith(`${slash(paths.routesDir)}/`) && /^\+(?:get|post|put|patch|delete|options|head|shared)\.(?:[cm]?[jt]s|[jt]sx)$/i.test((0, import_node_path16.basename)(file)) && !isRoute && !isShared;
       if (isRoute || isNewRouteStructure && isMethodFile) {
         assertRouteHandleExport(abs);
       }
@@ -2646,20 +3671,20 @@ function createWatchUpdater(config, initial) {
 }
 
 // src/lifecycle.ts
-var import_node_fs11 = require("fs");
-var import_node_path16 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_path17 = require("path");
 var MAIN_EXTENSIONS2 = ["ts", "tsx", "mts", "cts", "js", "jsx", "mjs", "cjs"];
 function resolveMainFile(cwd) {
   for (const ext of MAIN_EXTENSIONS2) {
-    const file = (0, import_node_path16.join)(cwd, "src", `main.${ext}`);
-    if ((0, import_node_fs11.existsSync)(file)) {
+    const file = (0, import_node_path17.join)(cwd, "src", `main.${ext}`);
+    if ((0, import_node_fs12.existsSync)(file)) {
       return file;
     }
   }
   return void 0;
 }
 async function loadLifecycle(cwd = process.cwd()) {
-  const file = resolveMainFile((0, import_node_path16.resolve)(cwd));
+  const file = resolveMainFile((0, import_node_path17.resolve)(cwd));
   if (!file) {
     return {};
   }
@@ -2714,7 +3739,7 @@ var highlight = (text) => color.green(text);
 var muted = (text) => color.dim(text);
 function timestamp() {
   const now = /* @__PURE__ */ new Date();
-  const pad = (n) => String(n).padStart(2, "0");
+  const pad = (n2) => String(n2).padStart(2, "0");
   return `${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
 }
 var TAG = "giri";
@@ -2823,9 +3848,9 @@ function parseFlags(args) {
   return flags;
 }
 async function ensureGitignore(cwd) {
-  const file = (0, import_node_path17.join)(cwd, ".gitignore");
+  const file = (0, import_node_path18.join)(cwd, ".gitignore");
   const entry = ".giri";
-  if (!(0, import_node_fs12.existsSync)(file)) {
+  if (!(0, import_node_fs13.existsSync)(file)) {
     await (0, import_promises5.writeFile)(file, `${entry}
 `);
     return;
@@ -2837,8 +3862,8 @@ async function ensureGitignore(cwd) {
   }
 }
 async function ensureTsConfig(cwd) {
-  const file = (0, import_node_path17.join)(cwd, "tsconfig.json");
-  if ((0, import_node_fs12.existsSync)(file)) {
+  const file = (0, import_node_path18.join)(cwd, "tsconfig.json");
+  if ((0, import_node_fs13.existsSync)(file)) {
     return;
   }
   await (0, import_promises5.writeFile)(
@@ -2867,7 +3892,7 @@ async function ensureTsConfig(cwd) {
 async function missingDeps(cwd, candidates) {
   let pkg = {};
   try {
-    pkg = JSON.parse(await (0, import_promises5.readFile)((0, import_node_path17.join)(cwd, "package.json"), "utf8"));
+    pkg = JSON.parse(await (0, import_promises5.readFile)((0, import_node_path18.join)(cwd, "package.json"), "utf8"));
   } catch {
   }
   const present = /* @__PURE__ */ new Set();
@@ -2921,7 +3946,7 @@ async function selectAdapter(interactive) {
   if (!interactive || ADAPTERS.length === 1) {
     return ADAPTERS[0];
   }
-  const picked = await prompts.select({
+  const picked = await select({
     message: "Which backend adapter?",
     initialValue: "hono",
     options: ADAPTERS.map((adapter) => ({
@@ -2930,44 +3955,44 @@ async function selectAdapter(interactive) {
       hint: adapter.hint
     }))
   });
-  if (prompts.isCancel(picked)) {
+  if (isCancel(picked)) {
     return null;
   }
   return ADAPTERS.find((adapter) => adapter.value === picked) ?? null;
 }
 async function initProject(cwd, flags) {
-  if (!(0, import_node_fs12.existsSync)((0, import_node_path17.join)(cwd, "package.json"))) {
+  if (!(0, import_node_fs13.existsSync)((0, import_node_path18.join)(cwd, "package.json"))) {
     throw new Error(
       "No package.json found. Run `giri init` inside an existing project - set one up first (e.g. `npm init -y` and install typescript), then re-run."
     );
   }
   const interactive = Boolean(process.stdout.isTTY) && !flags.yes;
-  prompts.intro("giri init");
+  intro("giri init");
   let adapter;
   if (flags.adapter) {
     adapter = ADAPTERS.find((choice) => choice.value === flags.adapter) ?? null;
     if (!adapter) {
-      prompts.cancel(`Unknown adapter "${flags.adapter}". Available: ${ADAPTERS.map((a) => a.value).join(", ")}.`);
+      cancel(`Unknown adapter "${flags.adapter}". Available: ${ADAPTERS.map((a2) => a2.value).join(", ")}.`);
       return;
     }
   } else {
     adapter = await selectAdapter(interactive);
     if (!adapter) {
-      prompts.cancel("Cancelled.");
+      cancel("Cancelled.");
       return;
     }
   }
   if (!adapter.available) {
-    prompts.cancel(`The ${adapter.label} adapter isn't available yet - only Hono ships today.`);
+    cancel(`The ${adapter.label} adapter isn't available yet - only Hono ships today.`);
     return;
   }
-  const configPath = (0, import_node_path17.join)(cwd, "giri.config.ts");
-  if (!(0, import_node_fs12.existsSync)(configPath)) {
+  const configPath = (0, import_node_path18.join)(cwd, "giri.config.ts");
+  if (!(0, import_node_fs13.existsSync)(configPath)) {
     await (0, import_promises5.writeFile)(configPath, configSource(adapter));
   }
-  const routePath = (0, import_node_path17.join)(cwd, "src", "routes", "+get.ts");
-  if (!(0, import_node_fs12.existsSync)(routePath)) {
-    await (0, import_promises5.mkdir)((0, import_node_path17.join)(cwd, "src", "routes"), { recursive: true });
+  const routePath = (0, import_node_path18.join)(cwd, "src", "routes", "+get.ts");
+  if (!(0, import_node_fs13.existsSync)(routePath)) {
+    await (0, import_promises5.mkdir)((0, import_node_path18.join)(cwd, "src", "routes"), { recursive: true });
     await (0, import_promises5.writeFile)(
       routePath,
       [
@@ -2980,12 +4005,12 @@ async function initProject(cwd, flags) {
   }
   await ensureGitignore(cwd);
   await ensureTsConfig(cwd);
-  prompts.log.success(`scaffolded a ${adapter.label} project`);
+  log.success(`scaffolded a ${adapter.label} project`);
   const pm = flags.packageManager ?? detectPackageManager();
   const deps = await missingDeps(cwd, ["@boon4681/giri", ...adapter.deps, "zod"]);
   const devDeps = await missingDeps(cwd, ["typescript", "@types/node"]);
   if (deps.length === 0 && devDeps.length === 0) {
-    prompts.outro("All dependencies already present. Run `giri serve` to start the dev server.");
+    outro("All dependencies already present. Run `giri serve` to start the dev server.");
     return;
   }
   const planLines = [
@@ -2997,9 +4022,9 @@ async function initProject(cwd, flags) {
     if (!interactive) {
       install = flags.yes;
     } else {
-      const answer = await prompts.confirm({ message: `Install dependencies with ${pm}?` });
-      if (prompts.isCancel(answer)) {
-        prompts.cancel("Cancelled - files written, skipped install.");
+      const answer = await confirm({ message: `Install dependencies with ${pm}?` });
+      if (isCancel(answer)) {
+        cancel("Cancelled - files written, skipped install.");
         return;
       }
       install = answer;
@@ -3008,23 +4033,23 @@ async function initProject(cwd, flags) {
   if (install) {
     try {
       if (deps.length) {
-        prompts.log.step(`Installing ${deps.join(", ")}`);
+        log.step(`Installing ${deps.join(", ")}`);
         await runCommand(pm, installArgs(pm, deps, false), cwd);
       }
       if (devDeps.length) {
-        prompts.log.step(`Installing dev deps ${devDeps.join(", ")}`);
+        log.step(`Installing dev deps ${devDeps.join(", ")}`);
         await runCommand(pm, installArgs(pm, devDeps, true), cwd);
       }
     } catch (error) {
-      prompts.log.error(error instanceof Error ? error.message : String(error));
-      prompts.outro(`Install failed - run these yourself, then \`giri serve\`:
+      log.error(error instanceof Error ? error.message : String(error));
+      outro(`Install failed - run these yourself, then \`giri serve\`:
 ${planLines.join("\n")}`);
       return;
     }
-    prompts.outro("Ready. Run `giri serve` to start the dev server.");
+    outro("Ready. Run `giri serve` to start the dev server.");
     return;
   }
-  prompts.outro(`Next:
+  outro(`Next:
 ${planLines.join("\n")}
   giri serve`);
 }
@@ -3040,7 +4065,7 @@ async function serveProject(config, flags) {
   let stop;
   const boot = async (cfg) => {
     const closers = [];
-    closers.push(registerAliasResolver(cfg.alias, (0, import_node_path17.resolve)(process.cwd())));
+    closers.push(registerAliasResolver(cfg.alias, (0, import_node_path18.resolve)(process.cwd())));
     const lifecycle = await loadLifecycle();
     const sync = syncProject(cfg).then((initial2) => {
       log2.success(
@@ -3061,8 +4086,8 @@ async function serveProject(config, flags) {
     const port = flags.port ?? cfg.server?.port ?? 3e3;
     const hostname = flags.hostname ?? cfg.server?.hostname;
     if (flags.watch) {
-      const srcDir = (0, import_node_path17.resolve)(current.paths.routesDir, "..");
-      if ((0, import_node_fs12.existsSync)(srcDir)) {
+      const srcDir = (0, import_node_path18.resolve)(current.paths.routesDir, "..");
+      if ((0, import_node_fs13.existsSync)(srcDir)) {
         let timer;
         let syncing = false;
         const changed = /* @__PURE__ */ new Set();
@@ -3094,7 +4119,7 @@ async function serveProject(config, flags) {
                 }
                 rebuild = true;
                 if (name) {
-                  dirtySet.add((0, import_node_path17.resolve)(srcDir, name));
+                  dirtySet.add((0, import_node_path18.resolve)(srcDir, name));
                 }
                 const rel = name ? `src/${name.replace(/\\/g, "/")}` : "src";
                 log2.change(outcome === "full" ? "sync" : "update", rel, bump(rel));
@@ -3124,7 +4149,7 @@ async function serveProject(config, flags) {
         };
         const watcher = watch(srcDir, { persistent: true, ignoreInitial: true });
         const onFileChange = (filename) => {
-          changed.add((0, import_node_path17.isAbsolute)(filename) ? (0, import_node_path17.relative)(srcDir, filename) : filename);
+          changed.add((0, import_node_path18.isAbsolute)(filename) ? (0, import_node_path18.relative)(srcDir, filename) : filename);
           clearTimeout(timer);
           timer = setTimeout(() => void flush(), 150);
         };
@@ -3155,11 +4180,11 @@ async function serveProject(config, flags) {
     };
   };
   await boot(config);
-  const configPath = flags.watch ? findConfigPath((0, import_node_path17.resolve)(process.cwd())) : void 0;
+  const configPath = flags.watch ? findConfigPath((0, import_node_path18.resolve)(process.cwd())) : void 0;
   if (configPath) {
     let timer;
     let restarting = false;
-    const configName = (0, import_node_path17.basename)(configPath);
+    const configName = (0, import_node_path18.basename)(configPath);
     const restart = async () => {
       if (restarting) {
         return;
@@ -3207,7 +4232,7 @@ function registerShutdown(cleanup) {
 }
 async function main() {
   const [command = "help", ...args] = process.argv.slice(2);
-  const cwd = (0, import_node_path17.resolve)(process.cwd());
+  const cwd = (0, import_node_path18.resolve)(process.cwd());
   if (command === "help" || command === "--help" || command === "-h") {
     help();
     return;