rudel 0.1.1

package/dist/cli.js

@@ -0,0 +1,3933 @@
+#!/usr/bin/env bun
+// @bun
+
+// ../../node_modules/.bun/@stricli+core@1.2.5/node_modules/@stricli/core/dist/index.js
+function checkEnvironmentVariable(process2, varName) {
+  const value = process2.env?.[varName];
+  return typeof value === "string" && value !== "0";
+}
+var ExitCode = {
+  UnknownCommand: -5,
+  InvalidArgument: -4,
+  ContextLoadError: -3,
+  CommandLoadError: -2,
+  InternalError: -1,
+  Success: 0,
+  CommandRunError: 1
+};
+function convertKebabCaseToCamelCase(str) {
+  return str.replace(/-./g, (match) => match[1].toUpperCase());
+}
+function convertCamelCaseToKebabCase(name) {
+  return Array.from(name).map((char, i) => {
+    const upper = char.toUpperCase();
+    const lower = char.toLowerCase();
+    if (i === 0 || upper !== char || upper === lower) {
+      return char;
+    }
+    return `-${lower}`;
+  }).join("");
+}
+function newSparseMatrix(defaultValue) {
+  const values = /* @__PURE__ */ new Map;
+  return {
+    get: (...args) => {
+      return values.get(args.join(",")) ?? defaultValue;
+    },
+    set: (value, ...args) => {
+      values.set(args.join(","), value);
+    }
+  };
+}
+function damerauLevenshtein(a, b, options) {
+  const { threshold, weights } = options;
+  if (a === b) {
+    return 0;
+  }
+  const lengthDiff = Math.abs(a.length - b.length);
+  if (typeof threshold === "number" && lengthDiff > threshold) {
+    return Infinity;
+  }
+  const matrix = newSparseMatrix(Infinity);
+  matrix.set(0, -1, -1);
+  for (let j = 0;j < b.length; ++j) {
+    matrix.set((j + 1) * weights.insertion, -1, j);
+  }
+  for (let i = 0;i < a.length; ++i) {
+    matrix.set((i + 1) * weights.deletion, i, -1);
+  }
+  let prevRowMinDistance = -Infinity;
+  for (let i = 0;i < a.length; ++i) {
+    let rowMinDistance = Infinity;
+    for (let j = 0;j <= b.length - 1; ++j) {
+      const cost = a[i] === b[j] ? 0 : 1;
+      const distances = [
+        matrix.get(i - 1, j) + weights.deletion,
+        matrix.get(i, j - 1) + weights.insertion,
+        matrix.get(i - 1, j - 1) + cost * weights.substitution
+      ];
+      if (a[i] === b[j - 1] && a[i - 1] === b[j]) {
+        distances.push(matrix.get(i - 2, j - 2) + cost * weights.transposition);
+      }
+      const minDistance = Math.min(...distances);
+      matrix.set(minDistance, i, j);
+      if (minDistance < rowMinDistance) {
+        rowMinDistance = minDistance;
+      }
+    }
+    if (rowMinDistance > threshold) {
+      if (prevRowMinDistance > threshold) {
+        return Infinity;
+      }
+      prevRowMinDistance = rowMinDistance;
+    } else {
+      prevRowMinDistance = -Infinity;
+    }
+  }
+  const distance = matrix.get(a.length - 1, b.length - 1);
+  if (distance > threshold) {
+    return Infinity;
+  }
+  return distance;
+}
+function compareAlternatives(a, b, target) {
+  const cmp = a[1] - b[1];
+  if (cmp !== 0) {
+    return cmp;
+  }
+  const aStartsWith = a[0].startsWith(target);
+  const bStartsWith = b[0].startsWith(target);
+  if (aStartsWith && !bStartsWith) {
+    return -1;
+  } else if (!aStartsWith && bStartsWith) {
+    return 1;
+  }
+  return a[0].localeCompare(b[0]);
+}
+function filterClosestAlternatives(target, alternatives, options) {
+  const validAlternatives = alternatives.map((alt) => [alt, damerauLevenshtein(target, alt, options)]).filter(([, dist]) => dist <= options.threshold);
+  const minDistance = Math.min(...validAlternatives.map(([, dist]) => dist));
+  return validAlternatives.filter(([, dist]) => dist === minDistance).sort((a, b) => compareAlternatives(a, b, target)).map(([alt]) => alt);
+}
+var InternalError = class extends Error {
+};
+function formatException(exc) {
+  if (exc instanceof Error) {
+    return exc.stack ?? String(exc);
+  }
+  return String(exc);
+}
+function maximum(arr1, arr2) {
+  const maxValues = [];
+  const maxLength = Math.max(arr1.length, arr2.length);
+  for (let i = 0;i < maxLength; ++i) {
+    maxValues[i] = Math.max(arr1[i], arr2[i]);
+  }
+  return maxValues;
+}
+function formatRowsWithColumns(cells, separators) {
+  if (cells.length === 0) {
+    return [];
+  }
+  const startingLengths = Array(Math.max(...cells.map((cellRow) => cellRow.length))).fill(0, 0);
+  const maxLengths = cells.reduce((acc, cellRow) => {
+    const lengths = cellRow.map((cell) => cell.length);
+    return maximum(acc, lengths);
+  }, startingLengths);
+  return cells.map((cellRow) => {
+    const firstCell = (cellRow[0] ?? "").padEnd(maxLengths[0]);
+    return cellRow.slice(1).reduce((parts, str, i, arr) => {
+      const paddedStr = arr.length === i + 1 ? str : str.padEnd(maxLengths[i + 1]);
+      return [...parts, separators?.[i] ?? " ", paddedStr];
+    }, [firstCell]).join("").trimEnd();
+  });
+}
+function joinWithGrammar(parts, grammar) {
+  if (parts.length <= 1) {
+    return parts[0] ?? "";
+  }
+  if (parts.length === 2) {
+    return parts.join(` ${grammar.conjunction} `);
+  }
+  let allButLast = parts.slice(0, parts.length - 1).join(", ");
+  if (grammar.serialComma) {
+    allButLast += ",";
+  }
+  return [allButLast, grammar.conjunction, parts[parts.length - 1]].join(" ");
+}
+function group(array, callback) {
+  return array.reduce((groupings, item) => {
+    const key = callback(item);
+    const groupItems = groupings[key] ?? [];
+    groupItems.push(item);
+    groupings[key] = groupItems;
+    return groupings;
+  }, {});
+}
+function groupBy(array, selector) {
+  return group(array, (item) => item[selector]);
+}
+async function allSettledOrElse(values) {
+  const results = await Promise.allSettled(values);
+  const grouped = groupBy(results, "status");
+  if (grouped.rejected && grouped.rejected.length > 0) {
+    return { status: "rejected", reasons: grouped.rejected.map((result) => result.reason) };
+  }
+  return { status: "fulfilled", value: grouped.fulfilled?.map((result) => result.value) ?? [] };
+}
+var TRUTHY_VALUES = /* @__PURE__ */ new Set(["true", "t", "yes", "y", "on", "1"]);
+var FALSY_VALUES = /* @__PURE__ */ new Set(["false", "f", "no", "n", "off", "0"]);
+var looseBooleanParser = (input) => {
+  const value = input.toLowerCase();
+  if (TRUTHY_VALUES.has(value)) {
+    return true;
+  }
+  if (FALSY_VALUES.has(value)) {
+    return false;
+  }
+  throw new SyntaxError(`Cannot convert ${input} to a boolean`);
+};
+var numberParser = (input) => {
+  const value = Number(input);
+  if (Number.isNaN(value)) {
+    throw new SyntaxError(`Cannot convert ${input} to a number`);
+  }
+  return value;
+};
+var ArgumentScannerError = class extends InternalError {
+  _brand;
+};
+function formatMessageForArgumentScannerError(error, formatter) {
+  const errorType = error.constructor.name;
+  const formatError = formatter[errorType];
+  if (formatError) {
+    return formatError(error);
+  }
+  return error.message;
+}
+function resolveAliases(flags, aliases, scannerCaseStyle) {
+  return Object.fromEntries(Object.entries(aliases).map(([alias, internalFlagName_]) => {
+    const internalFlagName = internalFlagName_;
+    const flag = flags[internalFlagName];
+    if (!flag) {
+      const externalFlagName = asExternal(internalFlagName, scannerCaseStyle);
+      throw new FlagNotFoundError(externalFlagName, [], alias);
+    }
+    return [alias, [internalFlagName, flag]];
+  }));
+}
+var FlagNotFoundError = class extends ArgumentScannerError {
+  input;
+  corrections;
+  aliasName;
+  constructor(input, corrections, aliasName) {
+    let message = `No flag registered for --${input}`;
+    if (aliasName) {
+      message += ` (aliased from -${aliasName})`;
+    } else if (corrections.length > 0) {
+      const formattedCorrections = joinWithGrammar(corrections.map((correction) => `--${correction}`), {
+        kind: "conjunctive",
+        conjunction: "or",
+        serialComma: true
+      });
+      message += `, did you mean ${formattedCorrections}?`;
+    }
+    super(message);
+    this.input = input;
+    this.corrections = corrections;
+    this.aliasName = aliasName;
+  }
+};
+var AliasNotFoundError = class extends ArgumentScannerError {
+  input;
+  constructor(input) {
+    super(`No alias registered for -${input}`);
+    this.input = input;
+  }
+};
+function getPlaceholder(param, index) {
+  if (param.placeholder) {
+    return param.placeholder;
+  }
+  return typeof index === "number" ? `arg${index}` : "args";
+}
+function asExternal(internal, scannerCaseStyle) {
+  return scannerCaseStyle === "allow-kebab-for-camel" ? convertCamelCaseToKebabCase(internal) : internal;
+}
+var ArgumentParseError = class extends ArgumentScannerError {
+  externalFlagNameOrPlaceholder;
+  input;
+  exception;
+  constructor(externalFlagNameOrPlaceholder, input, exception) {
+    super(`Failed to parse "${input}" for ${externalFlagNameOrPlaceholder}: ${exception instanceof Error ? exception.message : String(exception)}`);
+    this.externalFlagNameOrPlaceholder = externalFlagNameOrPlaceholder;
+    this.input = input;
+    this.exception = exception;
+  }
+};
+function parseInput(externalFlagNameOrPlaceholder, parameter, input, context) {
+  try {
+    return parameter.parse.call(context, input);
+  } catch (exc) {
+    throw new ArgumentParseError(externalFlagNameOrPlaceholder, input, exc);
+  }
+}
+var EnumValidationError = class extends ArgumentScannerError {
+  externalFlagName;
+  input;
+  values;
+  constructor(externalFlagName, input, values, corrections) {
+    let message = `Expected "${input}" to be one of (${values.join("|")})`;
+    if (corrections.length > 0) {
+      const formattedCorrections = joinWithGrammar(corrections.map((str) => `"${str}"`), {
+        kind: "conjunctive",
+        conjunction: "or",
+        serialComma: true
+      });
+      message += `, did you mean ${formattedCorrections}?`;
+    }
+    super(message);
+    this.externalFlagName = externalFlagName;
+    this.input = input;
+    this.values = values;
+  }
+};
+var UnsatisfiedFlagError = class extends ArgumentScannerError {
+  externalFlagName;
+  nextFlagName;
+  constructor(externalFlagName, nextFlagName) {
+    let message = `Expected input for flag --${externalFlagName}`;
+    if (nextFlagName) {
+      message += ` but encountered --${nextFlagName} instead`;
+    }
+    super(message);
+    this.externalFlagName = externalFlagName;
+    this.nextFlagName = nextFlagName;
+  }
+};
+var UnexpectedPositionalError = class extends ArgumentScannerError {
+  expectedCount;
+  input;
+  constructor(expectedCount, input) {
+    super(`Too many arguments, expected ${expectedCount} but encountered "${input}"`);
+    this.expectedCount = expectedCount;
+    this.input = input;
+  }
+};
+var UnsatisfiedPositionalError = class extends ArgumentScannerError {
+  placeholder;
+  limit;
+  constructor(placeholder, limit) {
+    let message;
+    if (limit) {
+      message = `Expected at least ${limit[0]} argument(s) for ${placeholder}`;
+      if (limit[1] === 0) {
+        message += " but found none";
+      } else {
+        message += ` but only found ${limit[1]}`;
+      }
+    } else {
+      message = `Expected argument for ${placeholder}`;
+    }
+    super(message);
+    this.placeholder = placeholder;
+    this.limit = limit;
+  }
+};
+function undoNegation(flagName) {
+  if (flagName.startsWith("no") && flagName.length > 2) {
+    if (flagName[2] === "-") {
+      return flagName.slice(4);
+    }
+    const firstChar = flagName[2];
+    const firstUpper = firstChar.toUpperCase();
+    if (firstChar !== firstUpper) {
+      return;
+    }
+    const firstLower = firstChar.toLowerCase();
+    return firstLower + flagName.slice(3);
+  }
+}
+function findInternalFlagMatch(externalFlagName, flags, config) {
+  const internalFlagName = externalFlagName;
+  let flag = flags[internalFlagName];
+  let foundFlagWithNegatedFalse;
+  let foundFlagWithNegatedFalseFromKebabConversion = false;
+  if (!flag) {
+    const internalWithoutNegation = undoNegation(internalFlagName);
+    if (internalWithoutNegation) {
+      flag = flags[internalWithoutNegation];
+      if (flag && flag.kind == "boolean") {
+        if (flag.withNegated !== false) {
+          return { namedFlag: [internalWithoutNegation, flag], negated: true };
+        } else {
+          foundFlagWithNegatedFalse = internalWithoutNegation;
+          flag = undefined;
+        }
+      }
+    }
+  }
+  const camelCaseFlagName = convertKebabCaseToCamelCase(externalFlagName);
+  if (config.caseStyle === "allow-kebab-for-camel" && !flag) {
+    flag = flags[camelCaseFlagName];
+    if (flag) {
+      return { namedFlag: [camelCaseFlagName, flag] };
+    }
+    const camelCaseWithoutNegation = undoNegation(camelCaseFlagName);
+    if (camelCaseWithoutNegation) {
+      flag = flags[camelCaseWithoutNegation];
+      if (flag && flag.kind == "boolean") {
+        if (flag.withNegated !== false) {
+          return { namedFlag: [camelCaseWithoutNegation, flag], negated: true };
+        } else {
+          foundFlagWithNegatedFalse = camelCaseWithoutNegation;
+          foundFlagWithNegatedFalseFromKebabConversion = true;
+          flag = undefined;
+        }
+      }
+    }
+  }
+  if (!flag) {
+    if (foundFlagWithNegatedFalse) {
+      let correction = foundFlagWithNegatedFalse;
+      if (foundFlagWithNegatedFalseFromKebabConversion && externalFlagName.includes("-")) {
+        correction = convertCamelCaseToKebabCase(foundFlagWithNegatedFalse);
+      }
+      throw new FlagNotFoundError(externalFlagName, [correction]);
+    }
+    if (camelCaseFlagName in flags) {
+      throw new FlagNotFoundError(externalFlagName, [camelCaseFlagName]);
+    }
+    const kebabCaseFlagName = convertCamelCaseToKebabCase(externalFlagName);
+    if (kebabCaseFlagName in flags) {
+      throw new FlagNotFoundError(externalFlagName, [kebabCaseFlagName]);
+    }
+    const corrections = filterClosestAlternatives(internalFlagName, Object.keys(flags), config.distanceOptions);
+    throw new FlagNotFoundError(externalFlagName, corrections);
+  }
+  return { namedFlag: [internalFlagName, flag] };
+}
+function isNiladic(namedFlagWithNegation) {
+  if (namedFlagWithNegation.namedFlag[1].kind === "boolean" || namedFlagWithNegation.namedFlag[1].kind === "counter") {
+    return true;
+  }
+  return false;
+}
+var FLAG_SHORTHAND_PATTERN = /^-([a-z]+)$/i;
+var FLAG_NAME_PATTERN = /^--([a-z][a-z-.\d_]+)$/i;
+function findFlagsByArgument(arg, flags, resolvedAliases, config) {
+  const shorthandMatch = FLAG_SHORTHAND_PATTERN.exec(arg);
+  if (shorthandMatch) {
+    const batch = shorthandMatch[1];
+    return Array.from(batch).map((alias) => {
+      const aliasName = alias;
+      const namedFlag = resolvedAliases[aliasName];
+      if (!namedFlag) {
+        throw new AliasNotFoundError(aliasName);
+      }
+      return { namedFlag };
+    });
+  }
+  const flagNameMatch = FLAG_NAME_PATTERN.exec(arg);
+  if (flagNameMatch) {
+    const externalFlagName = flagNameMatch[1];
+    return [findInternalFlagMatch(externalFlagName, flags, config)];
+  }
+  return [];
+}
+var FLAG_NAME_VALUE_PATTERN = /^--([a-z][a-z-.\d_]+)=(.+)$/i;
+var ALIAS_VALUE_PATTERN = /^-([a-z])=(.+)$/i;
+var InvalidNegatedFlagSyntaxError = class extends ArgumentScannerError {
+  externalFlagName;
+  valueText;
+  constructor(externalFlagName, valueText) {
+    super(`Cannot negate flag --${externalFlagName} and pass "${valueText}" as value`);
+    this.externalFlagName = externalFlagName;
+    this.valueText = valueText;
+  }
+};
+function findFlagByArgumentWithInput(arg, flags, resolvedAliases, config) {
+  const flagsNameMatch = FLAG_NAME_VALUE_PATTERN.exec(arg);
+  if (flagsNameMatch) {
+    const externalFlagName = flagsNameMatch[1];
+    const { namedFlag: flagMatch, negated } = findInternalFlagMatch(externalFlagName, flags, config);
+    const valueText = flagsNameMatch[2];
+    if (negated) {
+      throw new InvalidNegatedFlagSyntaxError(externalFlagName, valueText);
+    }
+    return [flagMatch, valueText];
+  }
+  const aliasValueMatch = ALIAS_VALUE_PATTERN.exec(arg);
+  if (aliasValueMatch) {
+    const aliasName = aliasValueMatch[1];
+    const namedFlag = resolvedAliases[aliasName];
+    if (!namedFlag) {
+      throw new AliasNotFoundError(aliasName);
+    }
+    const valueText = aliasValueMatch[2];
+    return [namedFlag, valueText];
+  }
+}
+async function parseInputsForFlag(externalFlagName, flag, inputs, config, context) {
+  if (!inputs) {
+    if ("default" in flag && typeof flag.default !== "undefined") {
+      if (flag.kind === "boolean") {
+        return flag.default;
+      }
+      if (flag.kind === "enum") {
+        if ("variadic" in flag && flag.variadic && Array.isArray(flag.default)) {
+          const defaultArray = flag.default;
+          for (const value of defaultArray) {
+            if (!flag.values.includes(value)) {
+              const corrections = filterClosestAlternatives(value, flag.values, config.distanceOptions);
+              throw new EnumValidationError(externalFlagName, value, flag.values, corrections);
+            }
+          }
+          return flag.default;
+        }
+        return flag.default;
+      }
+      if ("variadic" in flag && flag.variadic && Array.isArray(flag.default)) {
+        const defaultArray = flag.default;
+        return Promise.all(defaultArray.map((input2) => parseInput(externalFlagName, flag, input2, context)));
+      }
+      return parseInput(externalFlagName, flag, flag.default, context);
+    }
+    if (flag.optional) {
+      return;
+    }
+    if (flag.kind === "boolean") {
+      return false;
+    } else if (flag.kind === "counter") {
+      return 0;
+    }
+    throw new UnsatisfiedFlagError(externalFlagName);
+  }
+  if (flag.kind === "counter") {
+    return inputs.reduce((total, input2) => {
+      try {
+        return total + numberParser.call(context, input2);
+      } catch (exc) {
+        throw new ArgumentParseError(externalFlagName, input2, exc);
+      }
+    }, 0);
+  }
+  if ("variadic" in flag && flag.variadic) {
+    if (flag.kind === "enum") {
+      for (const input2 of inputs) {
+        if (!flag.values.includes(input2)) {
+          const corrections = filterClosestAlternatives(input2, flag.values, config.distanceOptions);
+          throw new EnumValidationError(externalFlagName, input2, flag.values, corrections);
+        }
+      }
+      return inputs;
+    }
+    return Promise.all(inputs.map((input2) => parseInput(externalFlagName, flag, input2, context)));
+  }
+  const input = inputs[0];
+  if (flag.kind === "boolean") {
+    try {
+      return looseBooleanParser.call(context, input);
+    } catch (exc) {
+      throw new ArgumentParseError(externalFlagName, input, exc);
+    }
+  }
+  if (flag.kind === "enum") {
+    if (!flag.values.includes(input)) {
+      const corrections = filterClosestAlternatives(input, flag.values, config.distanceOptions);
+      throw new EnumValidationError(externalFlagName, input, flag.values, corrections);
+    }
+    return input;
+  }
+  return parseInput(externalFlagName, flag, input, context);
+}
+var UnexpectedFlagError = class extends ArgumentScannerError {
+  externalFlagName;
+  previousInput;
+  input;
+  constructor(externalFlagName, previousInput, input) {
+    super(`Too many arguments for --${externalFlagName}, encountered "${input}" after "${previousInput}"`);
+    this.externalFlagName = externalFlagName;
+    this.previousInput = previousInput;
+    this.input = input;
+  }
+};
+function isVariadicFlag(flag) {
+  if (flag.kind === "counter") {
+    return true;
+  }
+  if ("variadic" in flag) {
+    return Boolean(flag.variadic);
+  }
+  return false;
+}
+function storeInput(flagInputs, scannerCaseStyle, [internalFlagName, flag], input) {
+  const inputs = flagInputs.get(internalFlagName) ?? [];
+  if (inputs.length > 0 && !isVariadicFlag(flag)) {
+    const externalFlagName = asExternal(internalFlagName, scannerCaseStyle);
+    throw new UnexpectedFlagError(externalFlagName, inputs[0], input);
+  }
+  if ("variadic" in flag && typeof flag.variadic === "string") {
+    const multipleInputs = input.split(flag.variadic);
+    flagInputs.set(internalFlagName, [...inputs, ...multipleInputs]);
+  } else {
+    flagInputs.set(internalFlagName, [...inputs, input]);
+  }
+}
+function isFlagSatisfiedByInputs(flags, flagInputs, key) {
+  const inputs = flagInputs.get(key);
+  if (inputs) {
+    const flag = flags[key];
+    if (isVariadicFlag(flag)) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function buildArgumentScanner(parameters, config) {
+  const { flags = {}, aliases = {}, positional = { kind: "tuple", parameters: [] } } = parameters;
+  const resolvedAliases = resolveAliases(flags, aliases, config.caseStyle);
+  const positionalInputs = [];
+  const flagInputs = /* @__PURE__ */ new Map;
+  let positionalIndex = 0;
+  let activeFlag;
+  let treatInputsAsArguments = false;
+  return {
+    next: (input) => {
+      if (!treatInputsAsArguments && config.allowArgumentEscapeSequence && input === "--") {
+        if (activeFlag) {
+          if (activeFlag[1].kind === "parsed" && activeFlag[1].inferEmpty) {
+            storeInput(flagInputs, config.caseStyle, activeFlag, "");
+            activeFlag = undefined;
+          } else {
+            const externalFlagName = asExternal(activeFlag[0], config.caseStyle);
+            throw new UnsatisfiedFlagError(externalFlagName);
+          }
+        }
+        treatInputsAsArguments = true;
+        return;
+      }
+      if (!treatInputsAsArguments) {
+        const flagInput = findFlagByArgumentWithInput(input, flags, resolvedAliases, config);
+        if (flagInput) {
+          if (activeFlag) {
+            if (activeFlag[1].kind === "parsed" && activeFlag[1].inferEmpty) {
+              storeInput(flagInputs, config.caseStyle, activeFlag, "");
+              activeFlag = undefined;
+            } else {
+              const externalFlagName = asExternal(activeFlag[0], config.caseStyle);
+              const nextExternalFlagName = asExternal(flagInput[0][0], config.caseStyle);
+              throw new UnsatisfiedFlagError(externalFlagName, nextExternalFlagName);
+            }
+          }
+          storeInput(flagInputs, config.caseStyle, ...flagInput);
+          return;
+        }
+        const nextFlags = findFlagsByArgument(input, flags, resolvedAliases, config);
+        if (nextFlags.length > 0) {
+          if (activeFlag) {
+            if (activeFlag[1].kind === "parsed" && activeFlag[1].inferEmpty) {
+              storeInput(flagInputs, config.caseStyle, activeFlag, "");
+              activeFlag = undefined;
+            } else {
+              const externalFlagName = asExternal(activeFlag[0], config.caseStyle);
+              const nextFlagName = asExternal(nextFlags[0].namedFlag[0], config.caseStyle);
+              throw new UnsatisfiedFlagError(externalFlagName, nextFlagName);
+            }
+          }
+          if (nextFlags.every(isNiladic)) {
+            for (const nextFlag of nextFlags) {
+              if (nextFlag.namedFlag[1].kind === "boolean") {
+                storeInput(flagInputs, config.caseStyle, nextFlag.namedFlag, nextFlag.negated ? "false" : "true");
+              } else {
+                storeInput(flagInputs, config.caseStyle, nextFlag.namedFlag, "1");
+              }
+            }
+          } else if (nextFlags.length > 1) {
+            const nextFlagExpectingArg = nextFlags.find((nextFlag) => !isNiladic(nextFlag));
+            const externalFlagName = asExternal(nextFlagExpectingArg.namedFlag[0], config.caseStyle);
+            throw new UnsatisfiedFlagError(externalFlagName);
+          } else {
+            activeFlag = nextFlags[0].namedFlag;
+          }
+          return;
+        }
+      }
+      if (activeFlag) {
+        storeInput(flagInputs, config.caseStyle, activeFlag, input);
+        activeFlag = undefined;
+      } else {
+        if (positional.kind === "tuple") {
+          if (positionalIndex >= positional.parameters.length) {
+            throw new UnexpectedPositionalError(positional.parameters.length, input);
+          }
+        } else {
+          if (typeof positional.maximum === "number" && positionalIndex >= positional.maximum) {
+            throw new UnexpectedPositionalError(positional.maximum, input);
+          }
+        }
+        positionalInputs[positionalIndex] = input;
+        ++positionalIndex;
+      }
+    },
+    parseArguments: async (context) => {
+      const errors = [];
+      let positionalValues_p;
+      if (positional.kind === "array") {
+        if (typeof positional.minimum === "number" && positionalIndex < positional.minimum) {
+          errors.push(new UnsatisfiedPositionalError(getPlaceholder(positional.parameter), [
+            positional.minimum,
+            positionalIndex
+          ]));
+        }
+        positionalValues_p = allSettledOrElse(positionalInputs.map(async (input, i) => {
+          const placeholder = getPlaceholder(positional.parameter, i + 1);
+          return parseInput(placeholder, positional.parameter, input, context);
+        }));
+      } else {
+        positionalValues_p = allSettledOrElse(positional.parameters.map(async (param, i) => {
+          const placeholder = getPlaceholder(param, i + 1);
+          const input = positionalInputs[i];
+          if (typeof input !== "string") {
+            if (typeof param.default === "string") {
+              return parseInput(placeholder, param, param.default, context);
+            }
+            if (param.optional) {
+              return;
+            }
+            throw new UnsatisfiedPositionalError(placeholder);
+          }
+          return parseInput(placeholder, param, input, context);
+        }));
+      }
+      if (activeFlag && activeFlag[1].kind === "parsed" && activeFlag[1].inferEmpty) {
+        storeInput(flagInputs, config.caseStyle, activeFlag, "");
+        activeFlag = undefined;
+      }
+      const flagEntries_p = allSettledOrElse(Object.entries(flags).map(async (entry) => {
+        const [internalFlagName, flag] = entry;
+        const externalFlagName = asExternal(internalFlagName, config.caseStyle);
+        if (activeFlag && activeFlag[0] === internalFlagName) {
+          throw new UnsatisfiedFlagError(externalFlagName);
+        }
+        const inputs = flagInputs.get(internalFlagName);
+        const value = await parseInputsForFlag(externalFlagName, flag, inputs, config, context);
+        return [internalFlagName, value];
+      }));
+      const [positionalValuesResult, flagEntriesResult] = await Promise.all([positionalValues_p, flagEntries_p]);
+      if (positionalValuesResult.status === "rejected") {
+        for (const reason of positionalValuesResult.reasons) {
+          errors.push(reason);
+        }
+      }
+      if (flagEntriesResult.status === "rejected") {
+        for (const reason of flagEntriesResult.reasons) {
+          errors.push(reason);
+        }
+      }
+      if (errors.length > 0) {
+        return { success: false, errors };
+      }
+      if (positionalValuesResult.status === "rejected") {
+        throw new InternalError("Unknown failure while scanning positional arguments");
+      }
+      if (flagEntriesResult.status === "rejected") {
+        throw new InternalError("Unknown failure while scanning flag arguments");
+      }
+      const parsedFlags = Object.fromEntries(flagEntriesResult.value);
+      return { success: true, arguments: [parsedFlags, ...positionalValuesResult.value] };
+    },
+    proposeCompletions: async ({ partial, completionConfig, text, context, includeVersionFlag }) => {
+      if (activeFlag) {
+        return proposeFlagCompletionsForPartialInput(activeFlag[1], context, partial);
+      }
+      const completions = [];
+      if (!treatInputsAsArguments) {
+        const shorthandMatch = FLAG_SHORTHAND_PATTERN.exec(partial);
+        if (completionConfig.includeAliases) {
+          if (partial === "" || partial === "-") {
+            const incompleteAliases = Object.entries(aliases).filter((entry) => !isFlagSatisfiedByInputs(flags, flagInputs, entry[1]));
+            for (const [alias] of incompleteAliases) {
+              const flag = resolvedAliases[alias];
+              if (flag) {
+                completions.push({
+                  kind: "argument:flag",
+                  completion: `-${alias}`,
+                  brief: flag[1].brief
+                });
+              }
+            }
+          } else if (shorthandMatch) {
+            const partialAliases = Array.from(shorthandMatch[1]);
+            if (partialAliases.includes("h")) {
+              return [];
+            }
+            if (includeVersionFlag && partialAliases.includes("v")) {
+              return [];
+            }
+            const flagInputsIncludingPartial = new Map(flagInputs);
+            for (const alias of partialAliases) {
+              const namedFlag = resolvedAliases[alias];
+              if (!namedFlag) {
+                throw new AliasNotFoundError(alias);
+              }
+              storeInput(flagInputsIncludingPartial, config.caseStyle, namedFlag, namedFlag[1].kind === "boolean" ? "true" : "1");
+            }
+            const lastAlias = partialAliases[partialAliases.length - 1];
+            if (lastAlias) {
+              const namedFlag = resolvedAliases[lastAlias];
+              if (namedFlag) {
+                completions.push({
+                  kind: "argument:flag",
+                  completion: partial,
+                  brief: namedFlag[1].brief
+                });
+              }
+            }
+            const incompleteAliases = Object.entries(aliases).filter((entry) => !isFlagSatisfiedByInputs(flags, flagInputsIncludingPartial, entry[1]));
+            for (const [alias] of incompleteAliases) {
+              const flag = resolvedAliases[alias];
+              if (flag) {
+                completions.push({
+                  kind: "argument:flag",
+                  completion: `${partial}${alias}`,
+                  brief: flag[1].brief
+                });
+              }
+            }
+          }
+        }
+        if (partial === "" || partial === "-" || partial.startsWith("--")) {
+          if (config.allowArgumentEscapeSequence) {
+            completions.push({
+              kind: "argument:flag",
+              completion: "--",
+              brief: text.briefs.argumentEscapeSequence
+            });
+          }
+          let incompleteFlags = Object.entries(flags).filter(([flagName]) => !isFlagSatisfiedByInputs(flags, flagInputs, flagName));
+          if (config.caseStyle === "allow-kebab-for-camel") {
+            incompleteFlags = incompleteFlags.map(([flagName, param]) => {
+              return [convertCamelCaseToKebabCase(flagName), param];
+            });
+          }
+          const possibleFlags = incompleteFlags.map(([flagName, param]) => [`--${flagName}`, param]).filter(([flagName]) => flagName.startsWith(partial));
+          completions.push(...possibleFlags.map(([name, param]) => {
+            return {
+              kind: "argument:flag",
+              completion: name,
+              brief: param.brief
+            };
+          }));
+        }
+      }
+      if (positional.kind === "array") {
+        if (positional.parameter.proposeCompletions) {
+          if (typeof positional.maximum !== "number" || positionalIndex < positional.maximum) {
+            const positionalCompletions = await positional.parameter.proposeCompletions.call(context, partial);
+            completions.push(...positionalCompletions.map((value) => {
+              return {
+                kind: "argument:value",
+                completion: value,
+                brief: positional.parameter.brief
+              };
+            }));
+          }
+        }
+      } else {
+        const nextPositional = positional.parameters[positionalIndex];
+        if (nextPositional?.proposeCompletions) {
+          const positionalCompletions = await nextPositional.proposeCompletions.call(context, partial);
+          completions.push(...positionalCompletions.map((value) => {
+            return {
+              kind: "argument:value",
+              completion: value,
+              brief: nextPositional.brief
+            };
+          }));
+        }
+      }
+      return completions.filter(({ completion }) => completion.startsWith(partial));
+    }
+  };
+}
+async function proposeFlagCompletionsForPartialInput(flag, context, partial) {
+  if (typeof flag.variadic === "string") {
+    if (partial.endsWith(flag.variadic)) {
+      return proposeFlagCompletionsForPartialInput(flag, context, "");
+    }
+  }
+  let values;
+  if (flag.kind === "enum") {
+    values = flag.values;
+  } else if (flag.proposeCompletions) {
+    values = await flag.proposeCompletions.call(context, partial);
+  } else {
+    values = [];
+  }
+  return values.map((value) => {
+    return {
+      kind: "argument:value",
+      completion: value,
+      brief: flag.brief
+    };
+  }).filter(({ completion }) => completion.startsWith(partial));
+}
+function listAllRouteNamesAndAliasesForScan(routeMap, scannerCaseStyle, config) {
+  const displayCaseStyle = scannerCaseStyle === "allow-kebab-for-camel" ? "convert-camel-to-kebab" : scannerCaseStyle;
+  let entries = routeMap.getAllEntries();
+  if (!config.includeHiddenRoutes) {
+    entries = entries.filter((entry) => !entry.hidden);
+  }
+  return entries.flatMap((entry) => {
+    const routeName = entry.name[displayCaseStyle];
+    if (config.includeAliases) {
+      return [routeName, ...entry.aliases];
+    }
+    return [routeName];
+  });
+}
+var text_en = {
+  headers: {
+    usage: "USAGE",
+    aliases: "ALIASES",
+    commands: "COMMANDS",
+    flags: "FLAGS",
+    arguments: "ARGUMENTS"
+  },
+  keywords: {
+    default: "default =",
+    separator: "separator ="
+  },
+  briefs: {
+    help: "Print help information and exit",
+    helpAll: "Print help information (including hidden commands/flags) and exit",
+    version: "Print version information and exit",
+    argumentEscapeSequence: "All subsequent inputs should be interpreted as arguments"
+  },
+  noCommandRegisteredForInput: ({ input, corrections }) => {
+    const errorMessage = `No command registered for \`${input}\``;
+    if (corrections.length > 0) {
+      const formattedCorrections = joinWithGrammar(corrections, {
+        kind: "conjunctive",
+        conjunction: "or",
+        serialComma: true
+      });
+      return `${errorMessage}, did you mean ${formattedCorrections}?`;
+    } else {
+      return errorMessage;
+    }
+  },
+  noTextAvailableForLocale: ({ requestedLocale, defaultLocale }) => {
+    return `Application does not support "${requestedLocale}" locale, defaulting to "${defaultLocale}"`;
+  },
+  exceptionWhileParsingArguments: (exc) => {
+    if (exc instanceof ArgumentScannerError) {
+      return formatMessageForArgumentScannerError(exc, {});
+    }
+    return `Unable to parse arguments, ${formatException(exc)}`;
+  },
+  exceptionWhileLoadingCommandFunction: (exc) => {
+    return `Unable to load command function, ${formatException(exc)}`;
+  },
+  exceptionWhileLoadingCommandContext: (exc) => {
+    return `Unable to load command context, ${formatException(exc)}`;
+  },
+  exceptionWhileRunningCommand: (exc) => {
+    return `Command failed, ${formatException(exc)}`;
+  },
+  commandErrorResult: (err) => {
+    return err.message;
+  },
+  currentVersionIsNotLatest: ({ currentVersion, latestVersion, upgradeCommand }) => {
+    if (upgradeCommand) {
+      return `Latest available version is ${latestVersion} (currently running ${currentVersion}), upgrade with "${upgradeCommand}"`;
+    }
+    return `Latest available version is ${latestVersion} (currently running ${currentVersion})`;
+  }
+};
+function defaultTextLoader(locale) {
+  if (locale.startsWith("en")) {
+    return text_en;
+  }
+}
+function shouldUseAnsiColor(process2, stream, config) {
+  return !config.disableAnsiColor && !checkEnvironmentVariable(process2, "STRICLI_NO_COLOR") && (stream.getColorDepth?.(process2.env) ?? 1) >= 4;
+}
+async function runCommand({ loader, parameters }, {
+  context,
+  inputs,
+  scannerConfig,
+  errorFormatting,
+  documentationConfig,
+  determineExitCode
+}) {
+  let parsedArguments;
+  try {
+    const scanner = buildArgumentScanner(parameters, scannerConfig);
+    for (const input of inputs) {
+      scanner.next(input);
+    }
+    const result = await scanner.parseArguments(context);
+    if (result.success) {
+      parsedArguments = result.arguments;
+    } else {
+      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
+      for (const error of result.errors) {
+        const errorMessage = errorFormatting.exceptionWhileParsingArguments(error, ansiColor);
+        context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`);
+      }
+      return ExitCode.InvalidArgument;
+    }
+  } catch (exc) {
+    const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
+    const errorMessage = errorFormatting.exceptionWhileParsingArguments(exc, ansiColor);
+    context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`);
+    return ExitCode.InvalidArgument;
+  }
+  let commandFunction;
+  try {
+    const loaded = await loader();
+    if (typeof loaded === "function") {
+      commandFunction = loaded;
+    } else {
+      commandFunction = loaded.default;
+    }
+  } catch (exc) {
+    const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
+    const errorMessage = errorFormatting.exceptionWhileLoadingCommandFunction(exc, ansiColor);
+    context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`);
+    return ExitCode.CommandLoadError;
+  }
+  try {
+    const result = await commandFunction.call(context, ...parsedArguments);
+    if (result instanceof Error) {
+      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
+      const errorMessage = errorFormatting.commandErrorResult(result, ansiColor);
+      context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`);
+      if (determineExitCode) {
+        return determineExitCode(result);
+      }
+      return ExitCode.CommandRunError;
+    }
+  } catch (exc) {
+    const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
+    const errorMessage = errorFormatting.exceptionWhileRunningCommand(exc, ansiColor);
+    context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`);
+    if (determineExitCode) {
+      return determineExitCode(exc);
+    }
+    return ExitCode.CommandRunError;
+  }
+  return ExitCode.Success;
+}
+var RouteMapSymbol = Symbol("RouteMap");
+var CommandSymbol = Symbol("Command");
+function buildRouteScanner(root, config, startingPrefix) {
+  const prefix = [...startingPrefix];
+  const unprocessedInputs = [];
+  let parent;
+  let current = root;
+  let target;
+  let rootLevel = true;
+  let helpRequested = false;
+  return {
+    next: (input) => {
+      if (input === "--help" || input === "-h") {
+        helpRequested = true;
+        if (!target) {
+          target = current;
+        }
+        return;
+      } else if (input === "--helpAll" || input === "--help-all" || input === "-H") {
+        helpRequested = "all";
+        if (!target) {
+          target = current;
+        }
+        return;
+      }
+      if (target) {
+        unprocessedInputs.push(input);
+        return;
+      }
+      if (current.kind === CommandSymbol) {
+        target = current;
+        unprocessedInputs.push(input);
+        return;
+      }
+      const camelCaseRouteName = convertKebabCaseToCamelCase(input);
+      let internalRouteName = input;
+      let next = current.getRoutingTargetForInput(internalRouteName);
+      if (config.caseStyle === "allow-kebab-for-camel" && !next) {
+        next = current.getRoutingTargetForInput(camelCaseRouteName);
+        if (next) {
+          internalRouteName = camelCaseRouteName;
+        }
+      }
+      if (!next) {
+        const defaultCommand = current.getDefaultCommand();
+        if (defaultCommand) {
+          rootLevel = false;
+          parent = [current, ""];
+          unprocessedInputs.push(input);
+          current = defaultCommand;
+          return;
+        }
+        return { input, routeMap: current };
+      }
+      rootLevel = false;
+      parent = [current, input];
+      current = next;
+      prefix.push(input);
+    },
+    finish: () => {
+      target = target ?? current;
+      if (target.kind === RouteMapSymbol && !helpRequested) {
+        const defaultCommand = target.getDefaultCommand();
+        if (defaultCommand) {
+          parent = [target, ""];
+          target = defaultCommand;
+          rootLevel = false;
+        }
+      }
+      const aliases = parent ? parent[0].getOtherAliasesForInput(parent[1], config.caseStyle) : { original: [], "convert-camel-to-kebab": [] };
+      return {
+        target,
+        unprocessedInputs,
+        helpRequested,
+        prefix,
+        rootLevel,
+        aliases
+      };
+    }
+  };
+}
+async function runApplication({ root, defaultText, config }, rawInputs, context) {
+  let text = defaultText;
+  if (context.locale) {
+    const localeText = config.localization.loadText(context.locale);
+    if (localeText) {
+      text = localeText;
+    } else {
+      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, config.documentation);
+      const warningMessage = text.noTextAvailableForLocale({
+        requestedLocale: context.locale,
+        defaultLocale: config.localization.defaultLocale,
+        ansiColor
+      });
+      context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[33m${warningMessage}\x1B[39m\x1B[22m
+` : `${warningMessage}
+`);
+    }
+  }
+  if (config.versionInfo?.getLatestVersion && !checkEnvironmentVariable(context.process, "STRICLI_SKIP_VERSION_CHECK")) {
+    let currentVersion;
+    if ("currentVersion" in config.versionInfo) {
+      currentVersion = config.versionInfo.currentVersion;
+    } else {
+      currentVersion = await config.versionInfo.getCurrentVersion.call(context);
+    }
+    const latestVersion = await config.versionInfo.getLatestVersion.call(context, currentVersion);
+    if (latestVersion && currentVersion !== latestVersion) {
+      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, config.documentation);
+      const warningMessage = text.currentVersionIsNotLatest({
+        currentVersion,
+        latestVersion,
+        upgradeCommand: config.versionInfo.upgradeCommand,
+        ansiColor
+      });
+      context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[33m${warningMessage}\x1B[39m\x1B[22m
+` : `${warningMessage}
+`);
+    }
+  }
+  const inputs = rawInputs.slice();
+  if (config.versionInfo && (inputs[0] === "--version" || inputs[0] === "-v")) {
+    let currentVersion;
+    if ("currentVersion" in config.versionInfo) {
+      currentVersion = config.versionInfo.currentVersion;
+    } else {
+      currentVersion = await config.versionInfo.getCurrentVersion.call(context);
+    }
+    context.process.stdout.write(currentVersion + `
+`);
+    return ExitCode.Success;
+  }
+  const scanner = buildRouteScanner(root, config.scanner, [config.name]);
+  let error;
+  while (inputs.length > 0 && !error) {
+    const arg = inputs.shift();
+    error = scanner.next(arg);
+  }
+  if (error) {
+    const routeNames = listAllRouteNamesAndAliasesForScan(error.routeMap, config.scanner.caseStyle, config.completion);
+    const corrections = filterClosestAlternatives(error.input, routeNames, config.scanner.distanceOptions).map((str) => `\`${str}\``);
+    const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, config.documentation);
+    const errorMessage = text.noCommandRegisteredForInput({ input: error.input, corrections, ansiColor });
+    context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`);
+    return ExitCode.UnknownCommand;
+  }
+  const result = scanner.finish();
+  if (result.helpRequested || result.target.kind === RouteMapSymbol) {
+    const ansiColor = shouldUseAnsiColor(context.process, context.process.stdout, config.documentation);
+    context.process.stdout.write(result.target.formatHelp({
+      prefix: result.prefix,
+      includeVersionFlag: Boolean(config.versionInfo) && result.rootLevel,
+      includeArgumentEscapeSequenceFlag: config.scanner.allowArgumentEscapeSequence,
+      includeHelpAllFlag: result.helpRequested === "all" || config.documentation.alwaysShowHelpAllFlag,
+      includeHidden: result.helpRequested === "all",
+      config: config.documentation,
+      aliases: result.aliases[config.documentation.caseStyle],
+      text,
+      ansiColor
+    }));
+    return ExitCode.Success;
+  }
+  let commandContext;
+  if ("forCommand" in context) {
+    try {
+      commandContext = await context.forCommand({ prefix: result.prefix });
+    } catch (exc) {
+      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, config.documentation);
+      const errorMessage = text.exceptionWhileLoadingCommandContext(exc, ansiColor);
+      context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m` : errorMessage);
+      return ExitCode.ContextLoadError;
+    }
+  } else {
+    commandContext = context;
+  }
+  return runCommand(result.target, {
+    context: commandContext,
+    inputs: result.unprocessedInputs,
+    scannerConfig: config.scanner,
+    documentationConfig: config.documentation,
+    errorFormatting: text,
+    determineExitCode: config.determineExitCode
+  });
+}
+function formatForDisplay(flagName, displayCaseStyle) {
+  if (displayCaseStyle === "convert-camel-to-kebab") {
+    return convertCamelCaseToKebabCase(flagName);
+  }
+  return flagName;
+}
+function formatAsNegated(flagName, displayCaseStyle) {
+  if (displayCaseStyle === "convert-camel-to-kebab") {
+    return `no-${convertCamelCaseToKebabCase(flagName)}`;
+  }
+  return `no${flagName[0].toUpperCase()}${flagName.slice(1)}`;
+}
+function withDefaults(config) {
+  const scannerCaseStyle = config.scanner?.caseStyle ?? "original";
+  let displayCaseStyle;
+  if (config.documentation?.caseStyle) {
+    if (scannerCaseStyle === "original" && config.documentation.caseStyle === "convert-camel-to-kebab") {
+      throw new InternalError("Cannot convert route and flag names on display but scan as original");
+    }
+    displayCaseStyle = config.documentation.caseStyle;
+  } else if (scannerCaseStyle === "allow-kebab-for-camel") {
+    displayCaseStyle = "convert-camel-to-kebab";
+  } else {
+    displayCaseStyle = scannerCaseStyle;
+  }
+  const scannerConfig = {
+    caseStyle: scannerCaseStyle,
+    allowArgumentEscapeSequence: config.scanner?.allowArgumentEscapeSequence ?? false,
+    distanceOptions: config.scanner?.distanceOptions ?? {
+      threshold: 7,
+      weights: {
+        insertion: 1,
+        deletion: 3,
+        substitution: 2,
+        transposition: 0
+      }
+    }
+  };
+  const documentationConfig = {
+    alwaysShowHelpAllFlag: config.documentation?.alwaysShowHelpAllFlag ?? false,
+    useAliasInUsageLine: config.documentation?.useAliasInUsageLine ?? false,
+    onlyRequiredInUsageLine: config.documentation?.onlyRequiredInUsageLine ?? false,
+    caseStyle: displayCaseStyle,
+    disableAnsiColor: config.documentation?.disableAnsiColor ?? false
+  };
+  const completionConfig = {
+    includeAliases: config.completion?.includeAliases ?? documentationConfig.useAliasInUsageLine,
+    includeHiddenRoutes: config.completion?.includeHiddenRoutes ?? false,
+    ...config.completion
+  };
+  return {
+    ...config,
+    scanner: scannerConfig,
+    completion: completionConfig,
+    documentation: documentationConfig,
+    localization: {
+      defaultLocale: "en",
+      loadText: defaultTextLoader,
+      ...config.localization
+    }
+  };
+}
+function buildApplication(root, appConfig) {
+  const config = withDefaults(appConfig);
+  if (root.kind === CommandSymbol && config.versionInfo) {
+    if (root.usesFlag("version")) {
+      throw new InternalError("Unable to use command with flag --version as root when version info is supplied");
+    }
+    if (root.usesFlag("v")) {
+      throw new InternalError("Unable to use command with alias -v as root when version info is supplied");
+    }
+  }
+  const defaultText = config.localization.loadText(config.localization.defaultLocale);
+  if (!defaultText) {
+    throw new InternalError(`No text available for the default locale "${config.localization.defaultLocale}"`);
+  }
+  return {
+    root,
+    config,
+    defaultText
+  };
+}
+function hasDefault(flag) {
+  return "default" in flag && typeof flag.default !== "undefined";
+}
+function isOptionalAtRuntime(flag) {
+  return flag.optional ?? hasDefault(flag);
+}
+function wrapRequiredFlag(text) {
+  return `(${text})`;
+}
+function wrapOptionalFlag(text) {
+  return `[${text}]`;
+}
+function wrapVariadicFlag(text) {
+  return `${text}...`;
+}
+function wrapRequiredParameter(text) {
+  return `<${text}>`;
+}
+function wrapOptionalParameter(text) {
+  return `[<${text}>]`;
+}
+function wrapVariadicParameter(text) {
+  return `<${text}>...`;
+}
+function formatUsageLineForParameters(parameters, args) {
+  const flagsUsage = Object.entries(parameters.flags ?? {}).filter(([, flag]) => {
+    if (flag.hidden) {
+      return false;
+    }
+    if (args.config.onlyRequiredInUsageLine && isOptionalAtRuntime(flag)) {
+      return false;
+    }
+    return true;
+  }).map(([name, flag]) => {
+    let displayName = args.config.caseStyle === "convert-camel-to-kebab" ? `--${convertCamelCaseToKebabCase(name)}` : `--${name}`;
+    if (parameters.aliases && args.config.useAliasInUsageLine) {
+      const aliases = Object.entries(parameters.aliases).filter((entry) => entry[1] === name);
+      if (aliases.length === 1 && aliases[0]) {
+        displayName = `-${aliases[0][0]}`;
+      }
+    }
+    if (flag.kind === "boolean") {
+      return [flag, displayName];
+    }
+    if (flag.kind === "enum" && typeof flag.placeholder !== "string") {
+      return [flag, `${displayName} ${flag.values.join("|")}`];
+    }
+    const placeholder = flag.placeholder ?? "value";
+    return [flag, `${displayName} ${placeholder}`];
+  }).map(([flag, usage]) => {
+    if (flag.kind === "parsed" && flag.variadic) {
+      if (isOptionalAtRuntime(flag)) {
+        return wrapVariadicFlag(wrapOptionalFlag(usage));
+      }
+      return wrapVariadicFlag(wrapRequiredFlag(usage));
+    }
+    if (isOptionalAtRuntime(flag)) {
+      return wrapOptionalFlag(usage);
+    }
+    return wrapRequiredFlag(usage);
+  });
+  let positionalUsage = [];
+  const positional = parameters.positional;
+  if (positional) {
+    if (positional.kind === "array") {
+      positionalUsage = [wrapVariadicParameter(positional.parameter.placeholder ?? "args")];
+    } else {
+      let parameters2 = positional.parameters;
+      if (args.config.onlyRequiredInUsageLine) {
+        parameters2 = parameters2.filter((param) => !param.optional && typeof param.default === "undefined");
+      }
+      positionalUsage = parameters2.map((param, i) => {
+        const argName = param.placeholder ?? `arg${i + 1}`;
+        return param.optional || typeof param.default !== "undefined" ? wrapOptionalParameter(argName) : wrapRequiredParameter(argName);
+      });
+    }
+  }
+  return [...args.prefix, ...flagsUsage, ...positionalUsage].join(" ");
+}
+function formatDocumentationForFlagParameters(flags, aliases, args) {
+  const { keywords, briefs } = args.text;
+  const visibleFlags = Object.entries(flags).filter(([, flag]) => {
+    if (flag.hidden && !args.includeHidden) {
+      return false;
+    }
+    return true;
+  });
+  const atLeastOneOptional = visibleFlags.some(([, flag]) => isOptionalAtRuntime(flag));
+  const rows = visibleFlags.map(([name, flag]) => {
+    const aliasStrings = Object.entries(aliases).filter((entry) => entry[1] === name).map(([alias]) => `-${alias}`);
+    let flagName = "--" + formatForDisplay(name, args.config.caseStyle);
+    if (flag.kind === "boolean" && flag.default !== false && flag.withNegated !== false) {
+      const negatedFlagName = formatAsNegated(name, args.config.caseStyle);
+      flagName = `${flagName}/--${negatedFlagName}`;
+    }
+    if (isOptionalAtRuntime(flag)) {
+      flagName = `[${flagName}]`;
+    } else if (atLeastOneOptional) {
+      flagName = ` ${flagName}`;
+    }
+    if (flag.kind === "parsed" && flag.variadic) {
+      flagName = `${flagName}...`;
+    }
+    const suffixParts = [];
+    if (flag.kind === "enum") {
+      const choices = flag.values.join("|");
+      suffixParts.push(choices);
+    }
+    if (hasDefault(flag)) {
+      const defaultKeyword = args.ansiColor ? `\x1B[90m${keywords.default}\x1B[39m` : keywords.default;
+      let defaultValue;
+      if (Array.isArray(flag.default)) {
+        if (flag.default.length === 0) {
+          defaultValue = "[]";
+        } else {
+          const separator = "variadic" in flag && typeof flag.variadic === "string" ? flag.variadic : " ";
+          defaultValue = flag.default.join(separator);
+        }
+      } else {
+        defaultValue = flag.default === "" ? `""` : String(flag.default);
+      }
+      suffixParts.push(`${defaultKeyword} ${defaultValue}`);
+    }
+    if ("variadic" in flag && typeof flag.variadic === "string") {
+      const separatorKeyword = args.ansiColor ? `\x1B[90m${keywords.separator}\x1B[39m` : keywords.separator;
+      suffixParts.push(`${separatorKeyword} ${flag.variadic}`);
+    }
+    const suffix = suffixParts.length > 0 ? `[${suffixParts.join(", ")}]` : undefined;
+    return {
+      aliases: aliasStrings.join(" "),
+      flagName,
+      brief: flag.brief,
+      suffix,
+      hidden: flag.hidden
+    };
+  });
+  rows.push({
+    aliases: "-h",
+    flagName: atLeastOneOptional ? " --help" : "--help",
+    brief: briefs.help
+  });
+  if (args.includeHelpAllFlag) {
+    const helpAllFlagName = formatForDisplay("helpAll", args.config.caseStyle);
+    rows.push({
+      aliases: "-H",
+      flagName: atLeastOneOptional ? ` --${helpAllFlagName}` : `--${helpAllFlagName}`,
+      brief: briefs.helpAll,
+      hidden: !args.config.alwaysShowHelpAllFlag
+    });
+  }
+  if (args.includeVersionFlag) {
+    rows.push({
+      aliases: "-v",
+      flagName: atLeastOneOptional ? " --version" : "--version",
+      brief: briefs.version
+    });
+  }
+  if (args.includeArgumentEscapeSequenceFlag) {
+    rows.push({
+      aliases: "",
+      flagName: atLeastOneOptional ? " --" : "--",
+      brief: briefs.argumentEscapeSequence
+    });
+  }
+  return formatRowsWithColumns(rows.map((row) => {
+    if (!args.ansiColor) {
+      return [row.aliases, row.flagName, row.brief, row.suffix ?? ""];
+    }
+    return [
+      row.hidden ? `\x1B[90m${row.aliases}\x1B[39m` : `\x1B[97m${row.aliases}\x1B[39m`,
+      row.hidden ? `\x1B[90m${row.flagName}\x1B[39m` : `\x1B[97m${row.flagName}\x1B[39m`,
+      row.hidden ? `\x1B[90m${row.brief}\x1B[39m` : `\x1B[03m${row.brief}\x1B[23m`,
+      row.suffix ?? ""
+    ];
+  }), [" ", "  ", " "]);
+}
+function* generateBuiltInFlagUsageLines(args) {
+  yield args.config.useAliasInUsageLine ? "-h" : "--help";
+  if (args.includeHelpAllFlag) {
+    const helpAllFlagName = formatForDisplay("helpAll", args.config.caseStyle);
+    yield args.config.useAliasInUsageLine ? "-H" : `--${helpAllFlagName}`;
+  }
+  if (args.includeVersionFlag) {
+    yield args.config.useAliasInUsageLine ? "-v" : "--version";
+  }
+}
+function formatDocumentationForPositionalParameters(positional, args) {
+  if (positional.kind === "array") {
+    const name = positional.parameter.placeholder ?? "args";
+    const argName = args.ansiColor ? `\x1B[97m${name}...\x1B[39m` : `${name}...`;
+    const brief = args.ansiColor ? `\x1B[3m${positional.parameter.brief}\x1B[23m` : positional.parameter.brief;
+    return formatRowsWithColumns([[argName, brief]], ["  "]);
+  }
+  const { keywords } = args.text;
+  const atLeastOneOptional = positional.parameters.some((def) => def.optional);
+  return formatRowsWithColumns(positional.parameters.map((def, i) => {
+    let name = def.placeholder ?? `arg${i + 1}`;
+    let suffix;
+    if (def.optional) {
+      name = `[${name}]`;
+    } else if (atLeastOneOptional) {
+      name = ` ${name}`;
+    }
+    if (def.default) {
+      const defaultKeyword = args.ansiColor ? `\x1B[90m${keywords.default}\x1B[39m` : keywords.default;
+      suffix = `[${defaultKeyword} ${def.default}]`;
+    }
+    return [
+      args.ansiColor ? `\x1B[97m${name}\x1B[39m` : name,
+      args.ansiColor ? `\x1B[3m${def.brief}\x1B[23m` : def.brief,
+      suffix ?? ""
+    ];
+  }), ["  ", " "]);
+}
+function* generateCommandHelpLines(parameters, docs, args) {
+  const { brief, fullDescription, customUsage } = docs;
+  const { headers } = args.text;
+  const prefix = args.prefix.join(" ");
+  yield args.ansiColor ? `\x1B[1m${headers.usage}\x1B[22m` : headers.usage;
+  if (customUsage) {
+    for (const usage of customUsage) {
+      if (typeof usage === "string") {
+        yield `  ${prefix} ${usage}`;
+      } else {
+        const brief2 = args.ansiColor ? `\x1B[3m${usage.brief}\x1B[23m` : usage.brief;
+        yield `  ${prefix} ${usage.input}
+    ${brief2}`;
+      }
+    }
+  } else {
+    yield `  ${formatUsageLineForParameters(parameters, args)}`;
+  }
+  for (const line of generateBuiltInFlagUsageLines(args)) {
+    yield `  ${prefix} ${line}`;
+  }
+  yield "";
+  yield fullDescription ?? brief;
+  if (args.aliases && args.aliases.length > 0) {
+    const aliasPrefix = args.prefix.slice(0, -1).join(" ");
+    yield "";
+    yield args.ansiColor ? `\x1B[1m${headers.aliases}\x1B[22m` : headers.aliases;
+    for (const alias of args.aliases) {
+      yield `  ${aliasPrefix} ${alias}`;
+    }
+  }
+  yield "";
+  yield args.ansiColor ? `\x1B[1m${headers.flags}\x1B[22m` : headers.flags;
+  for (const line of formatDocumentationForFlagParameters(parameters.flags ?? {}, parameters.aliases ?? {}, args)) {
+    yield `  ${line}`;
+  }
+  const positional = parameters.positional ?? { kind: "tuple", parameters: [] };
+  if (positional.kind === "array" || positional.parameters.length > 0) {
+    yield "";
+    yield args.ansiColor ? `\x1B[1m${headers.arguments}\x1B[22m` : headers.arguments;
+    for (const line of formatDocumentationForPositionalParameters(positional, args)) {
+      yield `  ${line}`;
+    }
+  }
+}
+function checkForReservedFlags(flags, reserved) {
+  for (const flag of reserved) {
+    if (flag in flags) {
+      throw new InternalError(`Unable to use reserved flag --${flag}`);
+    }
+  }
+}
+function checkForReservedAliases(aliases, reserved) {
+  for (const alias of reserved) {
+    if (alias in aliases) {
+      throw new InternalError(`Unable to use reserved alias -${alias}`);
+    }
+  }
+}
+function* asNegationFlagNames(flagName) {
+  yield `no-${convertCamelCaseToKebabCase(flagName)}`;
+  yield `no${flagName[0].toUpperCase()}${flagName.slice(1)}`;
+}
+function checkForNegationCollisions(flags) {
+  const flagsAllowingNegation = Object.entries(flags).filter(([, flag]) => flag.kind === "boolean" && !flag.optional);
+  for (const [internalFlagName] of flagsAllowingNegation) {
+    for (const negatedFlagName of asNegationFlagNames(internalFlagName)) {
+      if (negatedFlagName in flags) {
+        throw new InternalError(`Unable to allow negation for --${internalFlagName} as it conflicts with --${negatedFlagName}`);
+      }
+    }
+  }
+}
+function checkForInvalidVariadicSeparators(flags) {
+  for (const [internalFlagName, flag] of Object.entries(flags)) {
+    if ("variadic" in flag && typeof flag.variadic === "string") {
+      if (flag.variadic.length < 1) {
+        throw new InternalError(`Unable to use "" as variadic separator for --${internalFlagName} as it is empty`);
+      }
+      if (/\s/.test(flag.variadic)) {
+        throw new InternalError(`Unable to use "${flag.variadic}" as variadic separator for --${internalFlagName} as it contains whitespace`);
+      }
+    }
+  }
+}
+function buildCommand(builderArgs) {
+  const { flags = {}, aliases = {} } = builderArgs.parameters;
+  checkForReservedFlags(flags, ["help", "helpAll", "help-all"]);
+  checkForReservedAliases(aliases, ["h", "H"]);
+  checkForNegationCollisions(flags);
+  checkForInvalidVariadicSeparators(flags);
+  let loader;
+  if ("func" in builderArgs) {
+    loader = async () => builderArgs.func;
+  } else {
+    loader = builderArgs.loader;
+  }
+  return {
+    kind: CommandSymbol,
+    loader,
+    parameters: builderArgs.parameters,
+    get brief() {
+      return builderArgs.docs.brief;
+    },
+    get fullDescription() {
+      return builderArgs.docs.fullDescription;
+    },
+    formatUsageLine: (args) => {
+      return formatUsageLineForParameters(builderArgs.parameters, args);
+    },
+    formatHelp: (args) => {
+      const lines = [
+        ...generateCommandHelpLines(builderArgs.parameters, builderArgs.docs, args)
+      ];
+      const text = lines.join(`
+`);
+      return text + `
+`;
+    },
+    usesFlag: (flagName) => {
+      return Boolean(flagName in flags || flagName in aliases);
+    }
+  };
+}
+function* generateRouteMapHelpLines(routes, docs, args) {
+  const { brief, fullDescription, hideRoute } = docs;
+  const { headers } = args.text;
+  yield args.ansiColor ? `\x1B[1m${headers.usage}\x1B[22m` : headers.usage;
+  for (const [name, route] of Object.entries(routes)) {
+    if (!hideRoute || !hideRoute[name] || args.includeHidden) {
+      const externalRouteName = args.config.caseStyle === "convert-camel-to-kebab" ? convertCamelCaseToKebabCase(name) : name;
+      yield `  ${route.formatUsageLine({
+        ...args,
+        prefix: [...args.prefix, externalRouteName]
+      })}`;
+    }
+  }
+  const prefix = args.prefix.join(" ");
+  for (const line of generateBuiltInFlagUsageLines(args)) {
+    yield `  ${prefix} ${line}`;
+  }
+  yield "";
+  yield fullDescription ?? brief;
+  if (args.aliases && args.aliases.length > 0) {
+    const aliasPrefix = args.prefix.slice(0, -1).join(" ");
+    yield "";
+    yield args.ansiColor ? `\x1B[1m${headers.aliases}\x1B[22m` : headers.aliases;
+    for (const alias of args.aliases) {
+      yield `  ${aliasPrefix} ${alias}`;
+    }
+  }
+  yield "";
+  yield args.ansiColor ? `\x1B[1m${headers.flags}\x1B[22m` : headers.flags;
+  for (const line of formatDocumentationForFlagParameters({}, {}, args)) {
+    yield `  ${line}`;
+  }
+  yield "";
+  yield args.ansiColor ? `\x1B[1m${headers.commands}\x1B[22m` : headers.commands;
+  const visibleRoutes = Object.entries(routes).filter(([name]) => !hideRoute || !hideRoute[name] || args.includeHidden);
+  const rows = visibleRoutes.map(([internalRouteName, route]) => {
+    const externalRouteName = formatForDisplay(internalRouteName, args.config.caseStyle);
+    return {
+      routeName: externalRouteName,
+      brief: route.brief,
+      hidden: hideRoute && hideRoute[internalRouteName]
+    };
+  });
+  const formattedRows = formatRowsWithColumns(rows.map((row) => {
+    if (!args.ansiColor) {
+      return [row.routeName, row.brief];
+    }
+    return [
+      row.hidden ? `\x1B[90m${row.routeName}\x1B[39m` : `\x1B[97m${row.routeName}\x1B[39m`,
+      row.hidden ? `\x1B[90m${row.brief}\x1B[39m` : `\x1B[03m${row.brief}\x1B[23m`
+    ];
+  }), ["  "]);
+  for (const line of formattedRows) {
+    yield `  ${line}`;
+  }
+}
+function buildRouteMap({
+  routes,
+  defaultCommand: defaultCommandRoute,
+  docs,
+  aliases
+}) {
+  if (Object.entries(routes).length === 0) {
+    throw new InternalError("Route map must contain at least one route");
+  }
+  const activeAliases = aliases ?? {};
+  const aliasesByRoute = /* @__PURE__ */ new Map;
+  for (const [alias, routeName] of Object.entries(activeAliases)) {
+    if (alias in routes) {
+      throw new InternalError(`Cannot use "${alias}" as an alias when a route with that name already exists`);
+    }
+    const routeAliases = aliasesByRoute.get(routeName) ?? [];
+    aliasesByRoute.set(routeName, [...routeAliases, alias]);
+  }
+  const defaultCommand = defaultCommandRoute ? routes[defaultCommandRoute] : undefined;
+  if (defaultCommand && defaultCommand.kind === RouteMapSymbol) {
+    throw new InternalError(`Cannot use "${defaultCommandRoute}" as the default command because it is not a Command`);
+  }
+  const resolveRouteName = (input) => {
+    if (input in activeAliases) {
+      return activeAliases[input];
+    } else if (input in routes) {
+      return input;
+    }
+  };
+  return {
+    kind: RouteMapSymbol,
+    get brief() {
+      return docs.brief;
+    },
+    get fullDescription() {
+      return docs.fullDescription;
+    },
+    formatUsageLine(args) {
+      const routeNames = this.getAllEntries().filter((entry) => !entry.hidden).map((entry) => entry.name[args.config.caseStyle]);
+      return `${args.prefix.join(" ")} ${routeNames.join("|")} ...`;
+    },
+    formatHelp: (config) => {
+      const lines = [...generateRouteMapHelpLines(routes, docs, config)];
+      const text = lines.join(`
+`);
+      return text + `
+`;
+    },
+    getDefaultCommand: () => {
+      return defaultCommand;
+    },
+    getOtherAliasesForInput: (input, caseStyle) => {
+      if (defaultCommandRoute) {
+        if (input === defaultCommandRoute) {
+          return {
+            original: [""],
+            "convert-camel-to-kebab": [""]
+          };
+        }
+        if (input === "") {
+          return {
+            original: [defaultCommandRoute],
+            "convert-camel-to-kebab": [defaultCommandRoute]
+          };
+        }
+      }
+      const camelInput = convertKebabCaseToCamelCase(input);
+      let routeName = resolveRouteName(input);
+      if (!routeName && caseStyle === "allow-kebab-for-camel") {
+        routeName = resolveRouteName(camelInput);
+      }
+      if (!routeName) {
+        return {
+          original: [],
+          "convert-camel-to-kebab": []
+        };
+      }
+      const otherAliases = [routeName, ...aliasesByRoute.get(routeName) ?? []].filter((alias) => alias !== input && alias !== camelInput);
+      return {
+        original: otherAliases,
+        "convert-camel-to-kebab": otherAliases.map(convertCamelCaseToKebabCase)
+      };
+    },
+    getRoutingTargetForInput: (input) => {
+      const routeName = input in activeAliases ? activeAliases[input] : input;
+      return routes[routeName];
+    },
+    getAllEntries() {
+      const hiddenRoutes = docs.hideRoute;
+      return Object.entries(routes).map(([originalRouteName, target]) => {
+        return {
+          name: {
+            original: originalRouteName,
+            "convert-camel-to-kebab": convertCamelCaseToKebabCase(originalRouteName)
+          },
+          target,
+          aliases: aliasesByRoute.get(originalRouteName) ?? [],
+          hidden: hiddenRoutes?.[originalRouteName] ?? false
+        };
+      });
+    }
+  };
+}
+async function run(app, inputs, context) {
+  const exitCode = await runApplication(app, inputs, context);
+  context.process.exitCode = exitCode;
+}
+
+// src/commands/login.ts
+import { randomBytes } from "crypto";
+
+// src/lib/credentials.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+function getConfigDir() {
+  return process.env.RUDEL_CONFIG_DIR ?? join(process.env.HOME ?? "~", ".rudel");
+}
+function getCredentialsPath() {
+  return join(getConfigDir(), "credentials.json");
+}
+function saveCredentials(token, apiBaseUrl) {
+  const dir = getConfigDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+  const data = { token, apiBaseUrl };
+  writeFileSync(getCredentialsPath(), JSON.stringify(data, null, 2), {
+    mode: 384
+  });
+}
+function loadCredentials() {
+  const path = getCredentialsPath();
+  if (!existsSync(path))
+    return null;
+  const content = readFileSync(path, "utf-8");
+  return JSON.parse(content);
+}
+function clearCredentials() {
+  const path = getCredentialsPath();
+  if (existsSync(path)) {
+    rmSync(path);
+  }
+}
+
+// src/commands/login.ts
+var DEFAULT_API_BASE = "https://rudel.numia.workers.dev";
+var DEFAULT_WEB_URL = "https://rudel.numia.workers.dev";
+var CALLBACK_TIMEOUT_MS = 120000;
+async function runLogin(flags) {
+  const write = (msg) => process.stdout.write(`${msg}
+`);
+  const writeError = (msg) => process.stderr.write(`${msg}
+`);
+  const existing = loadCredentials();
+  if (existing) {
+    write("Already logged in. Run `rudel logout` first to switch accounts.");
+    return;
+  }
+  const state = randomBytes(16).toString("hex");
+  let resolveCallback;
+  let rejectCallback;
+  const tokenPromise = new Promise((resolve, reject) => {
+    resolveCallback = resolve;
+    rejectCallback = reject;
+  });
+  const server = Bun.serve({
+    port: 0,
+    hostname: "127.0.0.1",
+    fetch(request) {
+      const url = new URL(request.url);
+      if (url.pathname !== "/callback") {
+        return new Response("Not found", { status: 404 });
+      }
+      const receivedToken = url.searchParams.get("token");
+      const receivedState = url.searchParams.get("state");
+      if (receivedState !== state) {
+        rejectCallback(new Error("State mismatch \u2014 possible CSRF attack"));
+        return new Response("<html><body><h1>Login failed</h1><p>State mismatch. Please try again.</p></body></html>", { headers: { "Content-Type": "text/html" } });
+      }
+      if (!receivedToken) {
+        rejectCallback(new Error("No token received"));
+        return new Response("<html><body><h1>Login failed</h1><p>No token received.</p></body></html>", { headers: { "Content-Type": "text/html" } });
+      }
+      resolveCallback(receivedToken);
+      return new Response("<html><body><h1>Login successful!</h1><p>You can close this tab and return to the terminal.</p></body></html>", { headers: { "Content-Type": "text/html" } });
+    }
+  });
+  const callbackUrl = `http://127.0.0.1:${server.port}/callback`;
+  const loginUrl = `${flags.webUrl}?cli_callback=${encodeURIComponent(callbackUrl)}&state=${state}`;
+  write("Opening browser for authentication...");
+  write(`If the browser doesn't open, visit: ${loginUrl}`);
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  Bun.spawn([opener, loginUrl], { stdout: "ignore", stderr: "ignore" });
+  const timeout = setTimeout(() => {
+    rejectCallback(new Error("Login timed out after 120 seconds"));
+  }, CALLBACK_TIMEOUT_MS);
+  let token;
+  try {
+    token = await tokenPromise;
+  } catch (error) {
+    clearTimeout(timeout);
+    server.stop();
+    writeError(`Login failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+    return;
+  }
+  clearTimeout(timeout);
+  server.stop();
+  write("Validating token...");
+  const meResponse = await fetch(`${flags.apiBase}/rpc/me`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({})
+  });
+  if (!meResponse.ok) {
+    writeError("Login failed: token validation failed");
+    process.exitCode = 1;
+    return;
+  }
+  const body = await meResponse.json();
+  saveCredentials(token, flags.apiBase);
+  write(`Logged in as ${body.json.name} (${body.json.email})`);
+}
+var loginCommand = buildCommand({
+  loader: async () => ({ default: runLogin }),
+  parameters: {
+    flags: {
+      apiBase: {
+        kind: "parsed",
+        parse: String,
+        brief: "API server base URL",
+        default: DEFAULT_API_BASE
+      },
+      webUrl: {
+        kind: "parsed",
+        parse: String,
+        brief: "Web app URL for authentication",
+        default: DEFAULT_WEB_URL
+      }
+    }
+  },
+  docs: {
+    brief: "Authenticate with the Rudel API via browser login"
+  }
+});
+
+// src/commands/logout.ts
+async function runLogout() {
+  const write = (msg) => process.stdout.write(`${msg}
+`);
+  const credentials = loadCredentials();
+  if (!credentials) {
+    write("Not logged in.");
+    return;
+  }
+  clearCredentials();
+  write("Logged out successfully.");
+}
+var logoutCommand = buildCommand({
+  loader: async () => ({ default: runLogout }),
+  parameters: {},
+  docs: {
+    brief: "Log out and remove stored credentials"
+  }
+});
+
+// src/lib/classifier.ts
+import { mkdir, unlink } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/lib/types.ts
+var SESSION_TAGS = [
+  "research",
+  "new_feature",
+  "bug_fix",
+  "refactoring",
+  "documentation",
+  "tests",
+  "other"
+];
+var DEFAULT_ENDPOINT = "https://rudel.numia.workers.dev/rpc";
+
+// src/lib/classifier.ts
+var SYSTEM_PROMPT = `You are a session classifier. Analyze the Claude Code session transcript and classify it into exactly ONE of these categories:
+
+- research: Exploring codebase, understanding code, answering questions about how things work
+- new_feature: Implementing new functionality or features
+- bug_fix: Fixing bugs, errors, or unexpected behavior
+- refactoring: Restructuring existing code without changing functionality
+- documentation: Writing or updating documentation, comments, READMEs
+- tests: Writing, updating, or fixing tests
+
+CRITICAL: Respond with ONLY the tag name. Nothing else. No explanation, no punctuation, no formatting. Just ONE of: research, new_feature, bug_fix, refactoring, documentation, tests`;
+async function classifySession(content) {
+  const truncatedContent = content.slice(0, 50000);
+  const tempDir = join2(homedir(), ".claude", "temp");
+  const tempFile = join2(tempDir, `classify-${Date.now()}.txt`);
+  try {
+    await mkdir(tempDir, { recursive: true });
+    await Bun.write(tempFile, `Classify this session transcript:
+
+${truncatedContent}`);
+    const prompt = `Read and classify the session transcript in this file: ${tempFile}`;
+    const escapedPrompt = prompt.replace(/'/g, "'\\''");
+    const escapedSystemPrompt = SYSTEM_PROMPT.replace(/'/g, "'\\''");
+    const proc = Bun.spawn([
+      "sh",
+      "-c",
+      `echo '${escapedPrompt}' | claude --output-format text --print --model haiku --no-session-persistence --dangerously-skip-permissions --system-prompt '${escapedSystemPrompt}'`
+    ], { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    if (exitCode !== 0) {
+      return "other";
+    }
+    const output = stdout.trim().toLowerCase();
+    if (SESSION_TAGS.includes(output)) {
+      return output;
+    }
+    for (const tag of SESSION_TAGS) {
+      if (new RegExp(`\\b${tag}\\b`).test(output)) {
+        return tag;
+      }
+    }
+    return "other";
+  } catch {
+    return;
+  } finally {
+    try {
+      await unlink(tempFile);
+    } catch {}
+  }
+}
+
+// src/lib/git-info.ts
+import { join as join3 } from "path";
+var {$ } = globalThis.Bun;
+async function getGitInfo(cwd) {
+  const [repository, branch, sha] = await Promise.all([
+    getRepositoryName(cwd),
+    getGitBranch(cwd),
+    getGitSha(cwd)
+  ]);
+  return {
+    repository: repository ?? undefined,
+    branch: branch ?? undefined,
+    sha: sha ?? undefined
+  };
+}
+async function getRepositoryName(cwd) {
+  try {
+    const gitRootResult = await $`git -C ${cwd} rev-parse --show-toplevel`.quiet();
+    if (gitRootResult.exitCode !== 0)
+      return null;
+    const gitRoot = gitRootResult.text().trim();
+    const packageJsonPath = join3(gitRoot, "package.json");
+    const packageFile = Bun.file(packageJsonPath);
+    if (await packageFile.exists()) {
+      try {
+        const packageJson = await packageFile.json();
+        if (packageJson.name)
+          return packageJson.name;
+      } catch {}
+    }
+    const remoteResult = await $`git -C ${gitRoot} remote get-url origin`.quiet();
+    if (remoteResult.exitCode === 0) {
+      const remoteUrl = remoteResult.text().trim();
+      const match = remoteUrl.match(/[/:]([^/]+?)(?:\.git)?$/);
+      if (match?.[1])
+        return match[1];
+    }
+    const dirName = gitRoot.split("/").pop();
+    return dirName ?? null;
+  } catch {
+    return null;
+  }
+}
+async function getGitBranch(cwd) {
+  try {
+    const result = await $`git -C ${cwd} rev-parse --abbrev-ref HEAD`.quiet();
+    if (result.exitCode !== 0)
+      return null;
+    return result.text().trim();
+  } catch {
+    return null;
+  }
+}
+async function getGitSha(cwd) {
+  try {
+    const result = await $`git -C ${cwd} rev-parse HEAD`.quiet();
+    if (result.exitCode !== 0)
+      return null;
+    return result.text().trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/session-resolver.ts
+import { readdir, stat } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { basename, dirname, join as join4 } from "path";
+var SESSIONS_BASE_DIR = join4(homedir2(), ".claude", "projects");
+async function resolveSession(input) {
+  const isPath = input.includes("/") || input.endsWith(".jsonl");
+  if (isPath) {
+    return resolveFromPath(input);
+  }
+  return resolveFromId(input);
+}
+async function resolveFromPath(filePath) {
+  const filename = basename(filePath);
+  validateNotSubagent(filename);
+  const file = Bun.file(filePath);
+  if (!await file.exists()) {
+    throw new Error(`Session file not found: ${filePath}`);
+  }
+  const sessionId = filename.replace(/\.jsonl$/, "");
+  const sessionDir = dirname(filePath);
+  const parentDir = basename(sessionDir);
+  const projectPath = await decodeProjectPath(parentDir);
+  return { transcriptPath: filePath, projectPath, sessionDir, sessionId };
+}
+async function resolveFromId(sessionId) {
+  validateNotSubagent(`${sessionId}.jsonl`);
+  const sessionFileName = `${sessionId}.jsonl`;
+  let projectDirs;
+  try {
+    projectDirs = await readdir(SESSIONS_BASE_DIR);
+  } catch {
+    throw new Error(`Session not found: ${sessionId}`);
+  }
+  for (const projectDir of projectDirs) {
+    const sessionDir = join4(SESSIONS_BASE_DIR, projectDir);
+    try {
+      const files = await readdir(sessionDir);
+      if (files.includes(sessionFileName)) {
+        const transcriptPath = join4(sessionDir, sessionFileName);
+        const projectPath = await decodeProjectPath(projectDir);
+        return {
+          transcriptPath,
+          projectPath,
+          sessionDir,
+          sessionId
+        };
+      }
+    } catch {}
+  }
+  throw new Error(`Session not found: ${sessionId}`);
+}
+function validateNotSubagent(filename) {
+  if (filename.startsWith("agent-") && filename.endsWith(".jsonl")) {
+    throw new Error("This is a subagent file, not a main session. Please provide the main session ID or path.");
+  }
+}
+async function decodeProjectPath(encodedDir) {
+  const parts = encodedDir.replace(/^-/, "").split("-");
+  async function findPath(partIndex, currentPath) {
+    if (partIndex >= parts.length) {
+      try {
+        await stat(currentPath);
+        return currentPath;
+      } catch {
+        return null;
+      }
+    }
+    for (let endIndex = parts.length;endIndex > partIndex; endIndex--) {
+      const segment = parts.slice(partIndex, endIndex).join("-");
+      const testPath = currentPath ? `${currentPath}/${segment}` : `/${segment}`;
+      try {
+        await stat(testPath);
+        if (endIndex === parts.length) {
+          return testPath;
+        }
+        const result2 = await findPath(endIndex, testPath);
+        if (result2) {
+          return result2;
+        }
+      } catch {}
+    }
+    return null;
+  }
+  const result = await findPath(0, "");
+  if (result) {
+    return result;
+  }
+  return `/${parts.join("/")}`;
+}
+
+// src/lib/subagent-reader.ts
+import { join as join5 } from "path";
+async function readSubagentFiles(sessionDir, agentIds, sessionId) {
+  const subagents = [];
+  for (const agentId of agentIds) {
+    const possiblePaths = [
+      join5(sessionDir, `agent-${agentId}.jsonl`),
+      ...sessionId ? [join5(sessionDir, sessionId, "subagents", `agent-${agentId}.jsonl`)] : []
+    ];
+    for (const agentPath of possiblePaths) {
+      try {
+        const file = Bun.file(agentPath);
+        if (await file.exists()) {
+          const content = await file.text();
+          subagents.push({ agentId, content });
+          break;
+        }
+      } catch {}
+    }
+  }
+  return subagents;
+}
+
+// src/lib/transcript-reader.ts
+async function readTranscript(transcriptPath) {
+  const maxRetries = 5;
+  const delayMs = 500;
+  for (let attempt = 1;attempt <= maxRetries; attempt++) {
+    try {
+      const file = Bun.file(transcriptPath);
+      if (!await file.exists()) {
+        if (attempt < maxRetries) {
+          await new Promise((resolve) => setTimeout(resolve, delayMs));
+          continue;
+        }
+        throw new Error(`Transcript file not found after ${maxRetries} attempts: ${transcriptPath}`);
+      }
+      return await file.text();
+    } catch (error) {
+      if (attempt < maxRetries) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new Error(`Failed to read transcript: ${transcriptPath}`);
+}
+function extractAgentIds(sessionContent) {
+  const agentIds = new Set;
+  for (const line of sessionContent.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.toolUseResult?.agentId) {
+        agentIds.add(entry.toolUseResult.agentId);
+      }
+    } catch {}
+  }
+  return Array.from(agentIds);
+}
+
+// ../../node_modules/.bun/@orpc+shared@1.13.5/node_modules/@orpc/shared/dist/index.mjs
+function resolveMaybeOptionalOptions(rest) {
+  return rest[0] ?? {};
+}
+function toArray(value) {
+  return Array.isArray(value) ? value : value === undefined || value === null ? [] : [value];
+}
+var ORPC_NAME = "orpc";
+var ORPC_SHARED_PACKAGE_NAME = "@orpc/shared";
+var ORPC_SHARED_PACKAGE_VERSION = "1.13.5";
+
+class AbortError extends Error {
+  constructor(...rest) {
+    super(...rest);
+    this.name = "AbortError";
+  }
+}
+function once(fn) {
+  let cached;
+  return () => {
+    if (cached) {
+      return cached.result;
+    }
+    const result = fn();
+    cached = { result };
+    return result;
+  };
+}
+function sequential(fn) {
+  let lastOperationPromise = Promise.resolve();
+  return (...args) => {
+    return lastOperationPromise = lastOperationPromise.catch(() => {}).then(() => {
+      return fn(...args);
+    });
+  };
+}
+var SPAN_ERROR_STATUS = 2;
+var GLOBAL_OTEL_CONFIG_KEY = `__${ORPC_SHARED_PACKAGE_NAME}@${ORPC_SHARED_PACKAGE_VERSION}/otel/config__`;
+function getGlobalOtelConfig() {
+  return globalThis[GLOBAL_OTEL_CONFIG_KEY];
+}
+function startSpan(name, options = {}, context) {
+  const tracer = getGlobalOtelConfig()?.tracer;
+  return tracer?.startSpan(name, options, context);
+}
+function setSpanError(span, error, options = {}) {
+  if (!span) {
+    return;
+  }
+  const exception = toOtelException(error);
+  span.recordException(exception);
+  if (!options.signal?.aborted || options.signal.reason !== error) {
+    span.setStatus({
+      code: SPAN_ERROR_STATUS,
+      message: exception.message
+    });
+  }
+}
+function toOtelException(error) {
+  if (error instanceof Error) {
+    const exception = {
+      message: error.message,
+      name: error.name,
+      stack: error.stack
+    };
+    if ("code" in error && (typeof error.code === "string" || typeof error.code === "number")) {
+      exception.code = error.code;
+    }
+    return exception;
+  }
+  return { message: String(error) };
+}
+async function runWithSpan({ name, context, ...options }, fn) {
+  const tracer = getGlobalOtelConfig()?.tracer;
+  if (!tracer) {
+    return fn();
+  }
+  const callback = async (span) => {
+    try {
+      return await fn(span);
+    } catch (e) {
+      setSpanError(span, e, options);
+      throw e;
+    } finally {
+      span.end();
+    }
+  };
+  if (context) {
+    return tracer.startActiveSpan(name, options, context, callback);
+  } else {
+    return tracer.startActiveSpan(name, options, callback);
+  }
+}
+async function runInSpanContext(span, fn) {
+  const otelConfig = getGlobalOtelConfig();
+  if (!span || !otelConfig) {
+    return fn();
+  }
+  const ctx = otelConfig.trace.setSpan(otelConfig.context.active(), span);
+  return otelConfig.context.with(ctx, fn);
+}
+function isAsyncIteratorObject(maybe) {
+  if (!maybe || typeof maybe !== "object") {
+    return false;
+  }
+  return "next" in maybe && typeof maybe.next === "function" && Symbol.asyncIterator in maybe && typeof maybe[Symbol.asyncIterator] === "function";
+}
+var fallbackAsyncDisposeSymbol = Symbol.for("asyncDispose");
+var asyncDisposeSymbol = Symbol.asyncDispose ?? fallbackAsyncDisposeSymbol;
+
+class AsyncIteratorClass {
+  #isDone = false;
+  #isExecuteComplete = false;
+  #cleanup;
+  #next;
+  constructor(next, cleanup) {
+    this.#cleanup = cleanup;
+    this.#next = sequential(async () => {
+      if (this.#isDone) {
+        return { done: true, value: undefined };
+      }
+      try {
+        const result = await next();
+        if (result.done) {
+          this.#isDone = true;
+        }
+        return result;
+      } catch (err) {
+        this.#isDone = true;
+        throw err;
+      } finally {
+        if (this.#isDone && !this.#isExecuteComplete) {
+          this.#isExecuteComplete = true;
+          await this.#cleanup("next");
+        }
+      }
+    });
+  }
+  next() {
+    return this.#next();
+  }
+  async return(value) {
+    this.#isDone = true;
+    if (!this.#isExecuteComplete) {
+      this.#isExecuteComplete = true;
+      await this.#cleanup("return");
+    }
+    return { done: true, value };
+  }
+  async throw(err) {
+    this.#isDone = true;
+    if (!this.#isExecuteComplete) {
+      this.#isExecuteComplete = true;
+      await this.#cleanup("throw");
+    }
+    throw err;
+  }
+  async[asyncDisposeSymbol]() {
+    this.#isDone = true;
+    if (!this.#isExecuteComplete) {
+      this.#isExecuteComplete = true;
+      await this.#cleanup("dispose");
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+}
+function asyncIteratorWithSpan({ name, ...options }, iterator) {
+  let span;
+  return new AsyncIteratorClass(async () => {
+    span ??= startSpan(name);
+    try {
+      const result = await runInSpanContext(span, () => iterator.next());
+      span?.addEvent(result.done ? "completed" : "yielded");
+      return result;
+    } catch (err) {
+      setSpanError(span, err, options);
+      throw err;
+    }
+  }, async (reason) => {
+    try {
+      if (reason !== "next") {
+        await runInSpanContext(span, () => iterator.return?.());
+      }
+    } catch (err) {
+      setSpanError(span, err, options);
+      throw err;
+    } finally {
+      span?.end();
+    }
+  });
+}
+
+class EventPublisher {
+  #listenersMap = /* @__PURE__ */ new Map;
+  #maxBufferedEvents;
+  constructor(options = {}) {
+    this.#maxBufferedEvents = options.maxBufferedEvents ?? 100;
+  }
+  get size() {
+    return this.#listenersMap.size;
+  }
+  publish(event, payload) {
+    const listeners = this.#listenersMap.get(event);
+    if (!listeners) {
+      return;
+    }
+    for (const listener of listeners) {
+      listener(payload);
+    }
+  }
+  subscribe(event, listenerOrOptions) {
+    if (typeof listenerOrOptions === "function") {
+      let listeners = this.#listenersMap.get(event);
+      if (!listeners) {
+        this.#listenersMap.set(event, listeners = []);
+      }
+      listeners.push(listenerOrOptions);
+      return once(() => {
+        listeners.splice(listeners.indexOf(listenerOrOptions), 1);
+        if (listeners.length === 0) {
+          this.#listenersMap.delete(event);
+        }
+      });
+    }
+    const signal = listenerOrOptions?.signal;
+    const maxBufferedEvents = listenerOrOptions?.maxBufferedEvents ?? this.#maxBufferedEvents;
+    signal?.throwIfAborted();
+    const bufferedEvents = [];
+    const pullResolvers = [];
+    const unsubscribe = this.subscribe(event, (payload) => {
+      const resolver = pullResolvers.shift();
+      if (resolver) {
+        resolver[0]({ done: false, value: payload });
+      } else {
+        bufferedEvents.push(payload);
+        if (bufferedEvents.length > maxBufferedEvents) {
+          bufferedEvents.shift();
+        }
+      }
+    });
+    const abortListener = (event2) => {
+      unsubscribe();
+      pullResolvers.forEach((resolver) => resolver[1](event2.target.reason));
+      pullResolvers.length = 0;
+      bufferedEvents.length = 0;
+    };
+    signal?.addEventListener("abort", abortListener, { once: true });
+    return new AsyncIteratorClass(async () => {
+      if (signal?.aborted) {
+        throw signal.reason;
+      }
+      if (bufferedEvents.length > 0) {
+        return { done: false, value: bufferedEvents.shift() };
+      }
+      return new Promise((resolve, reject) => {
+        pullResolvers.push([resolve, reject]);
+      });
+    }, async () => {
+      unsubscribe();
+      signal?.removeEventListener("abort", abortListener);
+      pullResolvers.forEach((resolver) => resolver[0]({ done: true, value: undefined }));
+      pullResolvers.length = 0;
+      bufferedEvents.length = 0;
+    });
+  }
+}
+
+class SequentialIdGenerator {
+  index = BigInt(1);
+  generate() {
+    const id = this.index.toString(36);
+    this.index++;
+    return id;
+  }
+}
+function intercept(interceptors, options, main) {
+  const next = (options2, index) => {
+    const interceptor = interceptors[index];
+    if (!interceptor) {
+      return main(options2);
+    }
+    return interceptor({
+      ...options2,
+      next: (newOptions = options2) => next(newOptions, index + 1)
+    });
+  };
+  return next(options, 0);
+}
+function parseEmptyableJSON(text) {
+  if (!text) {
+    return;
+  }
+  return JSON.parse(text);
+}
+function stringifyJSON(value) {
+  return JSON.stringify(value);
+}
+function getConstructor(value) {
+  if (!isTypescriptObject(value)) {
+    return null;
+  }
+  return Object.getPrototypeOf(value)?.constructor;
+}
+function isObject(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || !proto || !proto.constructor;
+}
+function isTypescriptObject(value) {
+  return !!value && (typeof value === "object" || typeof value === "function");
+}
+function value(value2, ...args) {
+  if (typeof value2 === "function") {
+    return value2(...args);
+  }
+  return value2;
+}
+function preventNativeAwait(target) {
+  return new Proxy(target, {
+    get(target2, prop, receiver) {
+      const value2 = Reflect.get(target2, prop, receiver);
+      if (prop !== "then" || typeof value2 !== "function") {
+        return value2;
+      }
+      return new Proxy(value2, {
+        apply(targetFn, thisArg, args) {
+          if (args.length !== 2 || args.some((arg) => !isNativeFunction(arg))) {
+            return Reflect.apply(targetFn, thisArg, args);
+          }
+          let shouldOmit = true;
+          args[0].call(thisArg, preventNativeAwait(new Proxy(target2, {
+            get: (target3, prop2, receiver2) => {
+              if (shouldOmit && prop2 === "then") {
+                shouldOmit = false;
+                return;
+              }
+              return Reflect.get(target3, prop2, receiver2);
+            }
+          })));
+        }
+      });
+    }
+  });
+}
+var NATIVE_FUNCTION_REGEX = /^\s*function\s*\(\)\s*\{\s*\[native code\]\s*\}\s*$/;
+function isNativeFunction(fn) {
+  return typeof fn === "function" && NATIVE_FUNCTION_REGEX.test(fn.toString());
+}
+function tryDecodeURIComponent(value2) {
+  try {
+    return decodeURIComponent(value2);
+  } catch {
+    return value2;
+  }
+}
+// ../../node_modules/.bun/@orpc+client@1.13.5/node_modules/@orpc/client/dist/shared/client.BF1R3smX.mjs
+var ORPC_CLIENT_PACKAGE_NAME = "@orpc/client";
+var ORPC_CLIENT_PACKAGE_VERSION = "1.13.5";
+var COMMON_ORPC_ERROR_DEFS = {
+  BAD_REQUEST: {
+    status: 400,
+    message: "Bad Request"
+  },
+  UNAUTHORIZED: {
+    status: 401,
+    message: "Unauthorized"
+  },
+  FORBIDDEN: {
+    status: 403,
+    message: "Forbidden"
+  },
+  NOT_FOUND: {
+    status: 404,
+    message: "Not Found"
+  },
+  METHOD_NOT_SUPPORTED: {
+    status: 405,
+    message: "Method Not Supported"
+  },
+  NOT_ACCEPTABLE: {
+    status: 406,
+    message: "Not Acceptable"
+  },
+  TIMEOUT: {
+    status: 408,
+    message: "Request Timeout"
+  },
+  CONFLICT: {
+    status: 409,
+    message: "Conflict"
+  },
+  PRECONDITION_FAILED: {
+    status: 412,
+    message: "Precondition Failed"
+  },
+  PAYLOAD_TOO_LARGE: {
+    status: 413,
+    message: "Payload Too Large"
+  },
+  UNSUPPORTED_MEDIA_TYPE: {
+    status: 415,
+    message: "Unsupported Media Type"
+  },
+  UNPROCESSABLE_CONTENT: {
+    status: 422,
+    message: "Unprocessable Content"
+  },
+  TOO_MANY_REQUESTS: {
+    status: 429,
+    message: "Too Many Requests"
+  },
+  CLIENT_CLOSED_REQUEST: {
+    status: 499,
+    message: "Client Closed Request"
+  },
+  INTERNAL_SERVER_ERROR: {
+    status: 500,
+    message: "Internal Server Error"
+  },
+  NOT_IMPLEMENTED: {
+    status: 501,
+    message: "Not Implemented"
+  },
+  BAD_GATEWAY: {
+    status: 502,
+    message: "Bad Gateway"
+  },
+  SERVICE_UNAVAILABLE: {
+    status: 503,
+    message: "Service Unavailable"
+  },
+  GATEWAY_TIMEOUT: {
+    status: 504,
+    message: "Gateway Timeout"
+  }
+};
+function fallbackORPCErrorStatus(code, status) {
+  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
+}
+function fallbackORPCErrorMessage(code, message) {
+  return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
+}
+var GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL = Symbol.for(`__${ORPC_CLIENT_PACKAGE_NAME}@${ORPC_CLIENT_PACKAGE_VERSION}/error/ORPC_ERROR_CONSTRUCTORS__`);
+globalThis[GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL] ??= /* @__PURE__ */ new WeakSet;
+var globalORPCErrorConstructors = globalThis[GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL];
+
+class ORPCError extends Error {
+  defined;
+  code;
+  status;
+  data;
+  constructor(code, ...rest) {
+    const options = resolveMaybeOptionalOptions(rest);
+    if (options.status !== undefined && !isORPCErrorStatus(options.status)) {
+      throw new Error("[ORPCError] Invalid error status code.");
+    }
+    const message = fallbackORPCErrorMessage(code, options.message);
+    super(message, options);
+    this.code = code;
+    this.status = fallbackORPCErrorStatus(code, options.status);
+    this.defined = options.defined ?? false;
+    this.data = options.data;
+  }
+  toJSON() {
+    return {
+      defined: this.defined,
+      code: this.code,
+      status: this.status,
+      message: this.message,
+      data: this.data
+    };
+  }
+  static [Symbol.hasInstance](instance) {
+    if (globalORPCErrorConstructors.has(this)) {
+      const constructor = getConstructor(instance);
+      if (constructor && globalORPCErrorConstructors.has(constructor)) {
+        return true;
+      }
+    }
+    return super[Symbol.hasInstance](instance);
+  }
+}
+globalORPCErrorConstructors.add(ORPCError);
+function toORPCError(error) {
+  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", {
+    message: "Internal server error",
+    cause: error
+  });
+}
+function isORPCErrorStatus(status) {
+  return status < 200 || status >= 400;
+}
+function isORPCErrorJson(json) {
+  if (!isObject(json)) {
+    return false;
+  }
+  const validKeys = ["defined", "code", "status", "message", "data"];
+  if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+    return false;
+  }
+  return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && isORPCErrorStatus(json.status) && "message" in json && typeof json.message === "string";
+}
+function createORPCErrorFromJson(json, options = {}) {
+  return new ORPCError(json.code, {
+    ...options,
+    ...json
+  });
+}
+// ../../node_modules/.bun/@orpc+standard-server@1.13.5/node_modules/@orpc/standard-server/dist/index.mjs
+class EventEncoderError extends TypeError {
+}
+
+class EventDecoderError extends TypeError {
+}
+
+class ErrorEvent extends Error {
+  data;
+  constructor(options) {
+    super(options?.message ?? "An error event was received", options);
+    this.data = options?.data;
+  }
+}
+function decodeEventMessage(encoded) {
+  const lines = encoded.replace(/\n+$/, "").split(/\n/);
+  const message = {
+    data: undefined,
+    event: undefined,
+    id: undefined,
+    retry: undefined,
+    comments: []
+  };
+  for (const line of lines) {
+    const index = line.indexOf(":");
+    const key = index === -1 ? line : line.slice(0, index);
+    const value2 = index === -1 ? "" : line.slice(index + 1).replace(/^\s/, "");
+    if (index === 0) {
+      message.comments.push(value2);
+    } else if (key === "data") {
+      message.data ??= "";
+      message.data += `${value2}
+`;
+    } else if (key === "event") {
+      message.event = value2;
+    } else if (key === "id") {
+      message.id = value2;
+    } else if (key === "retry") {
+      const maybeInteger = Number.parseInt(value2);
+      if (Number.isInteger(maybeInteger) && maybeInteger >= 0 && maybeInteger.toString() === value2) {
+        message.retry = maybeInteger;
+      }
+    }
+  }
+  message.data = message.data?.replace(/\n$/, "");
+  return message;
+}
+
+class EventDecoder {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  incomplete = "";
+  feed(chunk) {
+    this.incomplete += chunk;
+    const lastCompleteIndex = this.incomplete.lastIndexOf(`
+
+`);
+    if (lastCompleteIndex === -1) {
+      return;
+    }
+    const completes = this.incomplete.slice(0, lastCompleteIndex).split(/\n\n/);
+    this.incomplete = this.incomplete.slice(lastCompleteIndex + 2);
+    for (const encoded of completes) {
+      const message = decodeEventMessage(`${encoded}
+
+`);
+      if (this.options.onEvent) {
+        this.options.onEvent(message);
+      }
+    }
+  }
+  end() {
+    if (this.incomplete) {
+      throw new EventDecoderError("Event Iterator ended before complete");
+    }
+  }
+}
+
+class EventDecoderStream extends TransformStream {
+  constructor() {
+    let decoder;
+    super({
+      start(controller) {
+        decoder = new EventDecoder({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          }
+        });
+      },
+      transform(chunk) {
+        decoder.feed(chunk);
+      },
+      flush() {
+        decoder.end();
+      }
+    });
+  }
+}
+function assertEventId(id) {
+  if (id.includes(`
+`)) {
+    throw new EventEncoderError("Event's id must not contain a newline character");
+  }
+}
+function assertEventName(event) {
+  if (event.includes(`
+`)) {
+    throw new EventEncoderError("Event's event must not contain a newline character");
+  }
+}
+function assertEventRetry(retry) {
+  if (!Number.isInteger(retry) || retry < 0) {
+    throw new EventEncoderError("Event's retry must be a integer and >= 0");
+  }
+}
+function assertEventComment(comment) {
+  if (comment.includes(`
+`)) {
+    throw new EventEncoderError("Event's comment must not contain a newline character");
+  }
+}
+function encodeEventData(data) {
+  const lines = data?.split(/\n/) ?? [];
+  let output = "";
+  for (const line of lines) {
+    output += `data: ${line}
+`;
+  }
+  return output;
+}
+function encodeEventComments(comments) {
+  let output = "";
+  for (const comment of comments ?? []) {
+    assertEventComment(comment);
+    output += `: ${comment}
+`;
+  }
+  return output;
+}
+function encodeEventMessage(message) {
+  let output = "";
+  output += encodeEventComments(message.comments);
+  if (message.event !== undefined) {
+    assertEventName(message.event);
+    output += `event: ${message.event}
+`;
+  }
+  if (message.retry !== undefined) {
+    assertEventRetry(message.retry);
+    output += `retry: ${message.retry}
+`;
+  }
+  if (message.id !== undefined) {
+    assertEventId(message.id);
+    output += `id: ${message.id}
+`;
+  }
+  output += encodeEventData(message.data);
+  output += `
+`;
+  return output;
+}
+var EVENT_SOURCE_META_SYMBOL = Symbol("ORPC_EVENT_SOURCE_META");
+function withEventMeta(container, meta) {
+  if (meta.id === undefined && meta.retry === undefined && !meta.comments?.length) {
+    return container;
+  }
+  if (meta.id !== undefined) {
+    assertEventId(meta.id);
+  }
+  if (meta.retry !== undefined) {
+    assertEventRetry(meta.retry);
+  }
+  if (meta.comments !== undefined) {
+    for (const comment of meta.comments) {
+      assertEventComment(comment);
+    }
+  }
+  return new Proxy(container, {
+    get(target, prop, receiver) {
+      if (prop === EVENT_SOURCE_META_SYMBOL) {
+        return meta;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function getEventMeta(container) {
+  return isTypescriptObject(container) ? Reflect.get(container, EVENT_SOURCE_META_SYMBOL) : undefined;
+}
+function generateContentDisposition(filename) {
+  const escapedFileName = filename.replace(/"/g, "\\\"");
+  const encodedFilenameStar = encodeURIComponent(filename).replace(/['()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`).replace(/%(7C|60|5E)/g, (str, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+  return `inline; filename="${escapedFileName}"; filename*=utf-8''${encodedFilenameStar}`;
+}
+function getFilenameFromContentDisposition(contentDisposition) {
+  const encodedFilenameStarMatch = contentDisposition.match(/filename\*=(UTF-8'')?([^;]*)/i);
+  if (encodedFilenameStarMatch && typeof encodedFilenameStarMatch[2] === "string") {
+    return tryDecodeURIComponent(encodedFilenameStarMatch[2]);
+  }
+  const encodedFilenameMatch = contentDisposition.match(/filename="((?:\\"|[^"])*)"/i);
+  if (encodedFilenameMatch && typeof encodedFilenameMatch[1] === "string") {
+    return encodedFilenameMatch[1].replace(/\\"/g, '"');
+  }
+}
+function mergeStandardHeaders(a, b) {
+  const merged = { ...a };
+  for (const key in b) {
+    if (Array.isArray(b[key])) {
+      merged[key] = [...toArray(merged[key]), ...b[key]];
+    } else if (b[key] !== undefined) {
+      if (Array.isArray(merged[key])) {
+        merged[key] = [...merged[key], b[key]];
+      } else if (merged[key] !== undefined) {
+        merged[key] = [merged[key], b[key]];
+      } else {
+        merged[key] = b[key];
+      }
+    }
+  }
+  return merged;
+}
+
+// ../../node_modules/.bun/@orpc+client@1.13.5/node_modules/@orpc/client/dist/shared/client.BLtwTQUg.mjs
+function mapEventIterator(iterator, maps) {
+  const mapError = async (error) => {
+    let mappedError = await maps.error(error);
+    if (mappedError !== error) {
+      const meta = getEventMeta(error);
+      if (meta && isTypescriptObject(mappedError)) {
+        mappedError = withEventMeta(mappedError, meta);
+      }
+    }
+    return mappedError;
+  };
+  return new AsyncIteratorClass(async () => {
+    const { done, value: value2 } = await (async () => {
+      try {
+        return await iterator.next();
+      } catch (error) {
+        throw await mapError(error);
+      }
+    })();
+    let mappedValue = await maps.value(value2, done);
+    if (mappedValue !== value2) {
+      const meta = getEventMeta(value2);
+      if (meta && isTypescriptObject(mappedValue)) {
+        mappedValue = withEventMeta(mappedValue, meta);
+      }
+    }
+    return { done, value: mappedValue };
+  }, async () => {
+    try {
+      await iterator.return?.();
+    } catch (error) {
+      throw await mapError(error);
+    }
+  });
+}
+// ../../node_modules/.bun/@orpc+client@1.13.5/node_modules/@orpc/client/dist/index.mjs
+function resolveFriendlyClientOptions(options) {
+  return {
+    ...options,
+    context: options.context ?? {}
+  };
+}
+function createORPCClient(link, options = {}) {
+  const path = options.path ?? [];
+  const procedureClient = async (...[input, options2 = {}]) => {
+    return await link.call(path, input, resolveFriendlyClientOptions(options2));
+  };
+  const recursive = new Proxy(procedureClient, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      return createORPCClient(link, {
+        ...options,
+        path: [...path, key]
+      });
+    }
+  });
+  return preventNativeAwait(recursive);
+}
+
+// ../../node_modules/.bun/@orpc+standard-server-fetch@1.13.5/node_modules/@orpc/standard-server-fetch/dist/index.mjs
+function toEventIterator(stream, options = {}) {
+  const eventStream = stream?.pipeThrough(new TextDecoderStream).pipeThrough(new EventDecoderStream);
+  const reader = eventStream?.getReader();
+  let span;
+  let isCancelled = false;
+  return new AsyncIteratorClass(async () => {
+    span ??= startSpan("consume_event_iterator_stream");
+    try {
+      while (true) {
+        if (reader === undefined) {
+          return { done: true, value: undefined };
+        }
+        const { done, value: value2 } = await runInSpanContext(span, () => reader.read());
+        if (done) {
+          if (isCancelled) {
+            throw new AbortError("Stream was cancelled");
+          }
+          return { done: true, value: undefined };
+        }
+        switch (value2.event) {
+          case "message": {
+            let message = parseEmptyableJSON(value2.data);
+            if (isTypescriptObject(message)) {
+              message = withEventMeta(message, value2);
+            }
+            span?.addEvent("message");
+            return { done: false, value: message };
+          }
+          case "error": {
+            let error = new ErrorEvent({
+              data: parseEmptyableJSON(value2.data)
+            });
+            error = withEventMeta(error, value2);
+            span?.addEvent("error");
+            throw error;
+          }
+          case "done": {
+            let done2 = parseEmptyableJSON(value2.data);
+            if (isTypescriptObject(done2)) {
+              done2 = withEventMeta(done2, value2);
+            }
+            span?.addEvent("done");
+            return { done: true, value: done2 };
+          }
+          default: {
+            span?.addEvent("maybe_keepalive");
+          }
+        }
+      }
+    } catch (e) {
+      if (!(e instanceof ErrorEvent)) {
+        setSpanError(span, e, options);
+      }
+      throw e;
+    }
+  }, async (reason) => {
+    try {
+      if (reason !== "next") {
+        isCancelled = true;
+        span?.addEvent("cancelled");
+      }
+      await runInSpanContext(span, () => reader?.cancel());
+    } catch (e) {
+      setSpanError(span, e, options);
+      throw e;
+    } finally {
+      span?.end();
+    }
+  });
+}
+function toEventStream(iterator, options = {}) {
+  const keepAliveEnabled = options.eventIteratorKeepAliveEnabled ?? true;
+  const keepAliveInterval = options.eventIteratorKeepAliveInterval ?? 5000;
+  const keepAliveComment = options.eventIteratorKeepAliveComment ?? "";
+  const initialCommentEnabled = options.eventIteratorInitialCommentEnabled ?? true;
+  const initialComment = options.eventIteratorInitialComment ?? "";
+  let cancelled = false;
+  let timeout;
+  let span;
+  const stream = new ReadableStream({
+    start(controller) {
+      span = startSpan("stream_event_iterator");
+      if (initialCommentEnabled) {
+        controller.enqueue(encodeEventMessage({
+          comments: [initialComment]
+        }));
+      }
+    },
+    async pull(controller) {
+      try {
+        if (keepAliveEnabled) {
+          timeout = setInterval(() => {
+            controller.enqueue(encodeEventMessage({
+              comments: [keepAliveComment]
+            }));
+            span?.addEvent("keepalive");
+          }, keepAliveInterval);
+        }
+        const value2 = await runInSpanContext(span, () => iterator.next());
+        clearInterval(timeout);
+        if (cancelled) {
+          return;
+        }
+        const meta = getEventMeta(value2.value);
+        if (!value2.done || value2.value !== undefined || meta !== undefined) {
+          const event = value2.done ? "done" : "message";
+          controller.enqueue(encodeEventMessage({
+            ...meta,
+            event,
+            data: stringifyJSON(value2.value)
+          }));
+          span?.addEvent(event);
+        }
+        if (value2.done) {
+          controller.close();
+          span?.end();
+        }
+      } catch (err) {
+        clearInterval(timeout);
+        if (cancelled) {
+          return;
+        }
+        if (err instanceof ErrorEvent) {
+          controller.enqueue(encodeEventMessage({
+            ...getEventMeta(err),
+            event: "error",
+            data: stringifyJSON(err.data)
+          }));
+          span?.addEvent("error");
+          controller.close();
+        } else {
+          setSpanError(span, err);
+          controller.error(err);
+        }
+        span?.end();
+      }
+    },
+    async cancel() {
+      try {
+        cancelled = true;
+        clearInterval(timeout);
+        span?.addEvent("cancelled");
+        await runInSpanContext(span, () => iterator.return?.());
+      } catch (e) {
+        setSpanError(span, e);
+        throw e;
+      } finally {
+        span?.end();
+      }
+    }
+  }).pipeThrough(new TextEncoderStream);
+  return stream;
+}
+function toStandardBody(re, options = {}) {
+  return runWithSpan({ name: "parse_standard_body", signal: options.signal }, async () => {
+    const contentDisposition = re.headers.get("content-disposition");
+    if (typeof contentDisposition === "string") {
+      const fileName = getFilenameFromContentDisposition(contentDisposition) ?? "blob";
+      const blob2 = await re.blob();
+      return new File([blob2], fileName, {
+        type: blob2.type
+      });
+    }
+    const contentType = re.headers.get("content-type");
+    if (!contentType || contentType.startsWith("application/json")) {
+      const text = await re.text();
+      return parseEmptyableJSON(text);
+    }
+    if (contentType.startsWith("multipart/form-data")) {
+      return await re.formData();
+    }
+    if (contentType.startsWith("application/x-www-form-urlencoded")) {
+      const text = await re.text();
+      return new URLSearchParams(text);
+    }
+    if (contentType.startsWith("text/event-stream")) {
+      return toEventIterator(re.body, options);
+    }
+    if (contentType.startsWith("text/plain")) {
+      return await re.text();
+    }
+    const blob = await re.blob();
+    return new File([blob], "blob", {
+      type: blob.type
+    });
+  });
+}
+function toFetchBody(body, headers, options = {}) {
+  const currentContentDisposition = headers.get("content-disposition");
+  headers.delete("content-type");
+  headers.delete("content-disposition");
+  if (body === undefined) {
+    return;
+  }
+  if (body instanceof Blob) {
+    headers.set("content-type", body.type);
+    headers.set("content-length", body.size.toString());
+    headers.set("content-disposition", currentContentDisposition ?? generateContentDisposition(body instanceof File ? body.name : "blob"));
+    return body;
+  }
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (body instanceof URLSearchParams) {
+    return body;
+  }
+  if (isAsyncIteratorObject(body)) {
+    headers.set("content-type", "text/event-stream");
+    return toEventStream(body, options);
+  }
+  headers.set("content-type", "application/json");
+  return stringifyJSON(body);
+}
+function toStandardHeaders(headers, standardHeaders = {}) {
+  headers.forEach((value2, key) => {
+    if (Array.isArray(standardHeaders[key])) {
+      standardHeaders[key].push(value2);
+    } else if (standardHeaders[key] !== undefined) {
+      standardHeaders[key] = [standardHeaders[key], value2];
+    } else {
+      standardHeaders[key] = value2;
+    }
+  });
+  return standardHeaders;
+}
+function toFetchHeaders(headers, fetchHeaders = new Headers) {
+  for (const [key, value2] of Object.entries(headers)) {
+    if (Array.isArray(value2)) {
+      for (const v of value2) {
+        fetchHeaders.append(key, v);
+      }
+    } else if (value2 !== undefined) {
+      fetchHeaders.append(key, value2);
+    }
+  }
+  return fetchHeaders;
+}
+function toFetchRequest(request, options = {}) {
+  const headers = toFetchHeaders(request.headers);
+  const body = toFetchBody(request.body, headers, options);
+  return new Request(request.url, {
+    signal: request.signal,
+    method: request.method,
+    headers,
+    body
+  });
+}
+function toStandardLazyResponse(response, options = {}) {
+  return {
+    body: once(() => toStandardBody(response, options)),
+    status: response.status,
+    get headers() {
+      const headers = toStandardHeaders(response.headers);
+      Object.defineProperty(this, "headers", { value: headers, writable: true });
+      return headers;
+    },
+    set headers(value2) {
+      Object.defineProperty(this, "headers", { value: value2, writable: true });
+    }
+  };
+}
+
+// ../../node_modules/.bun/@orpc+client@1.13.5/node_modules/@orpc/client/dist/shared/client.BcDRUyT-.mjs
+class CompositeStandardLinkPlugin {
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
+}
+
+class StandardLink {
+  constructor(codec, sender, options = {}) {
+    this.codec = codec;
+    this.sender = sender;
+    const plugin = new CompositeStandardLinkPlugin(options.plugins);
+    plugin.init(options);
+    this.interceptors = toArray(options.interceptors);
+    this.clientInterceptors = toArray(options.clientInterceptors);
+  }
+  interceptors;
+  clientInterceptors;
+  call(path, input, options) {
+    return runWithSpan({ name: `${ORPC_NAME}.${path.join("/")}`, signal: options.signal }, (span) => {
+      span?.setAttribute("rpc.system", ORPC_NAME);
+      span?.setAttribute("rpc.method", path.join("."));
+      if (isAsyncIteratorObject(input)) {
+        input = asyncIteratorWithSpan({ name: "consume_event_iterator_input", signal: options.signal }, input);
+      }
+      return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
+        const otelConfig = getGlobalOtelConfig();
+        let otelContext;
+        const currentSpan = otelConfig?.trace.getActiveSpan() ?? span;
+        if (currentSpan && otelConfig) {
+          otelContext = otelConfig?.trace.setSpan(otelConfig.context.active(), currentSpan);
+        }
+        const request = await runWithSpan({ name: "encode_request", context: otelContext }, () => this.codec.encode(path2, input2, options2));
+        const response = await intercept(this.clientInterceptors, { ...options2, input: input2, path: path2, request }, ({ input: input3, path: path3, request: request2, ...options3 }) => {
+          return runWithSpan({ name: "send_request", signal: options3.signal, context: otelContext }, () => this.sender.call(request2, options3, path3, input3));
+        });
+        const output = await runWithSpan({ name: "decode_response", context: otelContext }, () => this.codec.decode(response, options2, path2, input2));
+        if (isAsyncIteratorObject(output)) {
+          return asyncIteratorWithSpan({ name: "consume_event_iterator_output", signal: options2.signal }, output);
+        }
+        return output;
+      });
+    });
+  }
+}
+var STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES = {
+  BIGINT: 0,
+  DATE: 1,
+  NAN: 2,
+  UNDEFINED: 3,
+  URL: 4,
+  REGEXP: 5,
+  SET: 6,
+  MAP: 7
+};
+
+class StandardRPCJsonSerializer {
+  customSerializers;
+  constructor(options = {}) {
+    this.customSerializers = options.customJsonSerializers ?? [];
+    if (this.customSerializers.length !== new Set(this.customSerializers.map((custom) => custom.type)).size) {
+      throw new Error("Custom serializer type must be unique.");
+    }
+  }
+  serialize(data, segments = [], meta = [], maps = [], blobs = []) {
+    for (const custom of this.customSerializers) {
+      if (custom.condition(data)) {
+        const result = this.serialize(custom.serialize(data), segments, meta, maps, blobs);
+        meta.push([custom.type, ...segments]);
+        return result;
+      }
+    }
+    if (data instanceof Blob) {
+      maps.push(segments);
+      blobs.push(data);
+      return [data, meta, maps, blobs];
+    }
+    if (typeof data === "bigint") {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT, ...segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof Date) {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE, ...segments]);
+      if (Number.isNaN(data.getTime())) {
+        return [null, meta, maps, blobs];
+      }
+      return [data.toISOString(), meta, maps, blobs];
+    }
+    if (Number.isNaN(data)) {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN, ...segments]);
+      return [null, meta, maps, blobs];
+    }
+    if (data instanceof URL) {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL, ...segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof RegExp) {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP, ...segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof Set) {
+      const result = this.serialize(Array.from(data), segments, meta, maps, blobs);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET, ...segments]);
+      return result;
+    }
+    if (data instanceof Map) {
+      const result = this.serialize(Array.from(data.entries()), segments, meta, maps, blobs);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP, ...segments]);
+      return result;
+    }
+    if (Array.isArray(data)) {
+      const json = data.map((v, i) => {
+        if (v === undefined) {
+          meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED, ...segments, i]);
+          return v;
+        }
+        return this.serialize(v, [...segments, i], meta, maps, blobs)[0];
+      });
+      return [json, meta, maps, blobs];
+    }
+    if (isObject(data)) {
+      const json = {};
+      for (const k in data) {
+        if (k === "toJSON" && typeof data[k] === "function") {
+          continue;
+        }
+        json[k] = this.serialize(data[k], [...segments, k], meta, maps, blobs)[0];
+      }
+      return [json, meta, maps, blobs];
+    }
+    return [data, meta, maps, blobs];
+  }
+  deserialize(json, meta, maps, getBlob) {
+    const ref = { data: json };
+    if (maps && getBlob) {
+      maps.forEach((segments, i) => {
+        let currentRef = ref;
+        let preSegment = "data";
+        segments.forEach((segment) => {
+          currentRef = currentRef[preSegment];
+          preSegment = segment;
+        });
+        currentRef[preSegment] = getBlob(i);
+      });
+    }
+    for (const item of meta) {
+      const type = item[0];
+      let currentRef = ref;
+      let preSegment = "data";
+      for (let i = 1;i < item.length; i++) {
+        currentRef = currentRef[preSegment];
+        preSegment = item[i];
+      }
+      for (const custom of this.customSerializers) {
+        if (custom.type === type) {
+          currentRef[preSegment] = custom.deserialize(currentRef[preSegment]);
+          break;
+        }
+      }
+      switch (type) {
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT:
+          currentRef[preSegment] = BigInt(currentRef[preSegment]);
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE:
+          currentRef[preSegment] = new Date(currentRef[preSegment] ?? "Invalid Date");
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN:
+          currentRef[preSegment] = Number.NaN;
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED:
+          currentRef[preSegment] = undefined;
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL:
+          currentRef[preSegment] = new URL(currentRef[preSegment]);
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP: {
+          const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
+          currentRef[preSegment] = new RegExp(pattern, flags);
+          break;
+        }
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET:
+          currentRef[preSegment] = new Set(currentRef[preSegment]);
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP:
+          currentRef[preSegment] = new Map(currentRef[preSegment]);
+          break;
+      }
+    }
+    return ref.data;
+  }
+}
+function toHttpPath(path) {
+  return `/${path.map(encodeURIComponent).join("/")}`;
+}
+function toStandardHeaders2(headers) {
+  if (typeof headers.forEach === "function") {
+    return toStandardHeaders(headers);
+  }
+  return headers;
+}
+function getMalformedResponseErrorCode(status) {
+  return Object.entries(COMMON_ORPC_ERROR_DEFS).find(([, def]) => def.status === status)?.[0] ?? "MALFORMED_ORPC_ERROR_RESPONSE";
+}
+
+class StandardRPCLinkCodec {
+  constructor(serializer, options) {
+    this.serializer = serializer;
+    this.baseUrl = options.url;
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.fallbackMethod = options.fallbackMethod ?? "POST";
+    this.expectedMethod = options.method ?? this.fallbackMethod;
+    this.headers = options.headers ?? {};
+  }
+  baseUrl;
+  maxUrlLength;
+  fallbackMethod;
+  expectedMethod;
+  headers;
+  async encode(path, input, options) {
+    let headers = toStandardHeaders2(await value(this.headers, options, path, input));
+    if (options.lastEventId !== undefined) {
+      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
+    }
+    const expectedMethod = await value(this.expectedMethod, options, path, input);
+    const baseUrl = await value(this.baseUrl, options, path, input);
+    const url = new URL(baseUrl);
+    url.pathname = `${url.pathname.replace(/\/$/, "")}${toHttpPath(path)}`;
+    const serialized = this.serializer.serialize(input);
+    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
+      const maxUrlLength = await value(this.maxUrlLength, options, path, input);
+      const getUrl = new URL(url);
+      getUrl.searchParams.append("data", stringifyJSON(serialized));
+      if (getUrl.toString().length <= maxUrlLength) {
+        return {
+          body: undefined,
+          method: expectedMethod,
+          headers,
+          url: getUrl,
+          signal: options.signal
+        };
+      }
+    }
+    return {
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
+      headers,
+      body: serialized,
+      signal: options.signal
+    };
+  }
+  async decode(response) {
+    const isOk = !isORPCErrorStatus(response.status);
+    const deserialized = await (async () => {
+      let isBodyOk = false;
+      try {
+        const body = await response.body();
+        isBodyOk = true;
+        return this.serializer.deserialize(body);
+      } catch (error) {
+        if (!isBodyOk) {
+          throw new Error("Cannot parse response body, please check the response body and content-type.", {
+            cause: error
+          });
+        }
+        throw new Error("Invalid RPC response format.", {
+          cause: error
+        });
+      }
+    })();
+    if (!isOk) {
+      if (isORPCErrorJson(deserialized)) {
+        throw createORPCErrorFromJson(deserialized);
+      }
+      throw new ORPCError(getMalformedResponseErrorCode(response.status), {
+        status: response.status,
+        data: { ...response, body: deserialized }
+      });
+    }
+    return deserialized;
+  }
+}
+
+class StandardRPCSerializer {
+  constructor(jsonSerializer) {
+    this.jsonSerializer = jsonSerializer;
+  }
+  serialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value2) => this.#serialize(value2, false),
+        error: async (e) => {
+          return new ErrorEvent({
+            data: this.#serialize(toORPCError(e).toJSON(), false),
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#serialize(data, true);
+  }
+  #serialize(data, enableFormData) {
+    const [json, meta_, maps, blobs] = this.jsonSerializer.serialize(data);
+    const meta = meta_.length === 0 ? undefined : meta_;
+    if (!enableFormData || blobs.length === 0) {
+      return {
+        json,
+        meta
+      };
+    }
+    const form = new FormData;
+    form.set("data", stringifyJSON({ json, meta, maps }));
+    blobs.forEach((blob, i) => {
+      form.set(i.toString(), blob);
+    });
+    return form;
+  }
+  deserialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value2) => this.#deserialize(value2),
+        error: async (e) => {
+          if (!(e instanceof ErrorEvent)) {
+            return e;
+          }
+          const deserialized = this.#deserialize(e.data);
+          if (isORPCErrorJson(deserialized)) {
+            return createORPCErrorFromJson(deserialized, { cause: e });
+          }
+          return new ErrorEvent({
+            data: deserialized,
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#deserialize(data);
+  }
+  #deserialize(data) {
+    if (data === undefined) {
+      return;
+    }
+    if (!(data instanceof FormData)) {
+      return this.jsonSerializer.deserialize(data.json, data.meta ?? []);
+    }
+    const serialized = JSON.parse(data.get("data"));
+    return this.jsonSerializer.deserialize(serialized.json, serialized.meta ?? [], serialized.maps, (i) => data.get(i.toString()));
+  }
+}
+
+class StandardRPCLink extends StandardLink {
+  constructor(linkClient, options) {
+    const jsonSerializer = new StandardRPCJsonSerializer(options);
+    const serializer = new StandardRPCSerializer(jsonSerializer);
+    const linkCodec = new StandardRPCLinkCodec(serializer, options);
+    super(linkCodec, linkClient, options);
+  }
+}
+
+// ../../node_modules/.bun/@orpc+client@1.13.5/node_modules/@orpc/client/dist/adapters/fetch/index.mjs
+class CompositeLinkFetchPlugin extends CompositeStandardLinkPlugin {
+  initRuntimeAdapter(options) {
+    for (const plugin of this.plugins) {
+      plugin.initRuntimeAdapter?.(options);
+    }
+  }
+}
+
+class LinkFetchClient {
+  fetch;
+  toFetchRequestOptions;
+  adapterInterceptors;
+  constructor(options) {
+    const plugin = new CompositeLinkFetchPlugin(options.plugins);
+    plugin.initRuntimeAdapter(options);
+    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.toFetchRequestOptions = options;
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
+  }
+  async call(standardRequest, options, path, input) {
+    const request = toFetchRequest(standardRequest, this.toFetchRequestOptions);
+    const fetchResponse = await intercept(this.adapterInterceptors, { ...options, request, path, input, init: { redirect: "manual" } }, ({ request: request2, path: path2, input: input2, init, ...options2 }) => this.fetch(request2, init, options2, path2, input2));
+    const lazyResponse = toStandardLazyResponse(fetchResponse, { signal: request.signal });
+    return lazyResponse;
+  }
+}
+
+class RPCLink extends StandardRPCLink {
+  constructor(options) {
+    const linkClient = new LinkFetchClient(options);
+    super(linkClient, options);
+  }
+}
+
+// src/lib/uploader.ts
+async function uploadSession(request, config) {
+  const link = new RPCLink({
+    url: config.endpoint,
+    headers: {
+      Authorization: `Bearer ${config.token}`
+    }
+  });
+  const client = createORPCClient(link);
+  try {
+    await client.ingestSession(request);
+    return { success: true, status: 200 };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+
+// src/commands/upload.ts
+async function runUpload(flags, session) {
+  const write = (msg) => {
+    process.stdout.write(`${msg}
+`);
+  };
+  const writeError = (msg) => {
+    process.stderr.write(`${msg}
+`);
+  };
+  const credentials = loadCredentials();
+  if (!credentials && !flags.dryRun) {
+    writeError("Error: Not authenticated. Run `rudel login` first.");
+    process.exitCode = 1;
+    return;
+  }
+  write(`Resolving session: ${session}`);
+  let sessionInfo;
+  try {
+    sessionInfo = await resolveSession(session);
+  } catch (error) {
+    writeError(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+    return;
+  }
+  write(`Found session at: ${sessionInfo.transcriptPath}`);
+  write("Reading transcript...");
+  let content;
+  try {
+    content = await readTranscript(sessionInfo.transcriptPath);
+  } catch (error) {
+    writeError(`Error reading transcript: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+    return;
+  }
+  write(`Transcript: ${content.length} bytes`);
+  const agentIds = extractAgentIds(content);
+  let subagents = [];
+  if (agentIds.length > 0) {
+    write(`Found ${agentIds.length} subagent(s): ${agentIds.join(", ")}`);
+    subagents = await readSubagentFiles(sessionInfo.sessionDir, agentIds, sessionInfo.sessionId);
+    write(`Read ${subagents.length} subagent file(s): ${subagents.reduce((sum, s) => sum + s.content.length, 0)} bytes total`);
+  }
+  const gitInfo = await getGitInfo(sessionInfo.projectPath);
+  if (gitInfo.repository)
+    write(`Repository: ${gitInfo.repository}`);
+  if (gitInfo.branch)
+    write(`Branch: ${gitInfo.branch}`);
+  let tag = flags.tag;
+  if (!tag && flags.classify) {
+    write("Classifying session...");
+    tag = await classifySession(content) ?? undefined;
+    if (tag)
+      write(`Classified as: ${tag}`);
+  }
+  const request = {
+    sessionId: sessionInfo.sessionId,
+    projectPath: sessionInfo.projectPath,
+    repository: gitInfo.repository,
+    gitBranch: gitInfo.branch,
+    gitSha: gitInfo.sha,
+    tag,
+    content,
+    subagents: subagents.length > 0 ? subagents : undefined
+  };
+  if (flags.dryRun) {
+    const preview = {
+      ...request,
+      content: `[${request.content.length} bytes]`,
+      subagents: request.subagents?.map((s) => ({
+        ...s,
+        content: `[${s.content.length} bytes]`
+      }))
+    };
+    write("Dry run - would upload:");
+    write(JSON.stringify(preview, null, 2));
+    return;
+  }
+  write("Uploading...");
+  const result = await uploadSession(request, {
+    endpoint: flags.endpoint,
+    token: credentials.token
+  });
+  if (result.success) {
+    write("Upload successful!");
+  } else {
+    writeError(`Upload failed: ${result.error}`);
+    process.exitCode = 1;
+  }
+}
+var uploadCommand = buildCommand({
+  loader: async () => ({ default: runUpload }),
+  parameters: {
+    positional: {
+      kind: "tuple",
+      parameters: [
+        {
+          brief: "Session ID or path to a session .jsonl file",
+          parse: String,
+          placeholder: "session"
+        }
+      ]
+    },
+    flags: {
+      tag: {
+        kind: "enum",
+        values: [...SESSION_TAGS],
+        brief: "Session tag/category",
+        optional: true
+      },
+      endpoint: {
+        kind: "parsed",
+        parse: String,
+        brief: "Override the upload endpoint URL",
+        default: DEFAULT_ENDPOINT
+      },
+      classify: {
+        kind: "boolean",
+        brief: "Auto-classify session tag using Claude CLI",
+        default: false
+      },
+      dryRun: {
+        kind: "boolean",
+        brief: "Preview what would be uploaded without sending",
+        default: false
+      }
+    },
+    aliases: {
+      t: "tag",
+      c: "classify",
+      n: "dryRun"
+    }
+  },
+  docs: {
+    brief: "Upload a Claude Code session transcript to the backend"
+  }
+});
+
+// src/commands/whoami.ts
+async function runWhoami() {
+  const write = (msg) => process.stdout.write(`${msg}
+`);
+  const writeError = (msg) => process.stderr.write(`${msg}
+`);
+  const credentials = loadCredentials();
+  if (!credentials) {
+    write("Not logged in. Run `rudel login` to authenticate.");
+    return;
+  }
+  const response = await fetch(`${credentials.apiBaseUrl}/rpc/me`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${credentials.token}`
+    },
+    body: JSON.stringify({})
+  });
+  if (!response.ok) {
+    writeError("Session expired or invalid. Run `rudel login` to re-authenticate.");
+    process.exitCode = 1;
+    return;
+  }
+  const body = await response.json();
+  write(`Logged in as ${body.json.name} (${body.json.email})`);
+}
+var whoamiCommand = buildCommand({
+  loader: async () => ({ default: runWhoami }),
+  parameters: {},
+  docs: {
+    brief: "Show the currently authenticated user"
+  }
+});
+
+// src/app.ts
+var routes = buildRouteMap({
+  routes: {
+    login: loginCommand,
+    logout: logoutCommand,
+    whoami: whoamiCommand,
+    upload: uploadCommand
+  },
+  docs: {
+    brief: "CLI tools for managing Claude Code sessions"
+  }
+});
+var app = buildApplication(routes, {
+  name: "rudel",
+  versionInfo: {
+    currentVersion: "0.1.1"
+  },
+  scanner: {
+    caseStyle: "allow-kebab-for-camel"
+  }
+});
+
+// src/bin/cli.ts
+await run(app, process.argv.slice(2), { process });