@apps-in-toss/web-framework 0.0.8 → 0.0.10

package/dist/cli.js

@@ -2,3554 +2,508 @@ import { createRequire } from 'module'; const require = createRequire(import.met
 import {
   __dirname,
   __require,
-  init_esm_shims
-} from "./chunk-MHAJE5QI.js";
+  loadConfig
+} from "./chunk-HL7M3JLX.js";
 
 // src/cli.ts
-init_esm_shims();
+import { Cli } from "clipanion";
 
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/index.mjs
-init_esm_shims();
+// src/BuildCommand/BuildCommand.ts
+import { Command, Option } from "clipanion";
+import picocolors from "picocolors";
 
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/Command.mjs
-init_esm_shims();
-
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/options/utils.mjs
-init_esm_shims();
-
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/errors.mjs
-init_esm_shims();
-
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/constants.mjs
-init_esm_shims();
-var SpecialToken;
-(function(SpecialToken2) {
-  SpecialToken2["StartOfInput"] = "\0";
-  SpecialToken2["EndOfInput"] = "
";
-  SpecialToken2["EndOfPartialInput"] = "";
-})(SpecialToken || (SpecialToken = {}));
-var NodeType;
-(function(NodeType2) {
-  NodeType2[NodeType2["InitialNode"] = 0] = "InitialNode";
-  NodeType2[NodeType2["SuccessNode"] = 1] = "SuccessNode";
-  NodeType2[NodeType2["ErrorNode"] = 2] = "ErrorNode";
-  NodeType2[NodeType2["CustomNode"] = 3] = "CustomNode";
-})(NodeType || (NodeType = {}));
-var HELP_COMMAND_INDEX = -1;
-var HELP_REGEX = /^(-h|--help)(?:=([0-9]+))?$/;
-var OPTION_REGEX = /^(--[a-z]+(?:-[a-z]+)*|-[a-zA-Z]+)$/;
-var BATCH_REGEX = /^-[a-zA-Z]{2,}$/;
-var BINDING_REGEX = /^([^=]+)=([\s\S]*)$/;
-var IS_DEBUG = process.env.DEBUG_CLI === `1`;
-
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/errors.mjs
-var UsageError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.clipanion = { type: `usage` };
-    this.name = `UsageError`;
-  }
-};
-var UnknownSyntaxError = class extends Error {
-  constructor(input, candidates) {
-    super();
-    this.input = input;
-    this.candidates = candidates;
-    this.clipanion = { type: `none` };
-    this.name = `UnknownSyntaxError`;
-    if (this.candidates.length === 0) {
-      this.message = `Command not found, but we're not sure what's the alternative.`;
-    } else if (this.candidates.every((candidate) => candidate.reason !== null && candidate.reason === candidates[0].reason)) {
-      const [{ reason }] = this.candidates;
-      this.message = `${reason}
-
-${this.candidates.map(({ usage }) => `$ ${usage}`).join(`
-`)}`;
-    } else if (this.candidates.length === 1) {
-      const [{ usage }] = this.candidates;
-      this.message = `Command not found; did you mean:
-
-$ ${usage}
-${whileRunning(input)}`;
-    } else {
-      this.message = `Command not found; did you mean one of:
-
-${this.candidates.map(({ usage }, index) => {
-        return `${`${index}.`.padStart(4)} ${usage}`;
-      }).join(`
-`)}
-
-${whileRunning(input)}`;
-    }
-  }
-};
-var AmbiguousSyntaxError = class extends Error {
-  constructor(input, usages) {
-    super();
-    this.input = input;
-    this.usages = usages;
-    this.clipanion = { type: `none` };
-    this.name = `AmbiguousSyntaxError`;
-    this.message = `Cannot find which to pick amongst the following alternatives:
-
-${this.usages.map((usage, index) => {
-      return `${`${index}.`.padStart(4)} ${usage}`;
-    }).join(`
-`)}
-
-${whileRunning(input)}`;
-  }
-};
-var whileRunning = (input) => `While running ${input.filter((token) => {
-  return token !== SpecialToken.EndOfInput && token !== SpecialToken.EndOfPartialInput;
-}).map((token) => {
-  const json = JSON.stringify(token);
-  if (token.match(/\s/) || token.length === 0 || json !== `"${token}"`) {
-    return json;
-  } else {
-    return token;
-  }
-}).join(` `)}`;
-
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/options/utils.mjs
-var isOptionSymbol = Symbol(`clipanion/isOption`);
-function cleanValidationError(message, { mergeName = false } = {}) {
-  const match = message.match(/^([^:]+): (.*)$/m);
-  if (!match)
-    return `validation failed`;
-  let [, path2, line] = match;
-  if (mergeName)
-    line = line[0].toLowerCase() + line.slice(1);
-  line = path2 !== `.` || !mergeName ? `${path2.replace(/^\.(\[|$)/, `$1`)}: ${line}` : `: ${line}`;
-  return line;
-}
-function formatError(message, errors) {
-  if (errors.length === 1) {
-    return new UsageError(`${message}${cleanValidationError(errors[0], { mergeName: true })}`);
-  } else {
-    return new UsageError(`${message}:
-${errors.map((error) => `
-- ${cleanValidationError(error)}`).join(``)}`);
-  }
-}
-
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/Command.mjs
-var Command = class {
-  constructor() {
-    this.help = false;
-  }
-  /**
-   * Defines the usage information for the given command.
-   */
-  static Usage(usage) {
-    return usage;
-  }
-  /**
-   * Standard error handler which will simply rethrow the error. Can be used
-   * to add custom logic to handle errors from the command or simply return
-   * the parent class error handling.
-   */
-  async catch(error) {
-    throw error;
-  }
-  async validateAndExecute() {
-    const commandClass = this.constructor;
-    const cascade = commandClass.schema;
-    if (Array.isArray(cascade)) {
-      const { isDict, isUnknown, applyCascade } = await import("./lib-OD73GAMK.js");
-      const schema = applyCascade(isDict(isUnknown()), cascade);
-      const errors = [];
-      const coercions = [];
-      const check = schema(this, { errors, coercions });
-      if (!check)
-        throw formatError(`Invalid option schema`, errors);
-      for (const [, op] of coercions) {
-        op();
-      }
-    } else if (cascade != null) {
-      throw new Error(`Invalid command schema`);
-    }
-    const exitCode = await this.execute();
-    if (typeof exitCode !== `undefined`) {
-      return exitCode;
-    } else {
-      return 0;
-    }
-  }
-};
-Command.isOption = isOptionSymbol;
-Command.Default = [];
-
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/Cli.mjs
-init_esm_shims();
-
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/platform/node.mjs
-init_esm_shims();
-import tty from "tty";
-function getDefaultColorDepth() {
-  if (tty && `getColorDepth` in tty.WriteStream.prototype)
-    return tty.WriteStream.prototype.getColorDepth();
-  if (process.env.FORCE_COLOR === `0`)
-    return 1;
-  if (process.env.FORCE_COLOR === `1`)
-    return 8;
-  if (typeof process.stdout !== `undefined` && process.stdout.isTTY)
-    return 8;
-  return 1;
-}
-var gContextStorage;
-function getCaptureActivator(context) {
-  let contextStorage = gContextStorage;
-  if (typeof contextStorage === `undefined`) {
-    if (context.stdout === process.stdout && context.stderr === process.stderr)
-      return null;
-    const { AsyncLocalStorage: LazyAsyncLocalStorage } = __require("async_hooks");
-    contextStorage = gContextStorage = new LazyAsyncLocalStorage();
-    const origStdoutWrite = process.stdout._write;
-    process.stdout._write = function(chunk, encoding, cb) {
-      const context2 = contextStorage.getStore();
-      if (typeof context2 === `undefined`)
-        return origStdoutWrite.call(this, chunk, encoding, cb);
-      return context2.stdout.write(chunk, encoding, cb);
-    };
-    const origStderrWrite = process.stderr._write;
-    process.stderr._write = function(chunk, encoding, cb) {
-      const context2 = contextStorage.getStore();
-      if (typeof context2 === `undefined`)
-        return origStderrWrite.call(this, chunk, encoding, cb);
-      return context2.stderr.write(chunk, encoding, cb);
-    };
-  }
-  return (fn) => {
-    return contextStorage.run(context, fn);
-  };
-}
-
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/core.mjs
-init_esm_shims();
-function debug(str) {
-  if (IS_DEBUG) {
-    console.log(str);
-  }
-}
-var basicHelpState = {
-  candidateUsage: null,
-  requiredOptions: [],
-  errorMessage: null,
-  ignoreOptions: false,
-  path: [],
-  positionals: [],
-  options: [],
-  remainder: null,
-  selectedIndex: HELP_COMMAND_INDEX,
-  tokens: []
-};
-function makeStateMachine() {
-  const stateMachine = {
-    nodes: []
-  };
-  for (let t = 0; t < NodeType.CustomNode; ++t)
-    stateMachine.nodes.push(makeNode());
-  return stateMachine;
-}
-function makeAnyOfMachine(inputs) {
-  const output = makeStateMachine();
-  const heads = [];
-  let offset = output.nodes.length;
-  for (const input of inputs) {
-    heads.push(offset);
-    for (let t = 0; t < input.nodes.length; ++t)
-      if (!isTerminalNode(t))
-        output.nodes.push(cloneNode(input.nodes[t], offset));
-    offset += input.nodes.length - NodeType.CustomNode + 1;
-  }
-  for (const head of heads)
-    registerShortcut(output, NodeType.InitialNode, head);
-  return output;
-}
-function injectNode(machine, node) {
-  machine.nodes.push(node);
-  return machine.nodes.length - 1;
-}
-function simplifyMachine(input) {
-  const visited = /* @__PURE__ */ new Set();
-  const process2 = (node) => {
-    if (visited.has(node))
-      return;
-    visited.add(node);
-    const nodeDef = input.nodes[node];
-    for (const transitions of Object.values(nodeDef.statics))
-      for (const { to } of transitions)
-        process2(to);
-    for (const [, { to }] of nodeDef.dynamics)
-      process2(to);
-    for (const { to } of nodeDef.shortcuts)
-      process2(to);
-    const shortcuts = new Set(nodeDef.shortcuts.map(({ to }) => to));
-    while (nodeDef.shortcuts.length > 0) {
-      const { to } = nodeDef.shortcuts.shift();
-      const toDef = input.nodes[to];
-      for (const [segment, transitions] of Object.entries(toDef.statics)) {
-        const store = !Object.prototype.hasOwnProperty.call(nodeDef.statics, segment) ? nodeDef.statics[segment] = [] : nodeDef.statics[segment];
-        for (const transition of transitions) {
-          if (!store.some(({ to: to2 }) => transition.to === to2)) {
-            store.push(transition);
-          }
-        }
-      }
-      for (const [test, transition] of toDef.dynamics)
-        if (!nodeDef.dynamics.some(([otherTest, { to: to2 }]) => test === otherTest && transition.to === to2))
-          nodeDef.dynamics.push([test, transition]);
-      for (const transition of toDef.shortcuts) {
-        if (!shortcuts.has(transition.to)) {
-          nodeDef.shortcuts.push(transition);
-          shortcuts.add(transition.to);
-        }
-      }
-    }
-  };
-  process2(NodeType.InitialNode);
-}
-function debugMachine(machine, { prefix = `` } = {}) {
-  if (IS_DEBUG) {
-    debug(`${prefix}Nodes are:`);
-    for (let t = 0; t < machine.nodes.length; ++t) {
-      debug(`${prefix}  ${t}: ${JSON.stringify(machine.nodes[t])}`);
-    }
-  }
-}
-function runMachineInternal(machine, input, partial = false) {
-  debug(`Running a vm on ${JSON.stringify(input)}`);
-  let branches = [{
-    node: NodeType.InitialNode,
-    state: {
-      candidateUsage: null,
-      requiredOptions: [],
-      errorMessage: null,
-      ignoreOptions: false,
-      options: [],
-      path: [],
-      positionals: [],
-      remainder: null,
-      selectedIndex: null,
-      tokens: []
-    }
-  }];
-  debugMachine(machine, { prefix: `  ` });
-  const tokens = [SpecialToken.StartOfInput, ...input];
-  for (let t = 0; t < tokens.length; ++t) {
-    const segment = tokens[t];
-    const isEOI = segment === SpecialToken.EndOfInput || segment === SpecialToken.EndOfPartialInput;
-    const segmentIndex = t - 1;
-    debug(`  Processing ${JSON.stringify(segment)}`);
-    const nextBranches = [];
-    for (const { node, state } of branches) {
-      debug(`    Current node is ${node}`);
-      const nodeDef = machine.nodes[node];
-      if (node === NodeType.ErrorNode) {
-        nextBranches.push({ node, state });
-        continue;
-      }
-      console.assert(nodeDef.shortcuts.length === 0, `Shortcuts should have been eliminated by now`);
-      const hasExactMatch = Object.prototype.hasOwnProperty.call(nodeDef.statics, segment);
-      if (!partial || t < tokens.length - 1 || hasExactMatch) {
-        if (hasExactMatch) {
-          const transitions = nodeDef.statics[segment];
-          for (const { to, reducer } of transitions) {
-            nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment, segmentIndex) : state });
-            debug(`      Static transition to ${to} found`);
-          }
-        } else {
-          debug(`      No static transition found`);
-        }
-      } else {
-        let hasMatches = false;
-        for (const candidate of Object.keys(nodeDef.statics)) {
-          if (!candidate.startsWith(segment))
-            continue;
-          if (segment === candidate) {
-            for (const { to, reducer } of nodeDef.statics[candidate]) {
-              nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment, segmentIndex) : state });
-              debug(`      Static transition to ${to} found`);
-            }
-          } else {
-            for (const { to } of nodeDef.statics[candidate]) {
-              nextBranches.push({ node: to, state: { ...state, remainder: candidate.slice(segment.length) } });
-              debug(`      Static transition to ${to} found (partial match)`);
-            }
-          }
-          hasMatches = true;
-        }
-        if (!hasMatches) {
-          debug(`      No partial static transition found`);
-        }
-      }
-      if (!isEOI) {
-        for (const [test, { to, reducer }] of nodeDef.dynamics) {
-          if (execute(tests, test, state, segment, segmentIndex)) {
-            nextBranches.push({ node: to, state: typeof reducer !== `undefined` ? execute(reducers, reducer, state, segment, segmentIndex) : state });
-            debug(`      Dynamic transition to ${to} found (via ${test})`);
-          }
-        }
-      }
-    }
-    if (nextBranches.length === 0 && isEOI && input.length === 1) {
-      return [{
-        node: NodeType.InitialNode,
-        state: basicHelpState
-      }];
-    }
-    if (nextBranches.length === 0) {
-      throw new UnknownSyntaxError(input, branches.filter(({ node }) => {
-        return node !== NodeType.ErrorNode;
-      }).map(({ state }) => {
-        return { usage: state.candidateUsage, reason: null };
-      }));
-    }
-    if (nextBranches.every(({ node }) => node === NodeType.ErrorNode)) {
-      throw new UnknownSyntaxError(input, nextBranches.map(({ state }) => {
-        return { usage: state.candidateUsage, reason: state.errorMessage };
-      }));
-    }
-    branches = trimSmallerBranches(nextBranches);
-  }
-  if (branches.length > 0) {
-    debug(`  Results:`);
-    for (const branch of branches) {
-      debug(`    - ${branch.node} -> ${JSON.stringify(branch.state)}`);
-    }
-  } else {
-    debug(`  No results`);
-  }
-  return branches;
-}
-function runMachine(machine, input, { endToken = SpecialToken.EndOfInput } = {}) {
-  const branches = runMachineInternal(machine, [...input, endToken]);
-  return selectBestState(input, branches.map(({ state }) => {
-    return state;
-  }));
-}
-function trimSmallerBranches(branches) {
-  let maxPathSize = 0;
-  for (const { state } of branches)
-    if (state.path.length > maxPathSize)
-      maxPathSize = state.path.length;
-  return branches.filter(({ state }) => {
-    return state.path.length === maxPathSize;
-  });
-}
-function selectBestState(input, states) {
-  const terminalStates = states.filter((state) => {
-    return state.selectedIndex !== null;
-  });
-  if (terminalStates.length === 0)
-    throw new Error();
-  const requiredOptionsSetStates = terminalStates.filter((state) => state.selectedIndex === HELP_COMMAND_INDEX || state.requiredOptions.every((names) => names.some((name) => state.options.find((opt) => opt.name === name))));
-  if (requiredOptionsSetStates.length === 0) {
-    throw new UnknownSyntaxError(input, terminalStates.map((state) => ({
-      usage: state.candidateUsage,
-      reason: null
-    })));
-  }
-  let maxPathSize = 0;
-  for (const state of requiredOptionsSetStates)
-    if (state.path.length > maxPathSize)
-      maxPathSize = state.path.length;
-  const bestPathBranches = requiredOptionsSetStates.filter((state) => {
-    return state.path.length === maxPathSize;
-  });
-  const getPositionalCount = (state) => state.positionals.filter(({ extra }) => {
-    return !extra;
-  }).length + state.options.length;
-  const statesWithPositionalCount = bestPathBranches.map((state) => {
-    return { state, positionalCount: getPositionalCount(state) };
-  });
-  let maxPositionalCount = 0;
-  for (const { positionalCount } of statesWithPositionalCount)
-    if (positionalCount > maxPositionalCount)
-      maxPositionalCount = positionalCount;
-  const bestPositionalStates = statesWithPositionalCount.filter(({ positionalCount }) => {
-    return positionalCount === maxPositionalCount;
-  }).map(({ state }) => {
-    return state;
-  });
-  const fixedStates = aggregateHelpStates(bestPositionalStates);
-  if (fixedStates.length > 1)
-    throw new AmbiguousSyntaxError(input, fixedStates.map((state) => state.candidateUsage));
-  return fixedStates[0];
-}
-function aggregateHelpStates(states) {
-  const notHelps = [];
-  const helps = [];
-  for (const state of states) {
-    if (state.selectedIndex === HELP_COMMAND_INDEX) {
-      helps.push(state);
-    } else {
-      notHelps.push(state);
-    }
-  }
-  if (helps.length > 0) {
-    notHelps.push({
-      ...basicHelpState,
-      path: findCommonPrefix(...helps.map((state) => state.path)),
-      options: helps.reduce((options, state) => options.concat(state.options), [])
-    });
-  }
-  return notHelps;
-}
-function findCommonPrefix(firstPath, secondPath, ...rest) {
-  if (secondPath === void 0)
-    return Array.from(firstPath);
-  return findCommonPrefix(firstPath.filter((segment, i) => segment === secondPath[i]), ...rest);
-}
-function makeNode() {
-  return {
-    dynamics: [],
-    shortcuts: [],
-    statics: {}
-  };
-}
-function isTerminalNode(node) {
-  return node === NodeType.SuccessNode || node === NodeType.ErrorNode;
-}
-function cloneTransition(input, offset = 0) {
-  const to = !isTerminalNode(input.to) ? input.to >= NodeType.CustomNode ? input.to + offset - NodeType.CustomNode + 1 : input.to + offset : input.to;
-  return {
-    to,
-    reducer: input.reducer
-  };
-}
-function cloneNode(input, offset = 0) {
-  const output = makeNode();
-  for (const [test, transition] of input.dynamics)
-    output.dynamics.push([test, cloneTransition(transition, offset)]);
-  for (const transition of input.shortcuts)
-    output.shortcuts.push(cloneTransition(transition, offset));
-  for (const [segment, transitions] of Object.entries(input.statics))
-    output.statics[segment] = transitions.map((transition) => cloneTransition(transition, offset));
-  return output;
-}
-function registerDynamic(machine, from, test, to, reducer) {
-  machine.nodes[from].dynamics.push([
-    test,
-    { to, reducer }
-  ]);
-}
-function registerShortcut(machine, from, to, reducer) {
-  machine.nodes[from].shortcuts.push({ to, reducer });
-}
-function registerStatic(machine, from, test, to, reducer) {
-  const store = !Object.prototype.hasOwnProperty.call(machine.nodes[from].statics, test) ? machine.nodes[from].statics[test] = [] : machine.nodes[from].statics[test];
-  store.push({ to, reducer });
-}
-function execute(store, callback, state, segment, segmentIndex) {
-  if (Array.isArray(callback)) {
-    const [name, ...args] = callback;
-    return store[name](state, segment, segmentIndex, ...args);
-  } else {
-    return store[callback](state, segment, segmentIndex);
-  }
-}
-var tests = {
-  always: () => {
-    return true;
-  },
-  isOptionLike: (state, segment) => {
-    return !state.ignoreOptions && (segment !== `-` && segment.startsWith(`-`));
-  },
-  isNotOptionLike: (state, segment) => {
-    return state.ignoreOptions || segment === `-` || !segment.startsWith(`-`);
-  },
-  isOption: (state, segment, segmentIndex, name) => {
-    return !state.ignoreOptions && segment === name;
-  },
-  isBatchOption: (state, segment, segmentIndex, names) => {
-    return !state.ignoreOptions && BATCH_REGEX.test(segment) && [...segment.slice(1)].every((name) => names.has(`-${name}`));
-  },
-  isBoundOption: (state, segment, segmentIndex, names, options) => {
-    const optionParsing = segment.match(BINDING_REGEX);
-    return !state.ignoreOptions && !!optionParsing && OPTION_REGEX.test(optionParsing[1]) && names.has(optionParsing[1]) && options.filter((opt) => opt.nameSet.includes(optionParsing[1])).every((opt) => opt.allowBinding);
-  },
-  isNegatedOption: (state, segment, segmentIndex, name) => {
-    return !state.ignoreOptions && segment === `--no-${name.slice(2)}`;
-  },
-  isHelp: (state, segment) => {
-    return !state.ignoreOptions && HELP_REGEX.test(segment);
-  },
-  isUnsupportedOption: (state, segment, segmentIndex, names) => {
-    return !state.ignoreOptions && segment.startsWith(`-`) && OPTION_REGEX.test(segment) && !names.has(segment);
-  },
-  isInvalidOption: (state, segment) => {
-    return !state.ignoreOptions && segment.startsWith(`-`) && !OPTION_REGEX.test(segment);
-  }
-};
-var reducers = {
-  setCandidateState: (state, segment, segmentIndex, candidateState) => {
-    return { ...state, ...candidateState };
-  },
-  setSelectedIndex: (state, segment, segmentIndex, index) => {
-    return { ...state, selectedIndex: index };
-  },
-  pushBatch: (state, segment, segmentIndex, names) => {
-    const options = state.options.slice();
-    const tokens = state.tokens.slice();
-    for (let t = 1; t < segment.length; ++t) {
-      const name = names.get(`-${segment[t]}`);
-      const slice = t === 1 ? [0, 2] : [t, t + 1];
-      options.push({ name, value: true });
-      tokens.push({ segmentIndex, type: `option`, option: name, slice });
-    }
-    return { ...state, options, tokens };
-  },
-  pushBound: (state, segment, segmentIndex) => {
-    const [, name, value] = segment.match(BINDING_REGEX);
-    const options = state.options.concat({ name, value });
-    const tokens = state.tokens.concat([
-      { segmentIndex, type: `option`, slice: [0, name.length], option: name },
-      { segmentIndex, type: `assign`, slice: [name.length, name.length + 1] },
-      { segmentIndex, type: `value`, slice: [name.length + 1, name.length + value.length + 1] }
-    ]);
-    return { ...state, options, tokens };
-  },
-  pushPath: (state, segment, segmentIndex) => {
-    const path2 = state.path.concat(segment);
-    const tokens = state.tokens.concat({ segmentIndex, type: `path` });
-    return { ...state, path: path2, tokens };
-  },
-  pushPositional: (state, segment, segmentIndex) => {
-    const positionals = state.positionals.concat({ value: segment, extra: false });
-    const tokens = state.tokens.concat({ segmentIndex, type: `positional` });
-    return { ...state, positionals, tokens };
-  },
-  pushExtra: (state, segment, segmentIndex) => {
-    const positionals = state.positionals.concat({ value: segment, extra: true });
-    const tokens = state.tokens.concat({ segmentIndex, type: `positional` });
-    return { ...state, positionals, tokens };
-  },
-  pushExtraNoLimits: (state, segment, segmentIndex) => {
-    const positionals = state.positionals.concat({ value: segment, extra: NoLimits });
-    const tokens = state.tokens.concat({ segmentIndex, type: `positional` });
-    return { ...state, positionals, tokens };
-  },
-  pushTrue: (state, segment, segmentIndex, name) => {
-    const options = state.options.concat({ name, value: true });
-    const tokens = state.tokens.concat({ segmentIndex, type: `option`, option: name });
-    return { ...state, options, tokens };
-  },
-  pushFalse: (state, segment, segmentIndex, name) => {
-    const options = state.options.concat({ name, value: false });
-    const tokens = state.tokens.concat({ segmentIndex, type: `option`, option: name });
-    return { ...state, options, tokens };
-  },
-  pushUndefined: (state, segment, segmentIndex, name) => {
-    const options = state.options.concat({ name: segment, value: void 0 });
-    const tokens = state.tokens.concat({ segmentIndex, type: `option`, option: segment });
-    return { ...state, options, tokens };
-  },
-  pushStringValue: (state, segment, segmentIndex) => {
-    var _a;
-    const lastOption = state.options[state.options.length - 1];
-    const options = state.options.slice();
-    const tokens = state.tokens.concat({ segmentIndex, type: `value` });
-    lastOption.value = ((_a = lastOption.value) !== null && _a !== void 0 ? _a : []).concat([segment]);
-    return { ...state, options, tokens };
-  },
-  setStringValue: (state, segment, segmentIndex) => {
-    const lastOption = state.options[state.options.length - 1];
-    const options = state.options.slice();
-    const tokens = state.tokens.concat({ segmentIndex, type: `value` });
-    lastOption.value = segment;
-    return { ...state, options, tokens };
-  },
-  inhibateOptions: (state) => {
-    return { ...state, ignoreOptions: true };
-  },
-  useHelp: (state, segment, segmentIndex, command) => {
-    const [
-      ,
-      /* name */
-      ,
-      index
-    ] = segment.match(HELP_REGEX);
-    if (typeof index !== `undefined`) {
-      return { ...state, options: [{ name: `-c`, value: String(command) }, { name: `-i`, value: index }] };
-    } else {
-      return { ...state, options: [{ name: `-c`, value: String(command) }] };
-    }
-  },
-  setError: (state, segment, segmentIndex, errorMessage) => {
-    if (segment === SpecialToken.EndOfInput || segment === SpecialToken.EndOfPartialInput) {
-      return { ...state, errorMessage: `${errorMessage}.` };
-    } else {
-      return { ...state, errorMessage: `${errorMessage} ("${segment}").` };
-    }
-  },
-  setOptionArityError: (state, segment) => {
-    const lastOption = state.options[state.options.length - 1];
-    return { ...state, errorMessage: `Not enough arguments to option ${lastOption.name}.` };
-  }
-};
-var NoLimits = Symbol();
-var CommandBuilder = class {
-  constructor(cliIndex, cliOpts) {
-    this.allOptionNames = /* @__PURE__ */ new Map();
-    this.arity = { leading: [], trailing: [], extra: [], proxy: false };
-    this.options = [];
-    this.paths = [];
-    this.cliIndex = cliIndex;
-    this.cliOpts = cliOpts;
-  }
-  addPath(path2) {
-    this.paths.push(path2);
-  }
-  setArity({ leading = this.arity.leading, trailing = this.arity.trailing, extra = this.arity.extra, proxy = this.arity.proxy }) {
-    Object.assign(this.arity, { leading, trailing, extra, proxy });
-  }
-  addPositional({ name = `arg`, required = true } = {}) {
-    if (!required && this.arity.extra === NoLimits)
-      throw new Error(`Optional parameters cannot be declared when using .rest() or .proxy()`);
-    if (!required && this.arity.trailing.length > 0)
-      throw new Error(`Optional parameters cannot be declared after the required trailing positional arguments`);
-    if (!required && this.arity.extra !== NoLimits) {
-      this.arity.extra.push(name);
-    } else if (this.arity.extra !== NoLimits && this.arity.extra.length === 0) {
-      this.arity.leading.push(name);
-    } else {
-      this.arity.trailing.push(name);
-    }
-  }
-  addRest({ name = `arg`, required = 0 } = {}) {
-    if (this.arity.extra === NoLimits)
-      throw new Error(`Infinite lists cannot be declared multiple times in the same command`);
-    if (this.arity.trailing.length > 0)
-      throw new Error(`Infinite lists cannot be declared after the required trailing positional arguments`);
-    for (let t = 0; t < required; ++t)
-      this.addPositional({ name });
-    this.arity.extra = NoLimits;
-  }
-  addProxy({ required = 0 } = {}) {
-    this.addRest({ required });
-    this.arity.proxy = true;
-  }
-  addOption({ names: nameSet, description, arity = 0, hidden = false, required = false, allowBinding = true }) {
-    if (!allowBinding && arity > 1)
-      throw new Error(`The arity cannot be higher than 1 when the option only supports the --arg=value syntax`);
-    if (!Number.isInteger(arity))
-      throw new Error(`The arity must be an integer, got ${arity}`);
-    if (arity < 0)
-      throw new Error(`The arity must be positive, got ${arity}`);
-    const preferredName = nameSet.reduce((longestName, name) => {
-      return name.length > longestName.length ? name : longestName;
-    }, ``);
-    for (const name of nameSet)
-      this.allOptionNames.set(name, preferredName);
-    this.options.push({ preferredName, nameSet, description, arity, hidden, required, allowBinding });
-  }
-  setContext(context) {
-    this.context = context;
-  }
-  usage({ detailed = true, inlineOptions = true } = {}) {
-    const segments = [this.cliOpts.binaryName];
-    const detailedOptionList = [];
-    if (this.paths.length > 0)
-      segments.push(...this.paths[0]);
-    if (detailed) {
-      for (const { preferredName, nameSet, arity, hidden, description, required } of this.options) {
-        if (hidden)
-          continue;
-        const args = [];
-        for (let t = 0; t < arity; ++t)
-          args.push(` #${t}`);
-        const definition = `${nameSet.join(`,`)}${args.join(``)}`;
-        if (!inlineOptions && description) {
-          detailedOptionList.push({ preferredName, nameSet, definition, description, required });
-        } else {
-          segments.push(required ? `<${definition}>` : `[${definition}]`);
-        }
-      }
-      segments.push(...this.arity.leading.map((name) => `<${name}>`));
-      if (this.arity.extra === NoLimits)
-        segments.push(`...`);
-      else
-        segments.push(...this.arity.extra.map((name) => `[${name}]`));
-      segments.push(...this.arity.trailing.map((name) => `<${name}>`));
-    }
-    const usage = segments.join(` `);
-    return { usage, options: detailedOptionList };
-  }
-  compile() {
-    if (typeof this.context === `undefined`)
-      throw new Error(`Assertion failed: No context attached`);
-    const machine = makeStateMachine();
-    let firstNode = NodeType.InitialNode;
-    const candidateUsage = this.usage().usage;
-    const requiredOptions = this.options.filter((opt) => opt.required).map((opt) => opt.nameSet);
-    firstNode = injectNode(machine, makeNode());
-    registerStatic(machine, NodeType.InitialNode, SpecialToken.StartOfInput, firstNode, [`setCandidateState`, { candidateUsage, requiredOptions }]);
-    const positionalArgument = this.arity.proxy ? `always` : `isNotOptionLike`;
-    const paths = this.paths.length > 0 ? this.paths : [[]];
-    for (const path2 of paths) {
-      let lastPathNode = firstNode;
-      if (path2.length > 0) {
-        const optionPathNode = injectNode(machine, makeNode());
-        registerShortcut(machine, lastPathNode, optionPathNode);
-        this.registerOptions(machine, optionPathNode);
-        lastPathNode = optionPathNode;
-      }
-      for (let t = 0; t < path2.length; ++t) {
-        const nextPathNode = injectNode(machine, makeNode());
-        registerStatic(machine, lastPathNode, path2[t], nextPathNode, `pushPath`);
-        lastPathNode = nextPathNode;
-        if (t + 1 < path2.length) {
-          const helpNode = injectNode(machine, makeNode());
-          registerDynamic(machine, lastPathNode, `isHelp`, helpNode, [`useHelp`, this.cliIndex]);
-          registerStatic(machine, helpNode, SpecialToken.EndOfInput, NodeType.SuccessNode, [`setSelectedIndex`, HELP_COMMAND_INDEX]);
-        }
-      }
-      if (this.arity.leading.length > 0 || !this.arity.proxy) {
-        const helpNode = injectNode(machine, makeNode());
-        registerDynamic(machine, lastPathNode, `isHelp`, helpNode, [`useHelp`, this.cliIndex]);
-        registerDynamic(machine, helpNode, `always`, helpNode, `pushExtra`);
-        registerStatic(machine, helpNode, SpecialToken.EndOfInput, NodeType.SuccessNode, [`setSelectedIndex`, HELP_COMMAND_INDEX]);
-        this.registerOptions(machine, lastPathNode);
-      }
-      if (this.arity.leading.length > 0) {
-        registerStatic(machine, lastPathNode, SpecialToken.EndOfInput, NodeType.ErrorNode, [`setError`, `Not enough positional arguments`]);
-        registerStatic(machine, lastPathNode, SpecialToken.EndOfPartialInput, NodeType.SuccessNode, [`setSelectedIndex`, this.cliIndex]);
-      }
-      let lastLeadingNode = lastPathNode;
-      for (let t = 0; t < this.arity.leading.length; ++t) {
-        const nextLeadingNode = injectNode(machine, makeNode());
-        if (!this.arity.proxy || t + 1 !== this.arity.leading.length)
-          this.registerOptions(machine, nextLeadingNode);
-        if (this.arity.trailing.length > 0 || t + 1 !== this.arity.leading.length) {
-          registerStatic(machine, nextLeadingNode, SpecialToken.EndOfInput, NodeType.ErrorNode, [`setError`, `Not enough positional arguments`]);
-          registerStatic(machine, nextLeadingNode, SpecialToken.EndOfPartialInput, NodeType.SuccessNode, [`setSelectedIndex`, this.cliIndex]);
-        }
-        registerDynamic(machine, lastLeadingNode, `isNotOptionLike`, nextLeadingNode, `pushPositional`);
-        lastLeadingNode = nextLeadingNode;
-      }
-      let lastExtraNode = lastLeadingNode;
-      if (this.arity.extra === NoLimits || this.arity.extra.length > 0) {
-        const extraShortcutNode = injectNode(machine, makeNode());
-        registerShortcut(machine, lastLeadingNode, extraShortcutNode);
-        if (this.arity.extra === NoLimits) {
-          const extraNode = injectNode(machine, makeNode());
-          if (!this.arity.proxy)
-            this.registerOptions(machine, extraNode);
-          registerDynamic(machine, lastLeadingNode, positionalArgument, extraNode, `pushExtraNoLimits`);
-          registerDynamic(machine, extraNode, positionalArgument, extraNode, `pushExtraNoLimits`);
-          registerShortcut(machine, extraNode, extraShortcutNode);
-        } else {
-          for (let t = 0; t < this.arity.extra.length; ++t) {
-            const nextExtraNode = injectNode(machine, makeNode());
-            if (!this.arity.proxy || t > 0)
-              this.registerOptions(machine, nextExtraNode);
-            registerDynamic(machine, lastExtraNode, positionalArgument, nextExtraNode, `pushExtra`);
-            registerShortcut(machine, nextExtraNode, extraShortcutNode);
-            lastExtraNode = nextExtraNode;
-          }
-        }
-        lastExtraNode = extraShortcutNode;
-      }
-      if (this.arity.trailing.length > 0) {
-        registerStatic(machine, lastExtraNode, SpecialToken.EndOfInput, NodeType.ErrorNode, [`setError`, `Not enough positional arguments`]);
-        registerStatic(machine, lastExtraNode, SpecialToken.EndOfPartialInput, NodeType.SuccessNode, [`setSelectedIndex`, this.cliIndex]);
-      }
-      let lastTrailingNode = lastExtraNode;
-      for (let t = 0; t < this.arity.trailing.length; ++t) {
-        const nextTrailingNode = injectNode(machine, makeNode());
-        if (!this.arity.proxy)
-          this.registerOptions(machine, nextTrailingNode);
-        if (t + 1 < this.arity.trailing.length) {
-          registerStatic(machine, nextTrailingNode, SpecialToken.EndOfInput, NodeType.ErrorNode, [`setError`, `Not enough positional arguments`]);
-          registerStatic(machine, nextTrailingNode, SpecialToken.EndOfPartialInput, NodeType.SuccessNode, [`setSelectedIndex`, this.cliIndex]);
-        }
-        registerDynamic(machine, lastTrailingNode, `isNotOptionLike`, nextTrailingNode, `pushPositional`);
-        lastTrailingNode = nextTrailingNode;
-      }
-      registerDynamic(machine, lastTrailingNode, positionalArgument, NodeType.ErrorNode, [`setError`, `Extraneous positional argument`]);
-      registerStatic(machine, lastTrailingNode, SpecialToken.EndOfInput, NodeType.SuccessNode, [`setSelectedIndex`, this.cliIndex]);
-      registerStatic(machine, lastTrailingNode, SpecialToken.EndOfPartialInput, NodeType.SuccessNode, [`setSelectedIndex`, this.cliIndex]);
-    }
-    return {
-      machine,
-      context: this.context
-    };
-  }
-  registerOptions(machine, node) {
-    registerDynamic(machine, node, [`isOption`, `--`], node, `inhibateOptions`);
-    registerDynamic(machine, node, [`isBatchOption`, this.allOptionNames], node, [`pushBatch`, this.allOptionNames]);
-    registerDynamic(machine, node, [`isBoundOption`, this.allOptionNames, this.options], node, `pushBound`);
-    registerDynamic(machine, node, [`isUnsupportedOption`, this.allOptionNames], NodeType.ErrorNode, [`setError`, `Unsupported option name`]);
-    registerDynamic(machine, node, [`isInvalidOption`], NodeType.ErrorNode, [`setError`, `Invalid option name`]);
-    for (const option of this.options) {
-      if (option.arity === 0) {
-        for (const name of option.nameSet) {
-          registerDynamic(machine, node, [`isOption`, name], node, [`pushTrue`, option.preferredName]);
-          if (name.startsWith(`--`) && !name.startsWith(`--no-`)) {
-            registerDynamic(machine, node, [`isNegatedOption`, name], node, [`pushFalse`, option.preferredName]);
-          }
-        }
-      } else {
-        let lastNode = injectNode(machine, makeNode());
-        for (const name of option.nameSet)
-          registerDynamic(machine, node, [`isOption`, name], lastNode, [`pushUndefined`, option.preferredName]);
-        for (let t = 0; t < option.arity; ++t) {
-          const nextNode = injectNode(machine, makeNode());
-          registerStatic(machine, lastNode, SpecialToken.EndOfInput, NodeType.ErrorNode, `setOptionArityError`);
-          registerStatic(machine, lastNode, SpecialToken.EndOfPartialInput, NodeType.ErrorNode, `setOptionArityError`);
-          registerDynamic(machine, lastNode, `isOptionLike`, NodeType.ErrorNode, `setOptionArityError`);
-          const action = option.arity === 1 ? `setStringValue` : `pushStringValue`;
-          registerDynamic(machine, lastNode, `isNotOptionLike`, nextNode, action);
-          lastNode = nextNode;
-        }
-        registerShortcut(machine, lastNode, node);
-      }
-    }
-  }
-};
-var CliBuilder = class _CliBuilder {
-  static build(cbs, opts = {}) {
-    return new _CliBuilder(opts).commands(cbs).compile();
-  }
-  constructor({ binaryName = `...` } = {}) {
-    this.builders = [];
-    this.opts = { binaryName };
-  }
-  getBuilderByIndex(n) {
-    if (!(n >= 0 && n < this.builders.length))
-      throw new Error(`Assertion failed: Out-of-bound command index (${n})`);
-    return this.builders[n];
-  }
-  commands(cbs) {
-    for (const cb of cbs)
-      cb(this.command());
-    return this;
-  }
-  command() {
-    const builder = new CommandBuilder(this.builders.length, this.opts);
-    this.builders.push(builder);
-    return builder;
-  }
-  compile() {
-    const machines = [];
-    const contexts = [];
-    for (const builder of this.builders) {
-      const { machine: machine2, context } = builder.compile();
-      machines.push(machine2);
-      contexts.push(context);
-    }
-    const machine = makeAnyOfMachine(machines);
-    simplifyMachine(machine);
-    return {
-      machine,
-      contexts,
-      process: (input, { partial } = {}) => {
-        const endToken = partial ? SpecialToken.EndOfPartialInput : SpecialToken.EndOfInput;
-        return runMachine(machine, input, { endToken });
-      }
-    };
-  }
-};
-
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/format.mjs
-init_esm_shims();
-var MAX_LINE_LENGTH = 80;
-var richLine = Array(MAX_LINE_LENGTH).fill(`\u2501`);
-for (let t = 0; t <= 24; ++t)
-  richLine[richLine.length - t] = `\x1B[38;5;${232 + t}m\u2501`;
-var richFormat = {
-  header: (str) => `\x1B[1m\u2501\u2501\u2501 ${str}${str.length < MAX_LINE_LENGTH - 5 ? ` ${richLine.slice(str.length + 5).join(``)}` : `:`}\x1B[0m`,
-  bold: (str) => `\x1B[1m${str}\x1B[22m`,
-  error: (str) => `\x1B[31m\x1B[1m${str}\x1B[22m\x1B[39m`,
-  code: (str) => `\x1B[36m${str}\x1B[39m`
-};
-var textFormat = {
-  header: (str) => str,
-  bold: (str) => str,
-  error: (str) => str,
-  code: (str) => str
-};
-function dedent(text) {
-  const lines = text.split(`
-`);
-  const nonEmptyLines = lines.filter((line) => line.match(/\S/));
-  const indent = nonEmptyLines.length > 0 ? nonEmptyLines.reduce((minLength, line) => Math.min(minLength, line.length - line.trimStart().length), Number.MAX_VALUE) : 0;
-  return lines.map((line) => line.slice(indent).trimRight()).join(`
-`);
-}
-function formatMarkdownish(text, { format, paragraphs }) {
-  text = text.replace(/\r\n?/g, `
-`);
-  text = dedent(text);
-  text = text.replace(/^\n+|\n+$/g, ``);
-  text = text.replace(/^(\s*)-([^\n]*?)\n+/gm, `$1-$2
-
-`);
-  text = text.replace(/\n(\n)?\n*/g, ($0, $1) => $1 ? $1 : ` `);
-  if (paragraphs) {
-    text = text.split(/\n/).map((paragraph) => {
-      const bulletMatch = paragraph.match(/^\s*[*-][\t ]+(.*)/);
-      if (!bulletMatch)
-        return paragraph.match(/(.{1,80})(?: |$)/g).join(`
-`);
-      const indent = paragraph.length - paragraph.trimStart().length;
-      return bulletMatch[1].match(new RegExp(`(.{1,${78 - indent}})(?: |$)`, `g`)).map((line, index) => {
-        return ` `.repeat(indent) + (index === 0 ? `- ` : `  `) + line;
-      }).join(`
-`);
-    }).join(`
-
-`);
-  }
-  text = text.replace(/(`+)((?:.|[\n])*?)\1/g, ($0, $1, $2) => {
-    return format.code($1 + $2 + $1);
-  });
-  text = text.replace(/(\*\*)((?:.|[\n])*?)\1/g, ($0, $1, $2) => {
-    return format.bold($1 + $2 + $1);
-  });
-  return text ? `${text}
-` : ``;
-}
-
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/HelpCommand.mjs
-init_esm_shims();
-var HelpCommand = class _HelpCommand extends Command {
-  static from(state, contexts) {
-    const command = new _HelpCommand(contexts);
-    command.path = state.path;
-    for (const opt of state.options) {
-      switch (opt.name) {
-        case `-c`:
-          {
-            command.commands.push(Number(opt.value));
-          }
-          break;
-        case `-i`:
-          {
-            command.index = Number(opt.value);
-          }
-          break;
-      }
-    }
-    return command;
-  }
-  constructor(contexts) {
-    super();
-    this.contexts = contexts;
-    this.commands = [];
-  }
-  async execute() {
-    let commands = this.commands;
-    if (typeof this.index !== `undefined` && this.index >= 0 && this.index < commands.length)
-      commands = [commands[this.index]];
-    if (commands.length === 0) {
-      this.context.stdout.write(this.cli.usage());
-    } else if (commands.length === 1) {
-      this.context.stdout.write(this.cli.usage(this.contexts[commands[0]].commandClass, { detailed: true }));
-    } else if (commands.length > 1) {
-      this.context.stdout.write(`Multiple commands match your selection:
-`);
-      this.context.stdout.write(`
-`);
-      let index = 0;
-      for (const command of this.commands)
-        this.context.stdout.write(this.cli.usage(this.contexts[command].commandClass, { prefix: `${index++}. `.padStart(5) }));
-      this.context.stdout.write(`
-`);
-      this.context.stdout.write(`Run again with -h=<index> to see the longer details of any of those commands.
-`);
-    }
-  }
-};
-
-// ../../.yarn/__virtual__/clipanion-virtual-8d4993908b/0/cache/clipanion-npm-4.0.0-rc.4-8228e3d944-047b415b59.zip/node_modules/clipanion/lib/advanced/Cli.mjs
-var errorCommandSymbol = Symbol(`clipanion/errorCommand`);
-var Cli = class _Cli {
-  /**
-   * Creates a new Cli and registers all commands passed as parameters.
-   *
-   * @param commandClasses The Commands to register
-   * @returns The created `Cli` instance
-   */
-  static from(commandClasses, options = {}) {
-    const cli2 = new _Cli(options);
-    const resolvedCommandClasses = Array.isArray(commandClasses) ? commandClasses : [commandClasses];
-    for (const commandClass of resolvedCommandClasses)
-      cli2.register(commandClass);
-    return cli2;
-  }
-  constructor({ binaryLabel, binaryName: binaryNameOpt = `...`, binaryVersion, enableCapture = false, enableColors } = {}) {
-    this.registrations = /* @__PURE__ */ new Map();
-    this.builder = new CliBuilder({ binaryName: binaryNameOpt });
-    this.binaryLabel = binaryLabel;
-    this.binaryName = binaryNameOpt;
-    this.binaryVersion = binaryVersion;
-    this.enableCapture = enableCapture;
-    this.enableColors = enableColors;
-  }
-  /**
-   * Registers a command inside the CLI.
-   */
-  register(commandClass) {
-    var _a;
-    if (this.registrations.has(commandClass))
-      throw new RangeError(`${commandClass.name} has already been registered`);
-    const specs = /* @__PURE__ */ new Map();
-    const command = new commandClass();
-    for (const key in command) {
-      const value = command[key];
-      if (typeof value === `object` && value !== null && value[Command.isOption]) {
-        specs.set(key, value);
-      }
-    }
-    const builder = this.builder.command();
-    const index = builder.cliIndex;
-    const paths = (_a = commandClass.paths) !== null && _a !== void 0 ? _a : command.paths;
-    if (typeof paths !== `undefined`)
-      for (const path2 of paths)
-        builder.addPath(path2);
-    this.registrations.set(commandClass, { specs, builder, index });
-    for (const [key, { definition }] of specs.entries())
-      definition(builder, key);
-    builder.setContext({
-      commandClass
-    });
-  }
-  process(opts, contextArg) {
-    const { input, context: userContext, partial } = typeof opts === `object` && Array.isArray(opts) ? { input: opts, context: contextArg } : opts;
-    const { contexts, process: process2 } = this.builder.compile();
-    const state = process2(input, { partial });
-    const context = {
-      ..._Cli.defaultContext,
-      ...userContext
-    };
-    switch (state.selectedIndex) {
-      case HELP_COMMAND_INDEX: {
-        const command = HelpCommand.from(state, contexts);
-        command.context = context;
-        command.tokens = state.tokens;
-        return command;
-      }
-      default:
-        {
-          const { commandClass } = contexts[state.selectedIndex];
-          const record = this.registrations.get(commandClass);
-          if (typeof record === `undefined`)
-            throw new Error(`Assertion failed: Expected the command class to have been registered.`);
-          const command = new commandClass();
-          command.context = context;
-          command.tokens = state.tokens;
-          command.path = state.path;
-          try {
-            for (const [key, { transformer }] of record.specs.entries())
-              command[key] = transformer(record.builder, key, state, context);
-            return command;
-          } catch (error) {
-            error[errorCommandSymbol] = command;
-            throw error;
-          }
-        }
-        break;
-    }
-  }
-  async run(input, userContext) {
-    var _a, _b;
-    let command;
-    const context = {
-      ..._Cli.defaultContext,
-      ...userContext
-    };
-    const colored = (_a = this.enableColors) !== null && _a !== void 0 ? _a : context.colorDepth > 1;
-    if (!Array.isArray(input)) {
-      command = input;
-    } else {
-      try {
-        command = this.process(input, context);
-      } catch (error) {
-        context.stdout.write(this.error(error, { colored }));
-        return 1;
-      }
-    }
-    if (command.help) {
-      context.stdout.write(this.usage(command, { colored, detailed: true }));
-      return 0;
-    }
-    command.context = context;
-    command.cli = {
-      binaryLabel: this.binaryLabel,
-      binaryName: this.binaryName,
-      binaryVersion: this.binaryVersion,
-      enableCapture: this.enableCapture,
-      enableColors: this.enableColors,
-      definitions: () => this.definitions(),
-      definition: (command2) => this.definition(command2),
-      error: (error, opts) => this.error(error, opts),
-      format: (colored2) => this.format(colored2),
-      process: (input2, subContext) => this.process(input2, { ...context, ...subContext }),
-      run: (input2, subContext) => this.run(input2, { ...context, ...subContext }),
-      usage: (command2, opts) => this.usage(command2, opts)
-    };
-    const activate = this.enableCapture ? (_b = getCaptureActivator(context)) !== null && _b !== void 0 ? _b : noopCaptureActivator : noopCaptureActivator;
-    let exitCode;
-    try {
-      exitCode = await activate(() => command.validateAndExecute().catch((error) => command.catch(error).then(() => 0)));
-    } catch (error) {
-      context.stdout.write(this.error(error, { colored, command }));
-      return 1;
-    }
-    return exitCode;
-  }
-  async runExit(input, context) {
-    process.exitCode = await this.run(input, context);
-  }
-  definition(commandClass, { colored = false } = {}) {
-    if (!commandClass.usage)
-      return null;
-    const { usage: path2 } = this.getUsageByRegistration(commandClass, { detailed: false });
-    const { usage, options } = this.getUsageByRegistration(commandClass, { detailed: true, inlineOptions: false });
-    const category = typeof commandClass.usage.category !== `undefined` ? formatMarkdownish(commandClass.usage.category, { format: this.format(colored), paragraphs: false }) : void 0;
-    const description = typeof commandClass.usage.description !== `undefined` ? formatMarkdownish(commandClass.usage.description, { format: this.format(colored), paragraphs: false }) : void 0;
-    const details = typeof commandClass.usage.details !== `undefined` ? formatMarkdownish(commandClass.usage.details, { format: this.format(colored), paragraphs: true }) : void 0;
-    const examples = typeof commandClass.usage.examples !== `undefined` ? commandClass.usage.examples.map(([label, cli2]) => [formatMarkdownish(label, { format: this.format(colored), paragraphs: false }), cli2.replace(/\$0/g, this.binaryName)]) : void 0;
-    return { path: path2, usage, category, description, details, examples, options };
-  }
-  definitions({ colored = false } = {}) {
-    const data = [];
-    for (const commandClass of this.registrations.keys()) {
-      const usage = this.definition(commandClass, { colored });
-      if (!usage)
-        continue;
-      data.push(usage);
-    }
-    return data;
-  }
-  usage(command = null, { colored, detailed = false, prefix = `$ ` } = {}) {
-    var _a;
-    if (command === null) {
-      for (const commandClass2 of this.registrations.keys()) {
-        const paths = commandClass2.paths;
-        const isDocumented = typeof commandClass2.usage !== `undefined`;
-        const isExclusivelyDefault = !paths || paths.length === 0 || paths.length === 1 && paths[0].length === 0;
-        const isDefault = isExclusivelyDefault || ((_a = paths === null || paths === void 0 ? void 0 : paths.some((path2) => path2.length === 0)) !== null && _a !== void 0 ? _a : false);
-        if (isDefault) {
-          if (command) {
-            command = null;
-            break;
-          } else {
-            command = commandClass2;
-          }
-        } else {
-          if (isDocumented) {
-            command = null;
-            continue;
-          }
-        }
-      }
-      if (command) {
-        detailed = true;
-      }
-    }
-    const commandClass = command !== null && command instanceof Command ? command.constructor : command;
-    let result = ``;
-    if (!commandClass) {
-      const commandsByCategories = /* @__PURE__ */ new Map();
-      for (const [commandClass2, { index }] of this.registrations.entries()) {
-        if (typeof commandClass2.usage === `undefined`)
-          continue;
-        const category = typeof commandClass2.usage.category !== `undefined` ? formatMarkdownish(commandClass2.usage.category, { format: this.format(colored), paragraphs: false }) : null;
-        let categoryCommands = commandsByCategories.get(category);
-        if (typeof categoryCommands === `undefined`)
-          commandsByCategories.set(category, categoryCommands = []);
-        const { usage } = this.getUsageByIndex(index);
-        categoryCommands.push({ commandClass: commandClass2, usage });
-      }
-      const categoryNames = Array.from(commandsByCategories.keys()).sort((a, b) => {
-        if (a === null)
-          return -1;
-        if (b === null)
-          return 1;
-        return a.localeCompare(b, `en`, { usage: `sort`, caseFirst: `upper` });
-      });
-      const hasLabel = typeof this.binaryLabel !== `undefined`;
-      const hasVersion = typeof this.binaryVersion !== `undefined`;
-      if (hasLabel || hasVersion) {
-        if (hasLabel && hasVersion)
-          result += `${this.format(colored).header(`${this.binaryLabel} - ${this.binaryVersion}`)}
-
-`;
-        else if (hasLabel)
-          result += `${this.format(colored).header(`${this.binaryLabel}`)}
-`;
-        else
-          result += `${this.format(colored).header(`${this.binaryVersion}`)}
-`;
-        result += `  ${this.format(colored).bold(prefix)}${this.binaryName} <command>
-`;
-      } else {
-        result += `${this.format(colored).bold(prefix)}${this.binaryName} <command>
-`;
-      }
-      for (const categoryName of categoryNames) {
-        const commands = commandsByCategories.get(categoryName).slice().sort((a, b) => {
-          return a.usage.localeCompare(b.usage, `en`, { usage: `sort`, caseFirst: `upper` });
-        });
-        const header = categoryName !== null ? categoryName.trim() : `General commands`;
-        result += `
-`;
-        result += `${this.format(colored).header(`${header}`)}
-`;
-        for (const { commandClass: commandClass2, usage } of commands) {
-          const doc = commandClass2.usage.description || `undocumented`;
-          result += `
-`;
-          result += `  ${this.format(colored).bold(usage)}
-`;
-          result += `    ${formatMarkdownish(doc, { format: this.format(colored), paragraphs: false })}`;
-        }
-      }
-      result += `
-`;
-      result += formatMarkdownish(`You can also print more details about any of these commands by calling them with the \`-h,--help\` flag right after the command name.`, { format: this.format(colored), paragraphs: true });
-    } else {
-      if (!detailed) {
-        const { usage } = this.getUsageByRegistration(commandClass);
-        result += `${this.format(colored).bold(prefix)}${usage}
-`;
-      } else {
-        const { description = ``, details = ``, examples = [] } = commandClass.usage || {};
-        if (description !== ``) {
-          result += formatMarkdownish(description, { format: this.format(colored), paragraphs: false }).replace(/^./, ($0) => $0.toUpperCase());
-          result += `
-`;
-        }
-        if (details !== `` || examples.length > 0) {
-          result += `${this.format(colored).header(`Usage`)}
-`;
-          result += `
-`;
-        }
-        const { usage, options } = this.getUsageByRegistration(commandClass, { inlineOptions: false });
-        result += `${this.format(colored).bold(prefix)}${usage}
-`;
-        if (options.length > 0) {
-          result += `
-`;
-          result += `${this.format(colored).header(`Options`)}
-`;
-          const maxDefinitionLength = options.reduce((length, option) => {
-            return Math.max(length, option.definition.length);
-          }, 0);
-          result += `
-`;
-          for (const { definition, description: description2 } of options) {
-            result += `  ${this.format(colored).bold(definition.padEnd(maxDefinitionLength))}    ${formatMarkdownish(description2, { format: this.format(colored), paragraphs: false })}`;
-          }
-        }
-        if (details !== ``) {
-          result += `
-`;
-          result += `${this.format(colored).header(`Details`)}
-`;
-          result += `
-`;
-          result += formatMarkdownish(details, { format: this.format(colored), paragraphs: true });
-        }
-        if (examples.length > 0) {
-          result += `
-`;
-          result += `${this.format(colored).header(`Examples`)}
-`;
-          for (const [description2, example] of examples) {
-            result += `
-`;
-            result += formatMarkdownish(description2, { format: this.format(colored), paragraphs: false });
-            result += `${example.replace(/^/m, `  ${this.format(colored).bold(prefix)}`).replace(/\$0/g, this.binaryName)}
-`;
-          }
-        }
-      }
-    }
-    return result;
-  }
-  error(error, _a) {
-    var _b;
-    var { colored, command = (_b = error[errorCommandSymbol]) !== null && _b !== void 0 ? _b : null } = _a === void 0 ? {} : _a;
-    if (!error || typeof error !== `object` || !(`stack` in error))
-      error = new Error(`Execution failed with a non-error rejection (rejected value: ${JSON.stringify(error)})`);
-    let result = ``;
-    let name = error.name.replace(/([a-z])([A-Z])/g, `$1 $2`);
-    if (name === `Error`)
-      name = `Internal Error`;
-    result += `${this.format(colored).error(name)}: ${error.message}
-`;
-    const meta = error.clipanion;
-    if (typeof meta !== `undefined`) {
-      if (meta.type === `usage`) {
-        result += `
-`;
-        result += this.usage(command);
-      }
-    } else {
-      if (error.stack) {
-        result += `${error.stack.replace(/^.*\n/, ``)}
-`;
-      }
-    }
-    return result;
-  }
-  format(colored) {
-    var _a;
-    return ((_a = colored !== null && colored !== void 0 ? colored : this.enableColors) !== null && _a !== void 0 ? _a : _Cli.defaultContext.colorDepth > 1) ? richFormat : textFormat;
-  }
-  getUsageByRegistration(klass, opts) {
-    const record = this.registrations.get(klass);
-    if (typeof record === `undefined`)
-      throw new Error(`Assertion failed: Unregistered command`);
-    return this.getUsageByIndex(record.index, opts);
-  }
-  getUsageByIndex(n, opts) {
-    return this.builder.getBuilderByIndex(n).usage(opts);
-  }
-};
-Cli.defaultContext = {
-  env: process.env,
-  stdin: process.stdin,
-  stdout: process.stdout,
-  stderr: process.stderr,
-  colorDepth: getDefaultColorDepth()
-};
-function noopCaptureActivator(fn) {
-  return fn();
-}
-
-// src/commands/DevCommand.ts
-init_esm_shims();
-
-// ../../.yarn/__virtual__/@hono-node-server-virtual-cf2888014c/0/cache/@hono-node-server-npm-1.13.8-e78cfff928-5880892fdd.zip/node_modules/@hono/node-server/dist/index.mjs
-init_esm_shims();
-import { createServer as createServerHTTP } from "http";
-import { Http2ServerRequest } from "http2";
-import { Readable } from "stream";
-import crypto from "crypto";
-var RequestError = class extends Error {
-  static name = "RequestError";
-  constructor(message, options) {
-    super(message, options);
-  }
-};
-var toRequestError = (e) => {
-  if (e instanceof RequestError) {
-    return e;
-  }
-  return new RequestError(e.message, { cause: e });
-};
-var GlobalRequest = global.Request;
-var Request2 = class extends GlobalRequest {
-  constructor(input, options) {
-    if (typeof input === "object" && getRequestCache in input) {
-      input = input[getRequestCache]();
-    }
-    if (typeof options?.body?.getReader !== "undefined") {
-      ;
-      options.duplex ??= "half";
-    }
-    super(input, options);
-  }
-};
-var newRequestFromIncoming = (method, url, incoming, abortController) => {
-  const headerRecord = [];
-  const rawHeaders = incoming.rawHeaders;
-  for (let i = 0; i < rawHeaders.length; i += 2) {
-    const { [i]: key, [i + 1]: value } = rawHeaders;
-    if (key.charCodeAt(0) !== /*:*/
-    58) {
-      headerRecord.push([key, value]);
-    }
-  }
-  const init = {
-    method,
-    headers: headerRecord,
-    signal: abortController.signal
-  };
-  if (method === "TRACE") {
-    init.method = "GET";
-    const req = new Request2(url, init);
-    Object.defineProperty(req, "method", {
-      get() {
-        return "TRACE";
-      }
-    });
-    return req;
-  }
-  if (!(method === "GET" || method === "HEAD")) {
-    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
-      init.body = new ReadableStream({
-        start(controller) {
-          controller.enqueue(incoming.rawBody);
-          controller.close();
-        }
-      });
-    } else {
-      init.body = Readable.toWeb(incoming);
-    }
-  }
-  return new Request2(url, init);
-};
-var getRequestCache = Symbol("getRequestCache");
-var requestCache = Symbol("requestCache");
-var incomingKey = Symbol("incomingKey");
-var urlKey = Symbol("urlKey");
-var abortControllerKey = Symbol("abortControllerKey");
-var getAbortController = Symbol("getAbortController");
-var requestPrototype = {
-  get method() {
-    return this[incomingKey].method || "GET";
-  },
-  get url() {
-    return this[urlKey];
-  },
-  [getAbortController]() {
-    this[getRequestCache]();
-    return this[abortControllerKey];
-  },
-  [getRequestCache]() {
-    this[abortControllerKey] ||= new AbortController();
-    return this[requestCache] ||= newRequestFromIncoming(
-      this.method,
-      this[urlKey],
-      this[incomingKey],
-      this[abortControllerKey]
-    );
-  }
-};
-[
-  "body",
-  "bodyUsed",
-  "cache",
-  "credentials",
-  "destination",
-  "headers",
-  "integrity",
-  "mode",
-  "redirect",
-  "referrer",
-  "referrerPolicy",
-  "signal",
-  "keepalive"
-].forEach((k) => {
-  Object.defineProperty(requestPrototype, k, {
-    get() {
-      return this[getRequestCache]()[k];
-    }
-  });
-});
-["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-  Object.defineProperty(requestPrototype, k, {
-    value: function() {
-      return this[getRequestCache]()[k]();
-    }
-  });
-});
-Object.setPrototypeOf(requestPrototype, Request2.prototype);
-var newRequest = (incoming, defaultHostname) => {
-  const req = Object.create(requestPrototype);
-  req[incomingKey] = incoming;
-  const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
-  if (!host) {
-    throw new RequestError("Missing host header");
-  }
-  const url = new URL(
-    `${incoming instanceof Http2ServerRequest || incoming.socket && incoming.socket.encrypted ? "https" : "http"}://${host}${incoming.url}`
-  );
-  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
-    throw new RequestError("Invalid host header");
-  }
-  req[urlKey] = url.href;
-  return req;
-};
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    stream.cancel();
-    return;
-  }
-  const reader = stream.getReader();
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  reader.read().then(flow, cancel);
-  return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
-  });
-  function cancel(error) {
-    reader.cancel(error).catch(() => {
-    });
-    if (error) {
-      writable.destroy(error);
-    }
-  }
-  function onDrain() {
-    reader.read().then(flow, cancel);
-  }
-  function flow({ done, value }) {
-    try {
-      if (done) {
-        writable.end();
-      } else if (!writable.write(value)) {
-        writable.once("drain", onDrain);
-      } else {
-        return reader.read().then(flow, cancel);
-      }
-    } catch (e) {
-      cancel(e);
-    }
-  }
-}
-var buildOutgoingHttpHeaders = (headers) => {
-  const res = {};
-  if (!(headers instanceof Headers)) {
-    headers = new Headers(headers ?? void 0);
-  }
-  const cookies = [];
-  for (const [k, v] of headers) {
-    if (k === "set-cookie") {
-      cookies.push(v);
-    } else {
-      res[k] = v;
-    }
-  }
-  if (cookies.length > 0) {
-    res["set-cookie"] = cookies;
-  }
-  res["content-type"] ??= "text/plain; charset=UTF-8";
-  return res;
-};
-var responseCache = Symbol("responseCache");
-var getResponseCache = Symbol("getResponseCache");
-var cacheKey = Symbol("cache");
-var GlobalResponse = global.Response;
-var Response2 = class _Response {
-  #body;
-  #init;
-  [getResponseCache]() {
-    delete this[cacheKey];
-    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
-  }
-  constructor(body, init) {
-    this.#body = body;
-    if (init instanceof _Response) {
-      const cachedGlobalResponse = init[responseCache];
-      if (cachedGlobalResponse) {
-        this.#init = cachedGlobalResponse;
-        this[getResponseCache]();
-        return;
-      } else {
-        this.#init = init.#init;
-      }
-    } else {
-      this.#init = init;
-    }
-    if (typeof body === "string" || typeof body?.getReader !== "undefined") {
-      let headers = init?.headers || { "content-type": "text/plain; charset=UTF-8" };
-      if (headers instanceof Headers) {
-        headers = buildOutgoingHttpHeaders(headers);
-      }
-      ;
-      this[cacheKey] = [init?.status || 200, body, headers];
-    }
-  }
-};
-[
-  "body",
-  "bodyUsed",
-  "headers",
-  "ok",
-  "redirected",
-  "status",
-  "statusText",
-  "trailers",
-  "type",
-  "url"
-].forEach((k) => {
-  Object.defineProperty(Response2.prototype, k, {
-    get() {
-      return this[getResponseCache]()[k];
-    }
-  });
-});
-["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-  Object.defineProperty(Response2.prototype, k, {
-    value: function() {
-      return this[getResponseCache]()[k]();
-    }
-  });
-});
-Object.setPrototypeOf(Response2, GlobalResponse);
-Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
-var stateKey = Reflect.ownKeys(new GlobalResponse()).find(
-  (k) => typeof k === "symbol" && k.toString() === "Symbol(state)"
-);
-if (!stateKey) {
-  console.warn("Failed to find Response internal state key");
-}
-function getInternalBody(response) {
-  if (!stateKey) {
-    return;
-  }
-  if (response instanceof Response2) {
-    response = response[getResponseCache]();
-  }
-  const state = response[stateKey];
-  return state && state.body || void 0;
-}
-var X_ALREADY_SENT = "x-hono-already-sent";
-var webFetch = global.fetch;
-if (typeof global.crypto === "undefined") {
-  global.crypto = crypto;
-}
-global.fetch = (info, init) => {
-  init = {
-    // Disable compression handling so people can return the result of a fetch
-    // directly in the loader without messing with the Content-Encoding header.
-    compress: false,
-    ...init
-  };
-  return webFetch(info, init);
-};
-var regBuffer = /^no$/i;
-var regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
-var handleRequestError = () => new Response(null, {
-  status: 400
-});
-var handleFetchError = (e) => new Response(null, {
-  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
-});
-var handleResponseError = (e, outgoing) => {
-  const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
-  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
-    console.info("The user aborted a request.");
-  } else {
-    console.error(e);
-    if (!outgoing.headersSent) {
-      outgoing.writeHead(500, { "Content-Type": "text/plain" });
-    }
-    outgoing.end(`Error: ${err.message}`);
-    outgoing.destroy(err);
-  }
-};
-var responseViaCache = (res, outgoing) => {
-  const [status, body, header] = res[cacheKey];
-  if (typeof body === "string") {
-    header["Content-Length"] = Buffer.byteLength(body);
-    outgoing.writeHead(status, header);
-    outgoing.end(body);
-  } else {
-    outgoing.writeHead(status, header);
-    return writeFromReadableStream(body, outgoing)?.catch(
-      (e) => handleResponseError(e, outgoing)
-    );
-  }
-};
-var responseViaResponseObject = async (res, outgoing, options = {}) => {
-  if (res instanceof Promise) {
-    if (options.errorHandler) {
-      try {
-        res = await res;
-      } catch (err) {
-        const errRes = await options.errorHandler(err);
-        if (!errRes) {
-          return;
-        }
-        res = errRes;
-      }
-    } else {
-      res = await res.catch(handleFetchError);
-    }
-  }
-  if (cacheKey in res) {
-    return responseViaCache(res, outgoing);
-  }
-  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
-  const internalBody = getInternalBody(res);
-  if (internalBody) {
-    const { length, source, stream } = internalBody;
-    if (source instanceof Uint8Array && source.byteLength !== length) {
-    } else {
-      if (length) {
-        resHeaderRecord["content-length"] = length;
-      }
-      outgoing.writeHead(res.status, resHeaderRecord);
-      if (typeof source === "string" || source instanceof Uint8Array) {
-        outgoing.end(source);
-      } else if (source instanceof Blob) {
-        outgoing.end(new Uint8Array(await source.arrayBuffer()));
-      } else {
-        await writeFromReadableStream(stream, outgoing);
-      }
-      return;
-    }
-  }
-  if (res.body) {
-    const {
-      "transfer-encoding": transferEncoding,
-      "content-encoding": contentEncoding,
-      "content-length": contentLength,
-      "x-accel-buffering": accelBuffering,
-      "content-type": contentType
-    } = resHeaderRecord;
-    if (transferEncoding || contentEncoding || contentLength || // nginx buffering variant
-    accelBuffering && regBuffer.test(accelBuffering) || !regContentType.test(contentType)) {
-      outgoing.writeHead(res.status, resHeaderRecord);
-      await writeFromReadableStream(res.body, outgoing);
-    } else {
-      const buffer = await res.arrayBuffer();
-      resHeaderRecord["content-length"] = buffer.byteLength;
-      outgoing.writeHead(res.status, resHeaderRecord);
-      outgoing.end(new Uint8Array(buffer));
-    }
-  } else if (resHeaderRecord[X_ALREADY_SENT]) {
-  } else {
-    outgoing.writeHead(res.status, resHeaderRecord);
-    outgoing.end();
-  }
-};
-var getRequestListener = (fetchCallback, options = {}) => {
-  if (options.overrideGlobalObjects !== false && global.Request !== Request2) {
-    Object.defineProperty(global, "Request", {
-      value: Request2
-    });
-    Object.defineProperty(global, "Response", {
-      value: Response2
-    });
-  }
-  return async (incoming, outgoing) => {
-    let res, req;
-    try {
-      req = newRequest(incoming, options.hostname);
-      outgoing.on("close", () => {
-        const abortController = req[abortControllerKey];
-        if (!abortController) {
-          return;
-        }
-        if (incoming.errored) {
-          req[abortControllerKey].abort(incoming.errored.toString());
-        } else if (!outgoing.writableFinished) {
-          req[abortControllerKey].abort("Client connection prematurely closed.");
-        }
-      });
-      res = fetchCallback(req, { incoming, outgoing });
-      if (cacheKey in res) {
-        return responseViaCache(res, outgoing);
-      }
-    } catch (e) {
-      if (!res) {
-        if (options.errorHandler) {
-          res = await options.errorHandler(req ? e : toRequestError(e));
-          if (!res) {
-            return;
-          }
-        } else if (!req) {
-          res = handleRequestError();
-        } else {
-          res = handleFetchError(e);
-        }
-      } else {
-        return handleResponseError(e, outgoing);
-      }
-    }
-    try {
-      return responseViaResponseObject(res, outgoing, options);
-    } catch (e) {
-      return handleResponseError(e, outgoing);
-    }
-  };
-};
-var createAdaptorServer = (options) => {
-  const fetchCallback = options.fetch;
-  const requestListener = getRequestListener(fetchCallback, {
-    hostname: options.hostname,
-    overrideGlobalObjects: options.overrideGlobalObjects
-  });
-  const createServer = options.createServer || createServerHTTP;
-  const server = createServer(options.serverOptions || {}, requestListener);
-  return server;
-};
-var serve = (options, listeningListener) => {
-  const server = createAdaptorServer(options);
-  server.listen(options?.port ?? 3e3, options.hostname, () => {
-    const serverInfo = server.address();
-    listeningListener && listeningListener(serverInfo);
-  });
-  return server;
-};
-
-// src/server.ts
-init_esm_shims();
-import fs from "fs";
-import path from "path";
-import { transform } from "@babel/core";
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/index.js
-init_esm_shims();
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/hono.js
-init_esm_shims();
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/hono-base.js
-init_esm_shims();
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/compose.js
-init_esm_shims();
-var compose = (middleware, onError, onNotFound) => {
-  return (context, next) => {
-    let index = -1;
-    return dispatch(0);
-    async function dispatch(i) {
-      if (i <= index) {
-        throw new Error("next() called multiple times");
-      }
-      index = i;
-      let res;
-      let isError = false;
-      let handler;
-      if (middleware[i]) {
-        handler = middleware[i][0][0];
-        context.req.routeIndex = i;
-      } else {
-        handler = i === middleware.length && next || void 0;
-      }
-      if (handler) {
-        try {
-          res = await handler(context, () => dispatch(i + 1));
-        } catch (err) {
-          if (err instanceof Error && onError) {
-            context.error = err;
-            res = await onError(err, context);
-            isError = true;
-          } else {
-            throw err;
-          }
-        }
-      } else {
-        if (context.finalized === false && onNotFound) {
-          res = await onNotFound(context);
-        }
-      }
-      if (res && (context.finalized === false || isError)) {
-        context.res = res;
-      }
-      return context;
-    }
-  };
-};
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/context.js
-init_esm_shims();
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/request.js
-init_esm_shims();
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/utils/body.js
-init_esm_shims();
-var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
-  const { all = false, dot = false } = options;
-  const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
-  const contentType = headers.get("Content-Type");
-  if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) {
-    return parseFormData(request, { all, dot });
-  }
-  return {};
-};
-async function parseFormData(request, options) {
-  const formData = await request.formData();
-  if (formData) {
-    return convertFormDataToBodyData(formData, options);
-  }
-  return {};
-}
-function convertFormDataToBodyData(formData, options) {
-  const form = /* @__PURE__ */ Object.create(null);
-  formData.forEach((value, key) => {
-    const shouldParseAllValues = options.all || key.endsWith("[]");
-    if (!shouldParseAllValues) {
-      form[key] = value;
-    } else {
-      handleParsingAllValues(form, key, value);
-    }
-  });
-  if (options.dot) {
-    Object.entries(form).forEach(([key, value]) => {
-      const shouldParseDotValues = key.includes(".");
-      if (shouldParseDotValues) {
-        handleParsingNestedValues(form, key, value);
-        delete form[key];
-      }
-    });
-  }
-  return form;
-}
-var handleParsingAllValues = (form, key, value) => {
-  if (form[key] !== void 0) {
-    if (Array.isArray(form[key])) {
-      ;
-      form[key].push(value);
-    } else {
-      form[key] = [form[key], value];
-    }
-  } else {
-    form[key] = value;
-  }
-};
-var handleParsingNestedValues = (form, key, value) => {
-  let nestedForm = form;
-  const keys = key.split(".");
-  keys.forEach((key2, index) => {
-    if (index === keys.length - 1) {
-      nestedForm[key2] = value;
-    } else {
-      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
-        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
-      }
-      nestedForm = nestedForm[key2];
-    }
-  });
-};
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/utils/url.js
-init_esm_shims();
-var splitPath = (path2) => {
-  const paths = path2.split("/");
-  if (paths[0] === "") {
-    paths.shift();
-  }
-  return paths;
-};
-var splitRoutingPath = (routePath) => {
-  const { groups, path: path2 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path2);
-  return replaceGroupMarks(paths, groups);
-};
-var extractGroupsFromPath = (path2) => {
-  const groups = [];
-  path2 = path2.replace(/\{[^}]+\}/g, (match, index) => {
-    const mark = `@${index}`;
-    groups.push([mark, match]);
-    return mark;
-  });
-  return { groups, path: path2 };
-};
-var replaceGroupMarks = (paths, groups) => {
-  for (let i = groups.length - 1; i >= 0; i--) {
-    const [mark] = groups[i];
-    for (let j = paths.length - 1; j >= 0; j--) {
-      if (paths[j].includes(mark)) {
-        paths[j] = paths[j].replace(mark, groups[i][1]);
-        break;
-      }
-    }
-  }
-  return paths;
-};
-var patternCache = {};
-var getPattern = (label, next) => {
-  if (label === "*") {
-    return "*";
-  }
-  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-  if (match) {
-    const cacheKey2 = `${label}#${next}`;
-    if (!patternCache[cacheKey2]) {
-      if (match[2]) {
-        patternCache[cacheKey2] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey2, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
-      } else {
-        patternCache[cacheKey2] = [label, match[1], true];
-      }
-    }
-    return patternCache[cacheKey2];
-  }
-  return null;
-};
-var tryDecode = (str, decoder) => {
-  try {
-    return decoder(str);
-  } catch {
-    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
-      try {
-        return decoder(match);
-      } catch {
-        return match;
-      }
-    });
-  }
-};
-var tryDecodeURI = (str) => tryDecode(str, decodeURI);
-var getPath = (request) => {
-  const url = request.url;
-  const start = url.indexOf("/", 8);
-  let i = start;
-  for (; i < url.length; i++) {
-    const charCode = url.charCodeAt(i);
-    if (charCode === 37) {
-      const queryIndex = url.indexOf("?", i);
-      const path2 = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
-      return tryDecodeURI(path2.includes("%25") ? path2.replace(/%25/g, "%2525") : path2);
-    } else if (charCode === 63) {
-      break;
-    }
-  }
-  return url.slice(start, i);
-};
-var getPathNoStrict = (request) => {
-  const result = getPath(request);
-  return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
-};
-var mergePath = (base, sub, ...rest) => {
-  if (rest.length) {
-    sub = mergePath(sub, ...rest);
-  }
-  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
-};
-var checkOptionalParameter = (path2) => {
-  if (path2.charCodeAt(path2.length - 1) !== 63 || !path2.includes(":")) {
-    return null;
-  }
-  const segments = path2.split("/");
-  const results = [];
-  let basePath = "";
-  segments.forEach((segment) => {
-    if (segment !== "" && !/\:/.test(segment)) {
-      basePath += "/" + segment;
-    } else if (/\:/.test(segment)) {
-      if (/\?/.test(segment)) {
-        if (results.length === 0 && basePath === "") {
-          results.push("/");
-        } else {
-          results.push(basePath);
-        }
-        const optionalSegment = segment.replace("?", "");
-        basePath += "/" + optionalSegment;
-        results.push(basePath);
-      } else {
-        basePath += "/" + segment;
-      }
-    }
-  });
-  return results.filter((v, i, a) => a.indexOf(v) === i);
-};
-var _decodeURI = (value) => {
-  if (!/[%+]/.test(value)) {
-    return value;
-  }
-  if (value.indexOf("+") !== -1) {
-    value = value.replace(/\+/g, " ");
-  }
-  return value.indexOf("%") !== -1 ? decodeURIComponent_(value) : value;
-};
-var _getQueryParam = (url, key, multiple) => {
-  let encoded;
-  if (!multiple && key && !/[%+]/.test(key)) {
-    let keyIndex2 = url.indexOf(`?${key}`, 8);
-    if (keyIndex2 === -1) {
-      keyIndex2 = url.indexOf(`&${key}`, 8);
-    }
-    while (keyIndex2 !== -1) {
-      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
-      if (trailingKeyCode === 61) {
-        const valueIndex = keyIndex2 + key.length + 2;
-        const endIndex = url.indexOf("&", valueIndex);
-        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
-      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
-        return "";
-      }
-      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
-    }
-    encoded = /[%+]/.test(url);
-    if (!encoded) {
-      return void 0;
-    }
-  }
-  const results = {};
-  encoded ??= /[%+]/.test(url);
-  let keyIndex = url.indexOf("?", 8);
-  while (keyIndex !== -1) {
-    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
-    let valueIndex = url.indexOf("=", keyIndex);
-    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
-      valueIndex = -1;
-    }
-    let name = url.slice(
-      keyIndex + 1,
-      valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex
-    );
-    if (encoded) {
-      name = _decodeURI(name);
-    }
-    keyIndex = nextKeyIndex;
-    if (name === "") {
-      continue;
-    }
-    let value;
-    if (valueIndex === -1) {
-      value = "";
-    } else {
-      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
-      if (encoded) {
-        value = _decodeURI(value);
-      }
-    }
-    if (multiple) {
-      if (!(results[name] && Array.isArray(results[name]))) {
-        results[name] = [];
-      }
-      ;
-      results[name].push(value);
-    } else {
-      results[name] ??= value;
-    }
-  }
-  return key ? results[key] : results;
-};
-var getQueryParam = _getQueryParam;
-var getQueryParams = (url, key) => {
-  return _getQueryParam(url, key, true);
-};
-var decodeURIComponent_ = decodeURIComponent;
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/request.js
-var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
-var HonoRequest = class {
-  raw;
-  #validatedData;
-  #matchResult;
-  routeIndex = 0;
-  path;
-  bodyCache = {};
-  constructor(request, path2 = "/", matchResult = [[]]) {
-    this.raw = request;
-    this.path = path2;
-    this.#matchResult = matchResult;
-    this.#validatedData = {};
-  }
-  param(key) {
-    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
-  }
-  #getDecodedParam(key) {
-    const paramKey = this.#matchResult[0][this.routeIndex][1][key];
-    const param = this.#getParamValue(paramKey);
-    return param ? /\%/.test(param) ? tryDecodeURIComponent(param) : param : void 0;
-  }
-  #getAllDecodedParams() {
-    const decoded = {};
-    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
-    for (const key of keys) {
-      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
-      if (value && typeof value === "string") {
-        decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
-      }
-    }
-    return decoded;
-  }
-  #getParamValue(paramKey) {
-    return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
-  }
-  query(key) {
-    return getQueryParam(this.url, key);
-  }
-  queries(key) {
-    return getQueryParams(this.url, key);
-  }
-  header(name) {
-    if (name) {
-      return this.raw.headers.get(name) ?? void 0;
-    }
-    const headerData = {};
-    this.raw.headers.forEach((value, key) => {
-      headerData[key] = value;
-    });
-    return headerData;
-  }
-  async parseBody(options) {
-    return this.bodyCache.parsedBody ??= await parseBody(this, options);
-  }
-  #cachedBody = (key) => {
-    const { bodyCache, raw: raw2 } = this;
-    const cachedBody = bodyCache[key];
-    if (cachedBody) {
-      return cachedBody;
-    }
-    const anyCachedKey = Object.keys(bodyCache)[0];
-    if (anyCachedKey) {
-      return bodyCache[anyCachedKey].then((body) => {
-        if (anyCachedKey === "json") {
-          body = JSON.stringify(body);
-        }
-        return new Response(body)[key]();
-      });
-    }
-    return bodyCache[key] = raw2[key]();
-  };
-  json() {
-    return this.#cachedBody("json");
-  }
-  text() {
-    return this.#cachedBody("text");
-  }
-  arrayBuffer() {
-    return this.#cachedBody("arrayBuffer");
-  }
-  blob() {
-    return this.#cachedBody("blob");
-  }
-  formData() {
-    return this.#cachedBody("formData");
-  }
-  addValidatedData(target, data) {
-    this.#validatedData[target] = data;
-  }
-  valid(target) {
-    return this.#validatedData[target];
-  }
-  get url() {
-    return this.raw.url;
-  }
-  get method() {
-    return this.raw.method;
-  }
-  get matchedRoutes() {
-    return this.#matchResult[0].map(([[, route]]) => route);
-  }
-  get routePath() {
-    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
-  }
-};
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/utils/html.js
-init_esm_shims();
-var HtmlEscapedCallbackPhase = {
-  Stringify: 1,
-  BeforeStream: 2,
-  Stream: 3
-};
-var raw = (value, callbacks) => {
-  const escapedString = new String(value);
-  escapedString.isEscaped = true;
-  escapedString.callbacks = callbacks;
-  return escapedString;
-};
-var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
-  if (typeof str === "object" && !(str instanceof String)) {
-    if (!(str instanceof Promise)) {
-      str = str.toString();
-    }
-    if (str instanceof Promise) {
-      str = await str;
-    }
-  }
-  const callbacks = str.callbacks;
-  if (!callbacks?.length) {
-    return Promise.resolve(str);
-  }
-  if (buffer) {
-    buffer[0] += str;
-  } else {
-    buffer = [str];
-  }
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
-    (res) => Promise.all(
-      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
-    ).then(() => buffer[0])
-  );
-  if (preserveCallbacks) {
-    return raw(await resStr, callbacks);
-  } else {
-    return resStr;
-  }
-};
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/context.js
-var TEXT_PLAIN = "text/plain; charset=UTF-8";
-var setHeaders = (headers, map = {}) => {
-  for (const key of Object.keys(map)) {
-    headers.set(key, map[key]);
-  }
-  return headers;
-};
-var Context = class {
-  #rawRequest;
-  #req;
-  env = {};
-  #var;
-  finalized = false;
-  error;
-  #status = 200;
-  #executionCtx;
-  #headers;
-  #preparedHeaders;
-  #res;
-  #isFresh = true;
-  #layout;
-  #renderer;
-  #notFoundHandler;
-  #matchResult;
-  #path;
-  constructor(req, options) {
-    this.#rawRequest = req;
-    if (options) {
-      this.#executionCtx = options.executionCtx;
-      this.env = options.env;
-      this.#notFoundHandler = options.notFoundHandler;
-      this.#path = options.path;
-      this.#matchResult = options.matchResult;
-    }
-  }
-  get req() {
-    this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
-    return this.#req;
-  }
-  get event() {
-    if (this.#executionCtx && "respondWith" in this.#executionCtx) {
-      return this.#executionCtx;
-    } else {
-      throw Error("This context has no FetchEvent");
-    }
-  }
-  get executionCtx() {
-    if (this.#executionCtx) {
-      return this.#executionCtx;
-    } else {
-      throw Error("This context has no ExecutionContext");
-    }
-  }
-  get res() {
-    this.#isFresh = false;
-    return this.#res ||= new Response("404 Not Found", { status: 404 });
-  }
-  set res(_res) {
-    this.#isFresh = false;
-    if (this.#res && _res) {
-      try {
-        for (const [k, v] of this.#res.headers.entries()) {
-          if (k === "content-type") {
-            continue;
-          }
-          if (k === "set-cookie") {
-            const cookies = this.#res.headers.getSetCookie();
-            _res.headers.delete("set-cookie");
-            for (const cookie of cookies) {
-              _res.headers.append("set-cookie", cookie);
-            }
-          } else {
-            _res.headers.set(k, v);
-          }
-        }
-      } catch (e) {
-        if (e instanceof TypeError && e.message.includes("immutable")) {
-          this.res = new Response(_res.body, {
-            headers: _res.headers,
-            status: _res.status
-          });
-          return;
-        } else {
-          throw e;
-        }
-      }
-    }
-    this.#res = _res;
-    this.finalized = true;
-  }
-  render = (...args) => {
-    this.#renderer ??= (content) => this.html(content);
-    return this.#renderer(...args);
-  };
-  setLayout = (layout) => this.#layout = layout;
-  getLayout = () => this.#layout;
-  setRenderer = (renderer) => {
-    this.#renderer = renderer;
-  };
-  header = (name, value, options) => {
-    if (value === void 0) {
-      if (this.#headers) {
-        this.#headers.delete(name);
-      } else if (this.#preparedHeaders) {
-        delete this.#preparedHeaders[name.toLocaleLowerCase()];
-      }
-      if (this.finalized) {
-        this.res.headers.delete(name);
-      }
-      return;
-    }
-    if (options?.append) {
-      if (!this.#headers) {
-        this.#isFresh = false;
-        this.#headers = new Headers(this.#preparedHeaders);
-        this.#preparedHeaders = {};
-      }
-      this.#headers.append(name, value);
-    } else {
-      if (this.#headers) {
-        this.#headers.set(name, value);
-      } else {
-        this.#preparedHeaders ??= {};
-        this.#preparedHeaders[name.toLowerCase()] = value;
-      }
-    }
-    if (this.finalized) {
-      if (options?.append) {
-        this.res.headers.append(name, value);
-      } else {
-        this.res.headers.set(name, value);
-      }
-    }
-  };
-  status = (status) => {
-    this.#isFresh = false;
-    this.#status = status;
-  };
-  set = (key, value) => {
-    this.#var ??= /* @__PURE__ */ new Map();
-    this.#var.set(key, value);
-  };
-  get = (key) => {
-    return this.#var ? this.#var.get(key) : void 0;
-  };
-  get var() {
-    if (!this.#var) {
-      return {};
-    }
-    return Object.fromEntries(this.#var);
-  }
-  #newResponse(data, arg, headers) {
-    if (this.#isFresh && !headers && !arg && this.#status === 200) {
-      return new Response(data, {
-        headers: this.#preparedHeaders
-      });
-    }
-    if (arg && typeof arg !== "number") {
-      const header = new Headers(arg.headers);
-      if (this.#headers) {
-        this.#headers.forEach((v, k) => {
-          if (k === "set-cookie") {
-            header.append(k, v);
-          } else {
-            header.set(k, v);
-          }
-        });
-      }
-      const headers2 = setHeaders(header, this.#preparedHeaders);
-      return new Response(data, {
-        headers: headers2,
-        status: arg.status ?? this.#status
-      });
-    }
-    const status = typeof arg === "number" ? arg : this.#status;
-    this.#preparedHeaders ??= {};
-    this.#headers ??= new Headers();
-    setHeaders(this.#headers, this.#preparedHeaders);
-    if (this.#res) {
-      this.#res.headers.forEach((v, k) => {
-        if (k === "set-cookie") {
-          this.#headers?.append(k, v);
-        } else {
-          this.#headers?.set(k, v);
-        }
-      });
-      setHeaders(this.#headers, this.#preparedHeaders);
-    }
-    headers ??= {};
-    for (const [k, v] of Object.entries(headers)) {
-      if (typeof v === "string") {
-        this.#headers.set(k, v);
-      } else {
-        this.#headers.delete(k);
-        for (const v2 of v) {
-          this.#headers.append(k, v2);
-        }
-      }
-    }
-    return new Response(data, {
-      status,
-      headers: this.#headers
-    });
-  }
-  newResponse = (...args) => this.#newResponse(...args);
-  body = (data, arg, headers) => {
-    return typeof arg === "number" ? this.#newResponse(data, arg, headers) : this.#newResponse(data, arg);
-  };
-  text = (text, arg, headers) => {
-    if (!this.#preparedHeaders) {
-      if (this.#isFresh && !headers && !arg) {
-        return new Response(text);
-      }
-      this.#preparedHeaders = {};
-    }
-    this.#preparedHeaders["content-type"] = TEXT_PLAIN;
-    if (typeof arg === "number") {
-      return this.#newResponse(text, arg, headers);
-    }
-    return this.#newResponse(text, arg);
-  };
-  json = (object, arg, headers) => {
-    const body = JSON.stringify(object);
-    this.#preparedHeaders ??= {};
-    this.#preparedHeaders["content-type"] = "application/json";
-    return typeof arg === "number" ? this.#newResponse(body, arg, headers) : this.#newResponse(body, arg);
-  };
-  html = (html, arg, headers) => {
-    this.#preparedHeaders ??= {};
-    this.#preparedHeaders["content-type"] = "text/html; charset=UTF-8";
-    if (typeof html === "object") {
-      return resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2) => {
-        return typeof arg === "number" ? this.#newResponse(html2, arg, headers) : this.#newResponse(html2, arg);
-      });
-    }
-    return typeof arg === "number" ? this.#newResponse(html, arg, headers) : this.#newResponse(html, arg);
-  };
-  redirect = (location, status) => {
-    this.#headers ??= new Headers();
-    this.#headers.set("Location", String(location));
-    return this.newResponse(null, status ?? 302);
-  };
-  notFound = () => {
-    this.#notFoundHandler ??= () => new Response();
-    return this.#notFoundHandler(this);
-  };
-};
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router.js
-init_esm_shims();
-var METHOD_NAME_ALL = "ALL";
-var METHOD_NAME_ALL_LOWERCASE = "all";
-var METHODS = ["get", "post", "put", "delete", "options", "patch"];
-var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
-var UnsupportedPathError = class extends Error {
-};
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/utils/constants.js
-init_esm_shims();
-var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/hono-base.js
-var notFoundHandler = (c) => {
-  return c.text("404 Not Found", 404);
-};
-var errorHandler = (err, c) => {
-  if ("getResponse" in err) {
-    return err.getResponse();
-  }
-  console.error(err);
-  return c.text("Internal Server Error", 500);
-};
-var Hono = class {
-  get;
-  post;
-  put;
-  delete;
-  options;
-  patch;
-  all;
-  on;
-  use;
-  router;
-  getPath;
-  _basePath = "/";
-  #path = "/";
-  routes = [];
-  constructor(options = {}) {
-    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
-    allMethods.forEach((method) => {
-      this[method] = (args1, ...args) => {
-        if (typeof args1 === "string") {
-          this.#path = args1;
-        } else {
-          this.#addRoute(method, this.#path, args1);
-        }
-        args.forEach((handler) => {
-          this.#addRoute(method, this.#path, handler);
-        });
-        return this;
-      };
-    });
-    this.on = (method, path2, ...handlers) => {
-      for (const p of [path2].flat()) {
-        this.#path = p;
-        for (const m of [method].flat()) {
-          handlers.map((handler) => {
-            this.#addRoute(m.toUpperCase(), this.#path, handler);
-          });
-        }
-      }
-      return this;
-    };
-    this.use = (arg1, ...handlers) => {
-      if (typeof arg1 === "string") {
-        this.#path = arg1;
-      } else {
-        this.#path = "*";
-        handlers.unshift(arg1);
-      }
-      handlers.forEach((handler) => {
-        this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
-      });
-      return this;
-    };
-    const { strict, ...optionsWithoutStrict } = options;
-    Object.assign(this, optionsWithoutStrict);
-    this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
-  }
-  #clone() {
-    const clone = new Hono({
-      router: this.router,
-      getPath: this.getPath
-    });
-    clone.routes = this.routes;
-    return clone;
-  }
-  #notFoundHandler = notFoundHandler;
-  errorHandler = errorHandler;
-  route(path2, app2) {
-    const subApp = this.basePath(path2);
-    app2.routes.map((r) => {
-      let handler;
-      if (app2.errorHandler === errorHandler) {
-        handler = r.handler;
-      } else {
-        handler = async (c, next) => (await compose([], app2.errorHandler)(c, () => r.handler(c, next))).res;
-        handler[COMPOSED_HANDLER] = r.handler;
-      }
-      subApp.#addRoute(r.method, r.path, handler);
-    });
-    return this;
-  }
-  basePath(path2) {
-    const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path2);
-    return subApp;
-  }
-  onError = (handler) => {
-    this.errorHandler = handler;
-    return this;
-  };
-  notFound = (handler) => {
-    this.#notFoundHandler = handler;
-    return this;
+// src/BuildCommand/build.ts
+import fs from "fs";
+import path from "path";
+import { createArtifact } from "@apps-in-toss/framework/cli-presets";
+import * as mpack from "@react-native-bedrock/mpack-next";
+import { statusPlugin } from "@react-native-bedrock/mpack-next/plugins";
+import { execa } from "execa";
+import presets from "react-native-bedrock/presets";
+
+// src/utils/getPackageManager.ts
+function getPackageManager({ isExecutor = false } = {}) {
+  const userAgent = process.env.npm_config_user_agent;
+  const packageManagerCommands = {
+    npm: isExecutor ? "npx" : "npm",
+    pnpm: "pnpm",
+    yarn: "yarn"
   };
-  mount(path2, applicationHandler, options) {
-    let replaceRequest;
-    let optionHandler;
-    if (options) {
-      if (typeof options === "function") {
-        optionHandler = options;
-      } else {
-        optionHandler = options.optionHandler;
-        replaceRequest = options.replaceRequest;
-      }
-    }
-    const getOptions = optionHandler ? (c) => {
-      const options2 = optionHandler(c);
-      return Array.isArray(options2) ? options2 : [options2];
-    } : (c) => {
-      let executionContext = void 0;
-      try {
-        executionContext = c.executionCtx;
-      } catch {
-      }
-      return [c.env, executionContext];
-    };
-    replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path2);
-      const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
-      return (request) => {
-        const url = new URL(request.url);
-        url.pathname = url.pathname.slice(pathPrefixLength) || "/";
-        return new Request(url, request);
-      };
-    })();
-    const handler = async (c, next) => {
-      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
-      if (res) {
-        return res;
-      }
-      await next();
+  if (!userAgent) {
+    return {
+      packageManager: packageManagerCommands["npm"],
+      version: "0.0.0"
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path2, "*"), handler);
-    return this;
-  }
-  #addRoute(method, path2, handler) {
-    method = method.toUpperCase();
-    path2 = mergePath(this._basePath, path2);
-    const r = { path: path2, method, handler };
-    this.router.add(method, path2, [handler, r]);
-    this.routes.push(r);
   }
-  #handleError(err, c) {
-    if (err instanceof Error) {
-      return this.errorHandler(err, c);
-    }
-    throw err;
-  }
-  #dispatch(request, executionCtx, env, method) {
-    if (method === "HEAD") {
-      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
-    }
-    const path2 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path2);
-    const c = new Context(request, {
-      path: path2,
-      matchResult,
-      env,
-      executionCtx,
-      notFoundHandler: this.#notFoundHandler
-    });
-    if (matchResult[0].length === 1) {
-      let res;
-      try {
-        res = matchResult[0][0][0][0](c, async () => {
-          c.res = await this.#notFoundHandler(c);
-        });
-      } catch (err) {
-        return this.#handleError(err, c);
-      }
-      return res instanceof Promise ? res.then(
-        (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
-      ).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
-    }
-    const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
-    return (async () => {
-      try {
-        const context = await composed(c);
-        if (!context.finalized) {
-          throw new Error(
-            "Context is not finalized. Did you forget to return a Response object or `await next()`?"
-          );
-        }
-        return context.res;
-      } catch (err) {
-        return this.#handleError(err, c);
-      }
-    })();
+  const [packageManagerInfo] = userAgent.match(/(\w+)\/(\d+\.\d+\.\d+)/) || [];
+  const [packageManager, version2] = packageManagerInfo?.split("/") ?? ["npm", null];
+  if (!packageManager) {
+    return {
+      packageManager: packageManagerCommands["npm"],
+      version: "0.0.0"
+    };
   }
-  fetch = (request, ...rest) => {
-    return this.#dispatch(request, rest[1], rest[0], request.method);
-  };
-  request = (input, requestInit, Env, executionCtx) => {
-    if (input instanceof Request) {
-      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
-    }
-    input = input.toString();
-    return this.fetch(
-      new Request(
-        /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`,
-        requestInit
-      ),
-      Env,
-      executionCtx
-    );
-  };
-  fire = () => {
-    addEventListener("fetch", (event) => {
-      event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
-    });
+  return {
+    packageManager: packageManagerCommands[packageManager],
+    version: version2 ?? "0.0.0"
   };
-};
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/reg-exp-router/index.js
-init_esm_shims();
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/reg-exp-router/router.js
-init_esm_shims();
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/reg-exp-router/node.js
-init_esm_shims();
-var LABEL_REG_EXP_STR = "[^/]+";
-var ONLY_WILDCARD_REG_EXP_STR = ".*";
-var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
-var PATH_ERROR = Symbol();
-var regExpMetaChars = new Set(".\\+*[^]$()");
-function compareKey(a, b) {
-  if (a.length === 1) {
-    return b.length === 1 ? a < b ? -1 : 1 : -1;
-  }
-  if (b.length === 1) {
-    return 1;
-  }
-  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
-    return 1;
-  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
-    return -1;
-  }
-  if (a === LABEL_REG_EXP_STR) {
-    return 1;
-  } else if (b === LABEL_REG_EXP_STR) {
-    return -1;
-  }
-  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
 }
-var Node = class {
-  #index;
-  #varIndex;
-  #children = /* @__PURE__ */ Object.create(null);
-  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
-    if (tokens.length === 0) {
-      if (this.#index !== void 0) {
-        throw PATH_ERROR;
-      }
-      if (pathErrorCheckOnly) {
-        return;
-      }
-      this.#index = index;
-      return;
+
+// src/BuildCommand/build.ts
+async function build({ distDirname, cache }) {
+  const config = await loadConfig();
+  const rootDir = process.cwd();
+  const reactNativeProjectDir = path.resolve(__dirname, "..", "react-native");
+  const projectRootTmp = path.resolve(process.cwd(), ".apps-in-toss");
+  await fs.promises.mkdir(projectRootTmp, { recursive: true });
+  await fs.promises.writeFile(
+    path.join(projectRootTmp, "metadata.json"),
+    JSON.stringify({ appName: config.appName, webPort: config.web.port })
+  );
+  const appName = config.appName;
+  const { packageManager } = getPackageManager({ isExecutor: true });
+  const distDir = path.join(rootDir, distDirname);
+  const webDistDir = path.join(distDir, "web");
+  await fs.promises.rm(distDir, { recursive: true, force: true });
+  await execa(packageManager, config.web.commands.build.split(" "), {
+    cwd: process.cwd(),
+    stdio: "inherit"
+  });
+  await fs.promises.mkdir(webDistDir, { recursive: true });
+  const items = await fs.promises.readdir(distDir);
+  for (const item of items) {
+    const src = path.join(distDir, item);
+    const dest = path.join(webDistDir, item);
+    if (src === webDistDir) {
+      continue;
     }
-    const [token, ...restTokens] = tokens;
-    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-    let node;
-    if (pattern) {
-      const name = pattern[1];
-      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
-      if (name && pattern[2]) {
-        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
-        if (/\((?!\?:)/.test(regexpStr)) {
-          throw PATH_ERROR;
-        }
-      }
-      node = this.#children[regexpStr];
-      if (!node) {
-        if (Object.keys(this.#children).some(
-          (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
-        )) {
-          throw PATH_ERROR;
-        }
-        if (pathErrorCheckOnly) {
-          return;
-        }
-        node = this.#children[regexpStr] = new Node();
-        if (name !== "") {
-          node.#varIndex = context.varIndex++;
-        }
-      }
-      if (!pathErrorCheckOnly && name !== "") {
-        paramMap.push([name, node.#varIndex]);
-      }
-    } else {
-      node = this.#children[token];
-      if (!node) {
-        if (Object.keys(this.#children).some(
-          (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
-        )) {
-          throw PATH_ERROR;
+    await fs.promises.rename(src, dest);
+  }
+  const buildResults = await mpack.runBundle({
+    clean: false,
+    metafile: false,
+    dev: false,
+    rootDir: reactNativeProjectDir,
+    cache,
+    plugins: [statusPlugin],
+    config: {
+      appName,
+      services: {
+        sentry: {
+          enabled: false
         }
-        if (pathErrorCheckOnly) {
-          return;
+      },
+      concurrency: 2,
+      tasks: [
+        {
+          tag: `${appName}-ios`,
+          presets: [presets.service()],
+          build: {
+            babel: {
+              conditions: [(_code) => _code.includes("Ait")],
+              plugins: [
+                [
+                  __require.resolve("@apps-in-toss/babel-plugin-json"),
+                  { jsonPath: "./.apps-in-toss/metadata.json", identifierName: "Ait" }
+                ]
+              ]
+            },
+            platform: "ios",
+            entry: path.join(reactNativeProjectDir, "src", "_app.tsx"),
+            outfile: path.join(distDir, `${appName}.ios.js`)
+          }
+        },
+        {
+          tag: `${appName}-android`,
+          presets: [presets.service()],
+          build: {
+            babel: {
+              conditions: [(_code) => _code.includes("Ait")],
+              plugins: [
+                [
+                  __require.resolve("@apps-in-toss/babel-plugin-json"),
+                  { jsonPath: "./.apps-in-toss/metadata.json", identifierName: "Ait" }
+                ]
+              ]
+            },
+            platform: "android",
+            entry: path.join(reactNativeProjectDir, "src", "_app.tsx"),
+            outfile: path.join(distDir, `${appName}.android.js`)
+          }
         }
-        node = this.#children[token] = new Node();
-      }
+      ]
     }
-    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
+  });
+  const artifactOutfile = await createArtifact({
+    buildResults,
+    rootDir,
+    reactNativeProjectDir,
+    webOutDir: webDistDir
+  });
+  if (!artifactOutfile) {
+    throw new Error("\uC544\uD2F0\uD329\uD2B8 \uC0DD\uC131\uC5D0 \uC2E4\uD328\uD588\uC5B4\uC694.");
   }
-  buildRegExpStr() {
-    const childKeys = Object.keys(this.#children).sort(compareKey);
-    const strList = childKeys.map((k) => {
-      const c = this.#children[k];
-      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+  return artifactOutfile;
+}
+
+// src/constants.ts
+var APP_MANIFEST_NAME = "app.json";
+var DEFAULT_DIST_DIR = "dist";
+var API_BASE_URL = "https://apps-in-toss.toss.im/console";
+var DEFAULT_LOCALHOST_PORT = 8081;
+var DEFAULT_HOST = "localhost";
+
+// src/BuildCommand/BuildCommand.ts
+var BuildCommand = class extends Command {
+  static paths = [[`build`]];
+  static usage = Command.Usage({
+    category: "Build",
+    description: "Apps In Toss \uBE4C\uB4DC \uC544\uD2F0\uD329\uD2B8\uB97C \uC0DD\uC131\uD569\uB2C8\uB2E4",
+    examples: [["\uBE4C\uB4DC \uC544\uD2F0\uD329\uD2B8 \uC0DD\uC131\uD558\uAE30", "ait build"]]
+  });
+  cache = Option.Boolean("--cache", true);
+  async execute() {
+    const artifactOutfile = await build({
+      distDirname: DEFAULT_DIST_DIR,
+      cache: this.cache
     });
-    if (typeof this.#index === "number") {
-      strList.unshift(`#${this.#index}`);
-    }
-    if (strList.length === 0) {
-      return "";
-    }
-    if (strList.length === 1) {
-      return strList[0];
-    }
-    return "(?:" + strList.join("|") + ")";
+    console.log(`
+${picocolors.blue(artifactOutfile)}
+`);
   }
 };
 
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/reg-exp-router/trie.js
-init_esm_shims();
-var Trie = class {
-  #context = { varIndex: 0 };
-  #root = new Node();
-  insert(path2, index, pathErrorCheckOnly) {
-    const paramAssoc = [];
-    const groups = [];
-    for (let i = 0; ; ) {
-      let replaced = false;
-      path2 = path2.replace(/\{[^}]+\}/g, (m) => {
-        const mark = `@\\${i}`;
-        groups[i] = [mark, m];
-        i++;
-        replaced = true;
-        return mark;
-      });
-      if (!replaced) {
-        break;
-      }
-    }
-    const tokens = path2.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
-    for (let i = groups.length - 1; i >= 0; i--) {
-      const [mark] = groups[i];
-      for (let j = tokens.length - 1; j >= 0; j--) {
-        if (tokens[j].indexOf(mark) !== -1) {
-          tokens[j] = tokens[j].replace(mark, groups[i][1]);
-          break;
-        }
-      }
-    }
-    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
-    return paramAssoc;
-  }
-  buildRegExp() {
-    let regexp = this.#root.buildRegExpStr();
-    if (regexp === "") {
-      return [/^$/, [], []];
+// src/DeployCommand/DeployCommand.ts
+import assert from "assert";
+import path2 from "path";
+import * as p from "@clack/prompts";
+import { Command as Command2, Option as Option2 } from "clipanion";
+import Debug2 from "debug";
+import picocolors2 from "picocolors";
+
+// src/DeployCommand/upload.ts
+import * as fs2 from "fs";
+import Debug from "debug";
+var debug = Debug("cli:deploy");
+async function uploadArtifact(config) {
+  debug("uploadArtifact", config);
+  const response = await fetch(
+    `${API_BASE_URL}/api-public/v3/appsintossconsole/bundles/${config.appName}/sandbox/upload`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/octet-stream",
+        "X-Ait-Console-Api-Key": config.apiKey
+      },
+      body: fs2.createReadStream(config.artifactPath),
+      duplex: "half"
     }
-    let captureIndex = 0;
-    const indexReplacementMap = [];
-    const paramReplacementMap = [];
-    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
-      if (handlerIndex !== void 0) {
-        indexReplacementMap[++captureIndex] = Number(handlerIndex);
-        return "$()";
-      }
-      if (paramIndex !== void 0) {
-        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
-        return "";
+  );
+  return handleResponse(response);
+}
+async function handleResponse(response) {
+  debug(`Response ${response.status} ${response.statusText}`);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+  const data = await response.clone().json();
+  debug("uploadArtifact response", data);
+  if (data.resultType !== "SUCCESS") {
+    const errorCode = data?.error?.errorCode ?? "-1";
+    const errorReason = data?.error.reason ?? "unknown";
+    throw new Error(`${errorReason} (Code: ${errorCode})`);
+  }
+  const result = data.success;
+  return result.deploymentId;
+}
+
+// src/utils/readZipContent.ts
+import yauzl from "yauzl";
+function readZipContent(zipPath, fileName) {
+  return new Promise((resolve, reject) => {
+    yauzl.open(zipPath, { lazyEntries: true }, (error, zipFile) => {
+      if (error) {
+        reject(error);
+        return;
       }
-      return "";
+      zipFile.on("entry", (entry) => {
+        if (entry.fileName === fileName) {
+          zipFile.openReadStream(entry, (error2, readStream) => {
+            if (error2) {
+              throw error2;
+            }
+            let fileData = "";
+            readStream.on("data", (chunk) => fileData += chunk.toString("utf8")).on("end", () => {
+              zipFile.close();
+              resolve(fileData);
+            });
+          });
+        } else {
+          zipFile.readEntry();
+        }
+      }).on("end", () => {
+        zipFile.close();
+        reject(new Error(`'${fileName}' not found in zip file`));
+      }).on("error", (error2) => {
+        zipFile.close();
+        reject(error2);
+      });
+      zipFile.readEntry();
     });
-    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
-  }
-};
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/reg-exp-router/router.js
-var emptyParam = [];
-var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
-var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-function buildWildcardRegExp(path2) {
-  return wildcardRegExpCache[path2] ??= new RegExp(
-    path2 === "*" ? "" : `^${path2.replace(
-      /\/\*$|([.\\+*[^\]$()])/g,
-      (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
-    )}$`
-  );
-}
-function clearWildcardRegExpCache() {
-  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+  });
 }
-function buildMatcherFromPreprocessedRoutes(routes) {
-  const trie = new Trie();
-  const handlerData = [];
-  if (routes.length === 0) {
-    return nullMatcher;
-  }
-  const routesWithStaticPathFlag = routes.map(
-    (route) => [!/\*|\/:/.test(route[0]), ...route]
-  ).sort(
-    ([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
-  );
-  const staticMap = /* @__PURE__ */ Object.create(null);
-  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-    const [pathErrorCheckOnly, path2, handlers] = routesWithStaticPathFlag[i];
-    if (pathErrorCheckOnly) {
-      staticMap[path2] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
-    } else {
-      j++;
-    }
-    let paramAssoc;
-    try {
-      paramAssoc = trie.insert(path2, j, pathErrorCheckOnly);
-    } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path2) : e;
-    }
-    if (pathErrorCheckOnly) {
-      continue;
-    }
-    handlerData[j] = handlers.map(([h, paramCount]) => {
-      const paramIndexMap = /* @__PURE__ */ Object.create(null);
-      paramCount -= 1;
-      for (; paramCount >= 0; paramCount--) {
-        const [key, value] = paramAssoc[paramCount];
-        paramIndexMap[key] = value;
+
+// src/DeployCommand/DeployCommand.ts
+var debug2 = Debug2("cli:deploy");
+var DeployCommand = class extends Command2 {
+  static paths = [["deploy"]];
+  apiKey = Option2.String("--api-key", {
+    required: false,
+    description: "\uC54C\uD30C \uBC30\uD3EC\uB97C \uC704\uD55C API \uD0A4"
+  });
+  async execute() {
+    const apiKey = this.apiKey || await p.password({
+      message: "\uC571\uC778\uD1A0\uC2A4 \uBC30\uD3EC API \uD0A4\uB97C \uC785\uB825\uD574\uC8FC\uC138\uC694",
+      validate: (value) => {
+        if (value.length === 0) {
+          return "API \uD0A4\uB294 \uD544\uC218 \uC785\uB825 \uD56D\uBAA9\uC785\uB2C8\uB2E4.";
+        }
+        return;
       }
-      return [h, paramIndexMap];
     });
-  }
-  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-  for (let i = 0, len = handlerData.length; i < len; i++) {
-    for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
-      const map = handlerData[i][j]?.[1];
-      if (!map) {
-        continue;
-      }
-      const keys = Object.keys(map);
-      for (let k = 0, len3 = keys.length; k < len3; k++) {
-        map[keys[k]] = paramReplacementMap[map[keys[k]]];
-      }
-    }
-  }
-  const handlerMap = [];
-  for (const i in indexReplacementMap) {
-    handlerMap[i] = handlerData[indexReplacementMap[i]];
-  }
-  return [regexp, handlerMap, staticMap];
-}
-function findMiddleware(middleware, path2) {
-  if (!middleware) {
-    return void 0;
-  }
-  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path2)) {
-      return [...middleware[k]];
-    }
-  }
-  return void 0;
-}
-var RegExpRouter = class {
-  name = "RegExpRouter";
-  #middleware;
-  #routes;
-  constructor() {
-    this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-    this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-  }
-  add(method, path2, handler) {
-    const middleware = this.#middleware;
-    const routes = this.#routes;
-    if (!middleware || !routes) {
-      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-    }
-    if (!middleware[method]) {
-      ;
-      [middleware, routes].forEach((handlerMap) => {
-        handlerMap[method] = /* @__PURE__ */ Object.create(null);
-        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
-          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
-        });
-      });
-    }
-    if (path2 === "/*") {
-      path2 = "*";
+    if (p.isCancel(apiKey)) {
+      return;
     }
-    const paramCount = (path2.match(/\/:/g) || []).length;
-    if (/\*$/.test(path2)) {
-      const re = buildWildcardRegExp(path2);
-      if (method === METHOD_NAME_ALL) {
-        Object.keys(middleware).forEach((m) => {
-          middleware[m][path2] ||= findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || [];
-        });
-      } else {
-        middleware[method][path2] ||= findMiddleware(middleware[method], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || [];
-      }
-      Object.keys(middleware).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          Object.keys(middleware[m]).forEach((p) => {
-            re.test(p) && middleware[m][p].push([handler, paramCount]);
-          });
-        }
+    try {
+      const artifactOutfile = await build({
+        distDirname: DEFAULT_DIST_DIR,
+        cache: false
       });
-      Object.keys(routes).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          Object.keys(routes[m]).forEach(
-            (p) => re.test(p) && routes[m][p].push([handler, paramCount])
-          );
-        }
+      const rootDir = process.cwd();
+      const resolvedArtifactPath = path2.resolve(rootDir, artifactOutfile);
+      const appIdentifier = await readZipContent(resolvedArtifactPath, APP_MANIFEST_NAME).then((rawAppManifest) => {
+        const appManifest = JSON.parse(rawAppManifest);
+        const appIdentifier2 = appManifest.appName;
+        assert(typeof appIdentifier2 === "string", "invalid appName");
+        return appIdentifier2;
+      }).catch((error) => {
+        debug2("invalid ait file", error);
+        throw new Error("\uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 ait \uD30C\uC77C\uC785\uB2C8\uB2E4");
       });
-      return;
-    }
-    const paths = checkOptionalParameter(path2) || [path2];
-    for (let i = 0, len = paths.length; i < len; i++) {
-      const path22 = paths[i];
-      Object.keys(routes).forEach((m) => {
-        if (method === METHOD_NAME_ALL || method === m) {
-          routes[m][path22] ||= [
-            ...findMiddleware(middleware[m], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || []
-          ];
-          routes[m][path22].push([handler, paramCount - len + i + 1]);
+      let deploymentId = null;
+      const colorAppName = picocolors2.underline(picocolors2.cyan(appIdentifier));
+      await p.tasks([
+        {
+          title: `${colorAppName} \uC571 \uBC30\uD3EC \uC911...`,
+          task: async () => {
+            deploymentId = await uploadArtifact({
+              artifactPath: resolvedArtifactPath,
+              appName: appIdentifier,
+              apiKey
+            });
+            return `${colorAppName} \uBC30\uD3EC\uAC00 \uC644\uB8CC\uB418\uC5C8\uC5B4\uC694`;
+          }
         }
-      });
-    }
-  }
-  match(method, path2) {
-    clearWildcardRegExpCache();
-    const matchers = this.#buildAllMatchers();
-    this.match = (method2, path22) => {
-      const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
-      const staticMatch = matcher[2][path22];
-      if (staticMatch) {
-        return staticMatch;
-      }
-      const match = path22.match(matcher[0]);
-      if (!match) {
-        return [[], emptyParam];
+      ]);
+      if (deploymentId) {
+        p.note(`Deployment ID: ${picocolors2.underline(picocolors2.green(deploymentId))}`);
       }
-      const index = match.indexOf("", 1);
-      return [matcher[1][index], match];
-    };
-    return this.match(method, path2);
-  }
-  #buildAllMatchers() {
-    const matchers = /* @__PURE__ */ Object.create(null);
-    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
-      matchers[method] ||= this.#buildMatcher(method);
-    });
-    this.#middleware = this.#routes = void 0;
-    return matchers;
-  }
-  #buildMatcher(method) {
-    const routes = [];
-    let hasOwnRoute = method === METHOD_NAME_ALL;
-    [this.#middleware, this.#routes].forEach((r) => {
-      const ownRoute = r[method] ? Object.keys(r[method]).map((path2) => [path2, r[method][path2]]) : [];
-      if (ownRoute.length !== 0) {
-        hasOwnRoute ||= true;
-        routes.push(...ownRoute);
-      } else if (method !== METHOD_NAME_ALL) {
-        routes.push(
-          ...Object.keys(r[METHOD_NAME_ALL]).map((path2) => [path2, r[METHOD_NAME_ALL][path2]])
-        );
+    } catch (error) {
+      if (error instanceof Error) {
+        p.log.error(error.message);
+      } else {
+        console.error(error);
       }
-    });
-    if (!hasOwnRoute) {
-      return null;
-    } else {
-      return buildMatcherFromPreprocessedRoutes(routes);
+      process.exit(1);
     }
   }
 };
 
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/smart-router/index.js
-init_esm_shims();
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/smart-router/router.js
-init_esm_shims();
-var SmartRouter = class {
-  name = "SmartRouter";
-  #routers = [];
-  #routes = [];
-  constructor(init) {
-    this.#routers = init.routers;
-  }
-  add(method, path2, handler) {
-    if (!this.#routes) {
-      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-    }
-    this.#routes.push([method, path2, handler]);
-  }
-  match(method, path2) {
-    if (!this.#routes) {
-      throw new Error("Fatal error");
-    }
-    const routers = this.#routers;
-    const routes = this.#routes;
-    const len = routers.length;
-    let i = 0;
-    let res;
-    for (; i < len; i++) {
-      const router = routers[i];
-      try {
-        for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
-          router.add(...routes[i2]);
-        }
-        res = router.match(method, path2);
-      } catch (e) {
-        if (e instanceof UnsupportedPathError) {
-          continue;
-        }
-        throw e;
+// src/DevCommand/DevCommand.ts
+import fs3 from "fs";
+import path3 from "path";
+import * as mpack2 from "@react-native-bedrock/mpack-next";
+import { Command as Command3, Option as Option3 } from "clipanion";
+import { execa as execa2 } from "execa";
+import presets2 from "react-native-bedrock/presets";
+var DevCommand = class extends Command3 {
+  static paths = [[`dev`]];
+  static usage = Command3.Usage({
+    category: "Development",
+    description: "AppsInToss \uAC1C\uBC1C \uC11C\uBC84\uB97C \uC2E4\uD589\uD569\uB2C8\uB2E4",
+    examples: [["\uAC1C\uBC1C \uC11C\uBC84 \uC2E4\uD589\uD558\uAE30", "ait dev"]]
+  });
+  host = Option3.String("--host");
+  port = Option3.String("--port");
+  async execute() {
+    const config = await loadConfig();
+    const serverOptions = {
+      host: this.host,
+      port: this.port ? parseInt(this.port, 10) : void 0
+    };
+    const cwd = path3.resolve(__dirname, "..", "react-native");
+    const projectRootTmp = path3.resolve(process.cwd(), ".apps-in-toss");
+    await fs3.promises.mkdir(projectRootTmp, { recursive: true });
+    await fs3.promises.writeFile(
+      path3.join(projectRootTmp, "metadata.json"),
+      JSON.stringify({ appName: config.appName, webPort: config.web.port })
+    );
+    const appName = config.appName;
+    await mpack2.runServer({
+      host: serverOptions.host,
+      port: serverOptions.port,
+      enableEmbeddedReactDevTools: true,
+      enableRouterGen: false,
+      onServerReady: async () => {
+        this.context.stdout.write(
+          `Server is running on http://${serverOptions.host || DEFAULT_HOST}:${serverOptions.port || DEFAULT_LOCALHOST_PORT}
+`
+        );
+        const { packageManager } = getPackageManager({ isExecutor: true });
+        await execa2(packageManager, config.web.commands.dev.split(" "), {
+          cwd: process.cwd(),
+          stdio: "inherit"
+        });
+      },
+      cwd,
+      config: {
+        appName,
+        services: {
+          sentry: {
+            enabled: false
+          }
+        },
+        devServer: {
+          presets: [presets2.service()],
+          build: {
+            entry: "./src/_app.tsx"
+          }
+        },
+        tasks: []
       }
-      this.match = router.match.bind(router);
-      this.#routers = [router];
-      this.#routes = void 0;
-      break;
-    }
-    if (i === len) {
-      throw new Error("Fatal error");
-    }
-    this.name = `SmartRouter + ${this.activeRouter.name}`;
-    return res;
-  }
-  get activeRouter() {
-    if (this.#routes || this.#routers.length !== 1) {
-      throw new Error("No active router has been determined yet.");
-    }
-    return this.#routers[0];
+    });
   }
 };
 
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/trie-router/index.js
-init_esm_shims();
+// src/InitCommand/InitCommand.ts
+import fs4 from "fs";
+import path4 from "path";
+import * as p2 from "@clack/prompts";
+import { Command as Command4 } from "clipanion";
+import { kebabCase } from "es-toolkit";
 
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/trie-router/router.js
-init_esm_shims();
+// src/InitCommand/templates/index.tsx
+var CONFIG_TEMPLATE = `import { defineConfig } from '@apps-in-toss/web-framework';
 
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/trie-router/node.js
-init_esm_shims();
-var emptyParams = /* @__PURE__ */ Object.create(null);
-var Node2 = class {
-  #methods;
-  #children;
-  #patterns;
-  #order = 0;
-  #params = emptyParams;
-  constructor(method, handler, children) {
-    this.#children = children || /* @__PURE__ */ Object.create(null);
-    this.#methods = [];
-    if (method && handler) {
-      const m = /* @__PURE__ */ Object.create(null);
-      m[method] = { handler, possibleKeys: [], score: 0 };
-      this.#methods = [m];
-    }
-    this.#patterns = [];
-  }
-  insert(method, path2, handler) {
-    this.#order = ++this.#order;
-    let curNode = this;
-    const parts = splitRoutingPath(path2);
-    const possibleKeys = [];
-    for (let i = 0, len = parts.length; i < len; i++) {
-      const p = parts[i];
-      const nextP = parts[i + 1];
-      const pattern = getPattern(p, nextP);
-      const key = Array.isArray(pattern) ? pattern[0] : p;
-      if (Object.keys(curNode.#children).includes(key)) {
-        curNode = curNode.#children[key];
-        const pattern2 = getPattern(p, nextP);
-        if (pattern2) {
-          possibleKeys.push(pattern2[1]);
-        }
-        continue;
-      }
-      curNode.#children[key] = new Node2();
-      if (pattern) {
-        curNode.#patterns.push(pattern);
-        possibleKeys.push(pattern[1]);
-      }
-      curNode = curNode.#children[key];
-    }
-    const m = /* @__PURE__ */ Object.create(null);
-    const handlerSet = {
-      handler,
-      possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-      score: this.#order
-    };
-    m[method] = handlerSet;
-    curNode.#methods.push(m);
-    return curNode;
-  }
-  #getHandlerSets(node, method, nodeParams, params) {
-    const handlerSets = [];
-    for (let i = 0, len = node.#methods.length; i < len; i++) {
-      const m = node.#methods[i];
-      const handlerSet = m[method] || m[METHOD_NAME_ALL];
-      const processedSet = {};
-      if (handlerSet !== void 0) {
-        handlerSet.params = /* @__PURE__ */ Object.create(null);
-        handlerSets.push(handlerSet);
-        if (nodeParams !== emptyParams || params && params !== emptyParams) {
-          for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
-            const key = handlerSet.possibleKeys[i2];
-            const processed = processedSet[handlerSet.score];
-            handlerSet.params[key] = params?.[key] && !processed ? params[key] : nodeParams[key] ?? params?.[key];
-            processedSet[handlerSet.score] = true;
-          }
-        }
-      }
-    }
-    return handlerSets;
+export default defineConfig({
+  appName: '%%appName%%',
+  web: {
+    port: %%webPort%%,
+    commands: {
+      dev: '%%webDevCommand%%',
+      build: '%%webBuildCommand%%',
+    },
+  },
+});
+`;
+
+// src/utils/transformTemplate.ts
+function transformTemplate(templateString, values) {
+  let result = templateString;
+  for (const key in values) {
+    const placeholder = `%%${key}%%`;
+    result = result.replace(new RegExp(placeholder, "g"), values[key]);
   }
-  search(method, path2) {
-    const handlerSets = [];
-    this.#params = emptyParams;
-    const curNode = this;
-    let curNodes = [curNode];
-    const parts = splitPath(path2);
-    const curNodesQueue = [];
-    for (let i = 0, len = parts.length; i < len; i++) {
-      const part = parts[i];
-      const isLast = i === len - 1;
-      const tempNodes = [];
-      for (let j = 0, len2 = curNodes.length; j < len2; j++) {
-        const node = curNodes[j];
-        const nextNode = node.#children[part];
-        if (nextNode) {
-          nextNode.#params = node.#params;
-          if (isLast) {
-            if (nextNode.#children["*"]) {
-              handlerSets.push(
-                ...this.#getHandlerSets(nextNode.#children["*"], method, node.#params)
-              );
-            }
-            handlerSets.push(...this.#getHandlerSets(nextNode, method, node.#params));
-          } else {
-            tempNodes.push(nextNode);
-          }
+  return result;
+}
+
+// src/InitCommand/InitCommand.ts
+var InitCommand = class extends Command4 {
+  static paths = [[`init`]];
+  async execute() {
+    p2.intro("\u{1F680} \uC571 \uCD08\uAE30\uD654\uB97C \uC2DC\uC791\uD569\uB2C8\uB2E4");
+    const appName = await p2.text({
+      message: "Enter app name",
+      validate: (value) => {
+        if (!value) {
+          return "\uC571 \uC774\uB984\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694";
         }
-        for (let k = 0, len3 = node.#patterns.length; k < len3; k++) {
-          const pattern = node.#patterns[k];
-          const params = node.#params === emptyParams ? {} : { ...node.#params };
-          if (pattern === "*") {
-            const astNode = node.#children["*"];
-            if (astNode) {
-              handlerSets.push(...this.#getHandlerSets(astNode, method, node.#params));
-              astNode.#params = params;
-              tempNodes.push(astNode);
-            }
-            continue;
-          }
-          if (part === "") {
-            continue;
-          }
-          const [key, name, matcher] = pattern;
-          const child = node.#children[key];
-          const restPathString = parts.slice(i).join("/");
-          if (matcher instanceof RegExp) {
-            const m = matcher.exec(restPathString);
-            if (m) {
-              params[name] = m[0];
-              handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
-              if (Object.keys(child.#children).length) {
-                child.#params = params;
-                const componentCount = m[0].match(/\//)?.length ?? 0;
-                const targetCurNodes = curNodesQueue[componentCount] ||= [];
-                targetCurNodes.push(child);
-              }
-              continue;
-            }
-          }
-          if (matcher === true || matcher.test(part)) {
-            params[name] = part;
-            if (isLast) {
-              handlerSets.push(...this.#getHandlerSets(child, method, params, node.#params));
-              if (child.#children["*"]) {
-                handlerSets.push(
-                  ...this.#getHandlerSets(child.#children["*"], method, params, node.#params)
-                );
-              }
-            } else {
-              child.#params = params;
-              tempNodes.push(child);
-            }
-          }
+        const kebabCaseValue = kebabCase(value);
+        if (value !== kebabCaseValue) {
+          return `\uC571 \uC774\uB984\uC740 \uCF00\uBC25-\uCF00\uC774\uC2A4 \uD615\uC2DD\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4 (\uC608\uC2DC: ${kebabCaseValue})`;
         }
+        return;
       }
-      curNodes = tempNodes.concat(curNodesQueue.shift() ?? []);
-    }
-    if (handlerSets.length > 1) {
-      handlerSets.sort((a, b) => {
-        return a.score - b.score;
-      });
+    });
+    if (p2.isCancel(appName)) {
+      p2.cancel("\uCD08\uAE30\uD654\uAC00 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4");
+      return;
     }
-    return [handlerSets.map(({ handler, params }) => [handler, params])];
-  }
-};
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/trie-router/router.js
-var TrieRouter = class {
-  name = "TrieRouter";
-  #node;
-  constructor() {
-    this.#node = new Node2();
-  }
-  add(method, path2, handler) {
-    const results = checkOptionalParameter(path2);
-    if (results) {
-      for (let i = 0, len = results.length; i < len; i++) {
-        this.#node.insert(method, results[i], handler);
-      }
+    p2.log.step(`\uC571 \uC774\uB984\uC774 '${appName}'\uC73C\uB85C \uC124\uC815\uB418\uC5C8\uC2B5\uB2C8\uB2E4`);
+    const webPort = await p2.text({
+      message: "Enter web port",
+      placeholder: "5173",
+      defaultValue: "5173"
+    });
+    if (p2.isCancel(webPort)) {
+      p2.cancel("\uCD08\uAE30\uD654\uAC00 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4");
       return;
     }
-    this.#node.insert(method, path2, handler);
-  }
-  match(method, path2) {
-    return this.#node.search(method, path2);
-  }
-};
-
-// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/hono.js
-var Hono2 = class extends Hono {
-  constructor(options = {}) {
-    super(options);
-    this.router = options.router ?? new SmartRouter({
-      routers: [new RegExpRouter(), new TrieRouter()]
+    p2.log.step("package.json \uC2A4\uD06C\uB9BD\uD2B8\uB97C \uC124\uC815\uD558\uB294 \uC911...");
+    const packageJson = await fs4.promises.readFile(path4.join(process.cwd(), "package.json"), {
+      encoding: "utf-8"
     });
-  }
-};
-
-// src/server.ts
-var app = new Hono2();
-app.get("/status", (c) => {
-  c.header("X-React-Native-Project-Root", path.resolve(__dirname, "..", "react-native"));
-  return c.text("packager-status:running");
-});
-app.get("/permissions", (c) => {
-  return c.text("contacts:rw");
-});
-app.get("/oauth/scope", (c) => {
-  return c.text("user_email;user_name");
-});
-app.get("/index.bundle", async (c) => {
-  const platform = c.req.query("platform");
-  const bundle = fs.readFileSync(path.resolve(__dirname, "..", "dist", `app-name.${platform}.js`), "utf-8");
-  c.header("Surrogate-Control", "no-store");
-  c.header("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
-  c.header("Pragma", "no-cache");
-  c.header("Expires", "0");
-  c.header("Content-Type", "application/javascript");
-  const result = await transform(bundle, {
-    plugins: [
-      [
-        "@apps-in-toss/babel-plugin-json",
-        {
-          json: {
-            appName: "web-framework",
-            webPort: 5173
-          },
-          identifierName: "Ait"
-        }
-      ]
-    ]
-  });
-  if (!result?.code) {
-    return c.text("Error", 500);
-  }
-  return c.body(result.code);
-});
-
-// src/commands/DevCommand.ts
-var DevCommand = class extends Command {
-  static paths = [[`dev`]];
-  static usage = Command.Usage({
-    category: "Development",
-    description: "Bedrock \uAC1C\uBC1C \uC11C\uBC84\uB97C \uC2E4\uD589\uD569\uB2C8\uB2E4",
-    examples: [["\uAC1C\uBC1C \uC11C\uBC84 \uC2E4\uD589\uD558\uAE30", "bedrock dev"]]
-  });
-  async execute() {
-    serve(
+    const scripts = JSON.parse(packageJson);
+    const original = {
+      dev: scripts?.scripts?.dev || scripts?.scripts?.start,
+      build: scripts?.scripts?.build
+    };
+    scripts.scripts.dev = "ait dev";
+    scripts.scripts.build = "ait build";
+    scripts.scripts.deploy = "ait deploy";
+    await fs4.promises.writeFile(path4.join(process.cwd(), "package.json"), JSON.stringify(scripts, null, 2), {
+      encoding: "utf-8"
+    });
+    p2.log.step("apps-in-toss.config.web.ts \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
+    const config = transformTemplate(CONFIG_TEMPLATE, {
+      appName,
+      webPort,
+      webDevCommand: original.dev === "ait dev" ? "" : original.dev,
+      webBuildCommand: original.build === "ait build" ? "" : original.build
+    });
+    await fs4.promises.writeFile(path4.join(process.cwd(), "apps-in-toss.config.web.ts"), config, {
+      encoding: "utf-8"
+    });
+    p2.log.step(".gitignore \uD30C\uC77C\uC744 \uC5C5\uB370\uC774\uD2B8\uD558\uB294 \uC911...");
+    await fs4.promises.appendFile(path4.join(process.cwd(), ".gitignore"), "\n.apps-in-toss\n");
+    p2.log.step("app.json \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
+    await fs4.promises.writeFile(
+      path4.join(process.cwd(), "app.json"),
+      JSON.stringify({
+        clientId: "",
+        appName,
+        permissions: []
+      }),
       {
-        hostname: "0.0.0.0",
-        fetch: app.fetch,
-        port: 8081
-      },
-      (info) => {
-        console.log(`Listening on http://localhost:${info.port}`);
+        encoding: "utf-8"
       }
     );
+    p2.outro("\u2728 \uCD08\uAE30\uD654\uAC00 \uC644\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4!");
   }
 };
 
+// package.json
+var version = "0.1.6-next.6";
+
 // src/cli.ts
 var cli = new Cli({
-  binaryLabel: "bedrock",
-  binaryName: "bedrock",
+  binaryLabel: "apps-in-toss",
+  binaryName: "apps-in-toss",
+  binaryVersion: version,
   enableCapture: true
 });
-async function initialize() {
-  cli.register(DevCommand);
-  cli.runExit(process.argv.slice(2));
-}
-export {
-  initialize
-};
+cli.register(InitCommand);
+cli.register(DevCommand);
+cli.register(BuildCommand);
+cli.register(DeployCommand);
+cli.runExit(process.argv.slice(2));