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

package/dist/cli.js

@@ -2,561 +2,3554 @@ import { createRequire } from 'module'; const require = createRequire(import.met
 import {
   __dirname,
   __require,
-  loadConfig
-} from "./chunk-HL7M3JLX.js";
+  init_esm_shims
+} from "./chunk-MHAJE5QI.js";
 
 // src/cli.ts
-import { Cli } from "clipanion";
+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/index.mjs
+init_esm_shims();
 
-// src/BuildCommand/build.ts
+// ../../.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 { 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"
+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;
+    }
   };
-  if (!userAgent) {
-    return {
-      packageManager: packageManagerCommands["npm"],
-      version: "0.0.0"
+};
+
+// ../../.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;
   }
-  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"
+  #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;
+  };
+  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();
+    };
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path2, "*"), handler);
+    return this;
   }
-  return {
-    packageManager: packageManagerCommands[packageManager],
-    version: version2 ?? "0.0.0"
+  #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);
+      }
+    })();
+  }
+  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));
+    });
+  };
+};
 
-// 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(), ".bedrock");
-  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;
+// ../../.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;
     }
-    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
+    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;
         }
-      },
-      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: "./.bedrock/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: "./.bedrock/metadata.json", identifierName: "Ait" }
-                ]
-              ]
-            },
-            platform: "android",
-            entry: path.join(reactNativeProjectDir, "src", "_app.tsx"),
-            outfile: path.join(distDir, `${appName}.android.js`)
-          }
+      }
+      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;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.#children[token] = new Node();
+      }
     }
-  });
-  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.");
+    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
   }
-  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
+  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();
     });
-    console.log(`
-${picocolors.blue(artifactOutfile)}
-`);
+    if (typeof this.#index === "number") {
+      strList.unshift(`#${this.#index}`);
+    }
+    if (strList.length === 0) {
+      return "";
+    }
+    if (strList.length === 1) {
+      return strList[0];
+    }
+    return "(?:" + strList.join("|") + ")";
   }
 };
 
-// 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"
+// ../../.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;
+      }
     }
-  );
-  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;
+    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;
+        }
       }
-      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();
+    }
+    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
+    return paramAssoc;
+  }
+  buildRegExp() {
+    let regexp = this.#root.buildRegExpStr();
+    if (regexp === "") {
+      return [/^$/, [], []];
+    }
+    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 "";
     });
-  });
-}
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+  }
+};
 
-// 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;
+// ../../.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;
       }
+      return [h, paramIndexMap];
     });
-    if (p.isCancel(apiKey)) {
-      return;
+  }
+  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]]];
+      }
     }
-    try {
-      const artifactOutfile = await build({
-        distDirname: DEFAULT_DIST_DIR,
-        cache: false
-      });
-      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");
+  }
+  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]];
+        });
       });
-      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`;
-          }
-        }
-      ]);
-      if (deploymentId) {
-        p.note(picocolors2.underline(picocolors2.green(`intoss-sandbox://${appIdentifier}?_deploymentId=${deploymentId}`)));
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        p.log.error(error.message);
+    }
+    if (path2 === "/*") {
+      path2 = "*";
+    }
+    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 {
-        console.error(error);
+        middleware[method][path2] ||= findMiddleware(middleware[method], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || [];
       }
-      process.exit(1);
+      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]);
+          });
+        }
+      });
+      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])
+          );
+        }
+      });
+      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]);
+        }
+      });
     }
   }
-};
-
-// 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
+  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];
+      }
+      const index = match.indexOf("", 1);
+      return [matcher[1][index], match];
     };
-    const cwd = path3.resolve(__dirname, "..", "react-native");
-    const projectRootTmp = path3.resolve(process.cwd(), ".bedrock");
-    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}
-`
+    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]])
         );
-        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: []
       }
     });
+    if (!hasOwnRoute) {
+      return null;
+    } else {
+      return buildMatcherFromPreprocessedRoutes(routes);
+    }
   }
 };
 
-// src/InitCommand/InitCommand.ts
-import fs5 from "fs";
-import path5 from "path";
-import * as p2 from "@clack/prompts";
-import { Command as Command4 } from "clipanion";
-import { kebabCase, merge } from "es-toolkit";
-import { execa as execa3 } from "execa";
-import yaml from "yaml";
-
-// src/InitCommand/templates/index.tsx
-var CONFIG_TEMPLATE = `import { defineConfig } from '@apps-in-toss/web-framework';
-
-export default defineConfig({
-  appName: '%%appName%%',
-  web: {
-    port: %%webPort%%,
-    commands: {
-      dev: '%%webDevCommand%%',
-      build: '%%webBuildCommand%%',
-    },
-  },
-});
-`;
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/smart-router/index.js
+init_esm_shims();
 
-// src/utils/getPackageRoot.ts
-import fs4 from "fs";
-import path4 from "path";
-function getPackageRoot() {
-  let cwd = process.cwd();
-  const root = path4.parse(cwd).root;
-  while (cwd !== root) {
-    if (fs4.existsSync(path4.join(cwd, "package.json"))) {
-      return cwd;
+// ../../.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);
     }
-    cwd = path4.dirname(cwd);
+    this.#routes.push([method, path2, handler]);
   }
-  return cwd;
-}
-
-// 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]);
+  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;
+      }
+      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;
   }
-  return result;
-}
+  get activeRouter() {
+    if (this.#routes || this.#routers.length !== 1) {
+      throw new Error("No active router has been determined yet.");
+    }
+    return this.#routers[0];
+  }
+};
 
-// src/InitCommand/InitCommand.ts
-var InitCommand = class extends Command4 {
-  static paths = [[`init`]];
-  async execute() {
-    const cwd = getPackageRoot();
-    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";
-        }
-        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})`;
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/trie-router/index.js
+init_esm_shims();
+
+// ../../.yarn/cache/hono-npm-4.7.4-9bd547bbac-b189c5b755.zip/node_modules/hono/dist/router/trie-router/router.js
+init_esm_shims();
+
+// ../../.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]);
         }
-        return;
+        continue;
       }
-    });
-    if (p2.isCancel(appName)) {
-      p2.cancel("\uCD08\uAE30\uD654\uAC00 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4");
-      return;
-    }
-    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;
+      curNode.#children[key] = new Node2();
+      if (pattern) {
+        curNode.#patterns.push(pattern);
+        possibleKeys.push(pattern[1]);
+      }
+      curNode = curNode.#children[key];
     }
-    p2.log.step("package.json \uC2A4\uD06C\uB9BD\uD2B8\uB97C \uC124\uC815\uD558\uB294 \uC911...");
-    const packageJson = await fs5.promises.readFile(path5.join(cwd, "package.json"), {
-      encoding: "utf-8"
-    });
-    const scripts = JSON.parse(packageJson);
-    const original = {
-      dev: scripts?.scripts?.dev || scripts?.scripts?.start,
-      build: scripts?.scripts?.build
+    const m = /* @__PURE__ */ Object.create(null);
+    const handlerSet = {
+      handler,
+      possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
+      score: this.#order
     };
-    scripts.scripts.dev = "ait dev";
-    scripts.scripts.build = "ait build";
-    scripts.scripts.deploy = "ait deploy";
-    await fs5.promises.writeFile(path5.join(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 fs5.promises.writeFile(path5.join(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 fs5.promises.appendFile(path5.join(cwd, ".gitignore"), "\n.bedrock\n");
-    p2.log.step("app.json \uD30C\uC77C\uC744 \uC0DD\uC131\uD558\uB294 \uC911...");
-    await fs5.promises.writeFile(
-      path5.join(cwd, "app.json"),
-      JSON.stringify({
-        clientId: "",
-        appName,
-        permissions: []
-      }),
-      {
-        encoding: "utf-8"
-      }
-    );
-    const isPnP = fs5.existsSync(path5.join(cwd, ".pnp.cjs"));
-    if (isPnP) {
-      const yarnrcPath = path5.join(cwd, ".yarnrc.yml");
-      let yarnrc = {};
-      try {
-        const yarnrcContent = await fs5.promises.readFile(yarnrcPath, { encoding: "utf-8" });
-        yarnrc = yaml.parse(yarnrcContent);
-      } catch {
-        p2.log.info(".yarnrc.yml \uD30C\uC77C\uC774 \uC5C6\uC5B4 \uC0C8\uB85C \uC0DD\uC131\uD569\uB2C8\uB2E4.");
+    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;
+          }
+        }
       }
-      p2.log.step(".yarnrc.yml \uD30C\uC77C\uC744 \uC5C5\uB370\uC774\uD2B8\uD558\uB294 \uC911...");
-      yarnrc.packageExtensions = merge(yarnrc.packageExtensions, {
-        "@react-native-community/cli-debugger-ui@*": {
-          dependencies: {
-            "@babel/runtime": "^7"
+    }
+    return handlerSets;
+  }
+  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);
+          }
+        }
+        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;
           }
-        },
-        "react-native-video@*": {
-          peerDependencies: {
-            react: "*",
-            "react-native": "*"
+          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;
+            }
           }
-        },
-        "react-native-fast-image@*": {
-          dependencies: {
-            "@babel/runtime": "^7"
+          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);
+            }
           }
         }
+      }
+      curNodes = tempNodes.concat(curNodesQueue.shift() ?? []);
+    }
+    if (handlerSets.length > 1) {
+      handlerSets.sort((a, b) => {
+        return a.score - b.score;
       });
-      await fs5.promises.writeFile(yarnrcPath, yaml.stringify(yarnrc), { encoding: "utf-8" });
-      await execa3("yarn", ["install"], {
-        cwd,
-        stdio: "inherit"
-      });
     }
-    p2.outro("\u2728 \uCD08\uAE30\uD654\uAC00 \uC644\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4!");
+    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);
+      }
+      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()]
+    });
   }
 };
 
-// package.json
-var version = "0.1.6-next.6";
+// 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(
+      {
+        hostname: "0.0.0.0",
+        fetch: app.fetch,
+        port: 8081
+      },
+      (info) => {
+        console.log(`Listening on http://localhost:${info.port}`);
+      }
+    );
+  }
+};
 
 // src/cli.ts
 var cli = new Cli({
-  binaryLabel: "apps-in-toss",
-  binaryName: "apps-in-toss",
-  binaryVersion: version,
+  binaryLabel: "bedrock",
+  binaryName: "bedrock",
   enableCapture: true
 });
-cli.register(InitCommand);
-cli.register(DevCommand);
-cli.register(BuildCommand);
-cli.register(DeployCommand);
-cli.runExit(process.argv.slice(2));
+async function initialize() {
+  cli.register(DevCommand);
+  cli.runExit(process.argv.slice(2));
+}
+export {
+  initialize
+};