@wirecat/cli-memo 0.131.19 → 0.131.21

package/dist/bundle/{chunk-MXP4J6BJ.js → chunk-CDZZ2DZO.js}

@@ -1,5 +1,29 @@
 import { createRequire as __bundleRequire } from "node:module";
 const require = __bundleRequire(import.meta.url);
+import {
+  array,
+  dottedId,
+  duplicates,
+  errorObjectOf,
+  getDotPath,
+  isoTime,
+  optional,
+  parseRegistry,
+  picklist,
+  pipe,
+  record,
+  regex,
+  safeParse,
+  strictObject,
+  string,
+  text,
+  unknown
+} from "./chunk-EG2OMKWH.js";
+import {
+  CliError,
+  isCliError,
+  visibleControls
+} from "./chunk-CCHHEMPM.js";
 import {
   __commonJS,
   __name,
@@ -367,26 +391,26 @@ var require_utils = __commonJS({
       return ret;
     }
     __name(mergeOptions, "mergeOptions");
-    function wordWrap(maxLength2, input) {
+    function wordWrap(maxLength, input) {
       let lines = [];
       let split = input.split(/(\s+)/g);
       let line = [];
       let lineLength = 0;
       let whitespace;
       for (let i = 0; i < split.length; i += 2) {
-        let word2 = split[i];
-        let newLength = lineLength + strlen(word2);
+        let word = split[i];
+        let newLength = lineLength + strlen(word);
         if (lineLength > 0 && whitespace) {
           newLength += whitespace.length;
         }
-        if (newLength > maxLength2) {
+        if (newLength > maxLength) {
           if (lineLength !== 0) {
             lines.push(line.join(""));
           }
-          line = [word2];
-          lineLength = strlen(word2);
+          line = [word];
+          lineLength = strlen(word);
         } else {
-          line.push(whitespace || "", word2);
+          line.push(whitespace || "", word);
           lineLength = newLength;
         }
         whitespace = split[i + 1];
@@ -397,15 +421,15 @@ var require_utils = __commonJS({
       return lines;
     }
     __name(wordWrap, "wordWrap");
-    function textWrap(maxLength2, input) {
+    function textWrap(maxLength, input) {
       let lines = [];
       let line = "";
       function pushLine(str, ws) {
         if (line.length && ws) line += ws;
         line += str;
-        while (line.length > maxLength2) {
-          lines.push(line.slice(0, maxLength2));
-          line = line.slice(maxLength2);
+        while (line.length > maxLength) {
+          lines.push(line.slice(0, maxLength));
+          line = line.slice(maxLength);
         }
       }
       __name(pushLine, "pushLine");
@@ -417,12 +441,12 @@ var require_utils = __commonJS({
       return lines;
     }
     __name(textWrap, "textWrap");
-    function multiLineWordWrap(maxLength2, input, wrapOnWordBoundary = true) {
+    function multiLineWordWrap(maxLength, input, wrapOnWordBoundary = true) {
       let output = [];
       input = input.split("\n");
       const handler = wrapOnWordBoundary ? wordWrap : textWrap;
       for (let i = 0; i < input.length; i++) {
-        output.push.apply(output, handler(maxLength2, input[i]));
+        output.push.apply(output, handler(maxLength, input[i]));
       }
       return output;
     }
@@ -1872,2393 +1896,6 @@ var require_cli_table3 = __commonJS({
   }
 });
 
-// node_modules/.pnpm/@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/errors.js
-var errorCodes = [
-  "validation_error",
-  "configuration_error",
-  "authentication_error",
-  "permission_error",
-  "not_found",
-  "confirmation_required",
-  "rate_limited",
-  "timeout",
-  "network_error",
-  "provider_error",
-  "provider_unavailable",
-  "invalid_response",
-  "outcome_unknown",
-  "cancelled"
-];
-var BRAND = /* @__PURE__ */ Symbol.for("@wirecat/cli-base/CliError");
-var CliError = class extends Error {
-  static {
-    __name(this, "CliError");
-  }
-  code;
-  details;
-  constructor(code, message, details = {}) {
-    super(message);
-    this.name = "CliError";
-    this.code = code;
-    this.details = details;
-    Object.defineProperty(this, BRAND, { value: true });
-  }
-};
-var isCliError = /* @__PURE__ */ __name((value) => typeof value === "object" && value !== null && value[BRAND] === true, "isCliError");
-
-// node_modules/.pnpm/valibot@1.5.0_typescript@7.0.2/node_modules/valibot/dist/index.mjs
-var store$4;
-var DEFAULT_CONFIG = {
-  lang: void 0,
-  message: void 0,
-  abortEarly: void 0,
-  abortPipeEarly: void 0
-};
-// @__NO_SIDE_EFFECTS__
-function getGlobalConfig(config$1) {
-  if (!config$1 && !store$4) return DEFAULT_CONFIG;
-  return {
-    lang: config$1?.lang ?? store$4?.lang,
-    message: config$1?.message,
-    abortEarly: config$1?.abortEarly ?? store$4?.abortEarly,
-    abortPipeEarly: config$1?.abortPipeEarly ?? store$4?.abortPipeEarly
-  };
-}
-__name(getGlobalConfig, "getGlobalConfig");
-var store$3;
-// @__NO_SIDE_EFFECTS__
-function getGlobalMessage(lang) {
-  return store$3?.get(lang);
-}
-__name(getGlobalMessage, "getGlobalMessage");
-var store$2;
-// @__NO_SIDE_EFFECTS__
-function getSchemaMessage(lang) {
-  return store$2?.get(lang);
-}
-__name(getSchemaMessage, "getSchemaMessage");
-var store$1;
-// @__NO_SIDE_EFFECTS__
-function getSpecificMessage(reference2, lang) {
-  return store$1?.get(reference2)?.get(lang);
-}
-__name(getSpecificMessage, "getSpecificMessage");
-// @__NO_SIDE_EFFECTS__
-function _stringify(input) {
-  const type = typeof input;
-  if (type === "string") return `"${input}"`;
-  if (type === "number" || type === "bigint" || type === "boolean") return `${input}`;
-  if (type === "object" || type === "function") return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
-  return type;
-}
-__name(_stringify, "_stringify");
-function _addIssue(context, label, dataset, config$1, other) {
-  const input = other && "input" in other ? other.input : dataset.value;
-  const expected = other?.expected ?? context.expects ?? null;
-  const received = other?.received ?? /* @__PURE__ */ _stringify(input);
-  const issue = {
-    kind: context.kind,
-    type: context.type,
-    input,
-    expected,
-    received,
-    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
-    requirement: context.requirement,
-    path: other?.path,
-    issues: other?.issues,
-    lang: config$1.lang,
-    abortEarly: config$1.abortEarly,
-    abortPipeEarly: config$1.abortPipeEarly
-  };
-  const isSchema = context.kind === "schema";
-  const message$1 = other?.message ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config$1.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
-  if (message$1 !== void 0) issue.message = typeof message$1 === "function" ? message$1(issue) : message$1;
-  if (isSchema) dataset.typed = false;
-  if (dataset.issues) dataset.issues.push(issue);
-  else dataset.issues = [issue];
-}
-__name(_addIssue, "_addIssue");
-// @__NO_SIDE_EFFECTS__
-function _isSameValueZero(value1, value2) {
-  return value1 === value2 || Number.isNaN(value1) && Number.isNaN(value2);
-}
-__name(_isSameValueZero, "_isSameValueZero");
-// @__NO_SIDE_EFFECTS__
-function _isValidObjectKey(object$1, key) {
-  return Object.prototype.hasOwnProperty.call(object$1, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
-}
-__name(_isValidObjectKey, "_isValidObjectKey");
-// @__NO_SIDE_EFFECTS__
-function _joinExpects(values$1, separator) {
-  const list = [...new Set(values$1)];
-  if (list.length > 1) return `(${list.join(` ${separator} `)})`;
-  return list[0] ?? "never";
-}
-__name(_joinExpects, "_joinExpects");
-function _standardSchema(schema) {
-  schema["~standard"] = {
-    version: 1,
-    vendor: "valibot",
-    validate: /* @__PURE__ */ __name((value$1) => schema["~run"]({ value: value$1 }, /* @__PURE__ */ getGlobalConfig()), "validate")
-  };
-  return schema;
-}
-__name(_standardSchema, "_standardSchema");
-// @__NO_SIDE_EFFECTS__
-function getDotPath(issue) {
-  if (issue.path) {
-    let key = "";
-    for (const item of issue.path) if (typeof item.key === "string" || typeof item.key === "number") if (key) key += `.${item.key}`;
-    else key += item.key;
-    else return null;
-    return key;
-  }
-  return null;
-}
-__name(getDotPath, "getDotPath");
-var ValiError = class extends Error {
-  static {
-    __name(this, "ValiError");
-  }
-  /**
-  * Creates a Valibot error with useful information.
-  *
-  * @param issues The error issues.
-  */
-  constructor(issues) {
-    super(issues[0].message);
-    this.name = "ValiError";
-    this.issues = issues;
-  }
-};
-var EMOJI_REGEX = new RegExp("^(?:[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|(?![\\p{Emoji_Modifier_Base}\\u{1F1E6}-\\u{1F1FF}])\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|(?![\\p{Emoji_Modifier_Base}\\u{1F1E6}-\\u{1F1FF}])\\p{Emoji_Presentation}))*)+$", "u");
-var ISO_DATE_REGEX = /^\d{4}-(?:0[1-9]|1[0-2])-(?:[12]\d|0[1-9]|3[01])$/u;
-var ISO_TIMESTAMP_REGEX = /^\d{4}-(?:0[1-9]|1[0-2])-(?:[12]\d|0[1-9]|3[01])[T ](?:0\d|1\d|2[0-3])(?::[0-5]\d){2}(?:\.\d{1,9})?(?:Z| ?[+-](?:0\d|1\d|2[0-3])(?::?[0-5]\d)?)$/u;
-// @__NO_SIDE_EFFECTS__
-function check(requirement, message$1) {
-  return {
-    kind: "validation",
-    type: "check",
-    reference: check,
-    async: false,
-    expects: null,
-    requirement,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "input", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-__name(check, "check");
-// @__NO_SIDE_EFFECTS__
-function description(description_) {
-  return {
-    kind: "metadata",
-    type: "description",
-    reference: description,
-    description: description_
-  };
-}
-__name(description, "description");
-// @__NO_SIDE_EFFECTS__
-function endsWith(requirement, message$1) {
-  return {
-    kind: "validation",
-    type: "ends_with",
-    reference: endsWith,
-    async: false,
-    expects: `"${requirement}"`,
-    requirement,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !dataset.value.endsWith(this.requirement)) _addIssue(this, "end", dataset, config$1, { received: `"${dataset.value.slice(-this.requirement.length)}"` });
-      return dataset;
-    }
-  };
-}
-__name(endsWith, "endsWith");
-// @__NO_SIDE_EFFECTS__
-function finite(message$1) {
-  return {
-    kind: "validation",
-    type: "finite",
-    reference: finite,
-    async: false,
-    expects: null,
-    requirement: Number.isFinite,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "finite", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-__name(finite, "finite");
-// @__NO_SIDE_EFFECTS__
-function integer(message$1) {
-  return {
-    kind: "validation",
-    type: "integer",
-    reference: integer,
-    async: false,
-    expects: null,
-    requirement: Number.isInteger,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "integer", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-__name(integer, "integer");
-// @__NO_SIDE_EFFECTS__
-function isoDate(message$1) {
-  return {
-    kind: "validation",
-    type: "iso_date",
-    reference: isoDate,
-    async: false,
-    expects: null,
-    requirement: ISO_DATE_REGEX,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "date", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-__name(isoDate, "isoDate");
-// @__NO_SIDE_EFFECTS__
-function isoTimestamp(message$1) {
-  return {
-    kind: "validation",
-    type: "iso_timestamp",
-    reference: isoTimestamp,
-    async: false,
-    expects: null,
-    requirement: ISO_TIMESTAMP_REGEX,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "timestamp", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-__name(isoTimestamp, "isoTimestamp");
-// @__NO_SIDE_EFFECTS__
-function maxLength(requirement, message$1) {
-  return {
-    kind: "validation",
-    type: "max_length",
-    reference: maxLength,
-    async: false,
-    expects: `<=${requirement}`,
-    requirement,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && dataset.value.length > this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
-      return dataset;
-    }
-  };
-}
-__name(maxLength, "maxLength");
-// @__NO_SIDE_EFFECTS__
-function maxValue(requirement, message$1) {
-  return {
-    kind: "validation",
-    type: "max_value",
-    reference: maxValue,
-    async: false,
-    expects: `<=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
-    requirement,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !(dataset.value <= this.requirement)) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
-      return dataset;
-    }
-  };
-}
-__name(maxValue, "maxValue");
-// @__NO_SIDE_EFFECTS__
-function minLength(requirement, message$1) {
-  return {
-    kind: "validation",
-    type: "min_length",
-    reference: minLength,
-    async: false,
-    expects: `>=${requirement}`,
-    requirement,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && dataset.value.length < this.requirement) _addIssue(this, "length", dataset, config$1, { received: `${dataset.value.length}` });
-      return dataset;
-    }
-  };
-}
-__name(minLength, "minLength");
-// @__NO_SIDE_EFFECTS__
-function minValue(requirement, message$1) {
-  return {
-    kind: "validation",
-    type: "min_value",
-    reference: minValue,
-    async: false,
-    expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
-    requirement,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !(dataset.value >= this.requirement)) _addIssue(this, "value", dataset, config$1, { received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value) });
-      return dataset;
-    }
-  };
-}
-__name(minValue, "minValue");
-// @__NO_SIDE_EFFECTS__
-function nonEmpty(message$1) {
-  return {
-    kind: "validation",
-    type: "non_empty",
-    reference: nonEmpty,
-    async: false,
-    expects: "!0",
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && dataset.value.length === 0) _addIssue(this, "length", dataset, config$1, { received: "0" });
-      return dataset;
-    }
-  };
-}
-__name(nonEmpty, "nonEmpty");
-// @__NO_SIDE_EFFECTS__
-function regex(requirement, message$1) {
-  return {
-    kind: "validation",
-    type: "regex",
-    reference: regex,
-    async: false,
-    expects: `${requirement}`,
-    requirement,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !this.requirement.test(dataset.value)) _addIssue(this, "format", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-__name(regex, "regex");
-// @__NO_SIDE_EFFECTS__
-function safeInteger(message$1) {
-  return {
-    kind: "validation",
-    type: "safe_integer",
-    reference: safeInteger,
-    async: false,
-    expects: null,
-    requirement: Number.isSafeInteger,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.typed && !this.requirement(dataset.value)) _addIssue(this, "safe integer", dataset, config$1);
-      return dataset;
-    }
-  };
-}
-__name(safeInteger, "safeInteger");
-// @__NO_SIDE_EFFECTS__
-function transform(operation) {
-  return {
-    kind: "transformation",
-    type: "transform",
-    reference: transform,
-    async: false,
-    operation,
-    "~run"(dataset) {
-      dataset.value = this.operation(dataset.value);
-      return dataset;
-    }
-  };
-}
-__name(transform, "transform");
-// @__NO_SIDE_EFFECTS__
-function trim() {
-  return {
-    kind: "transformation",
-    type: "trim",
-    reference: trim,
-    async: false,
-    "~run"(dataset) {
-      dataset.value = dataset.value.trim();
-      return dataset;
-    }
-  };
-}
-__name(trim, "trim");
-var ABORT_EARLY_CONFIG = { abortEarly: true };
-// @__NO_SIDE_EFFECTS__
-function getFallback(schema, dataset, config$1) {
-  return typeof schema.fallback === "function" ? schema.fallback(dataset, config$1) : schema.fallback;
-}
-__name(getFallback, "getFallback");
-// @__NO_SIDE_EFFECTS__
-function forward(action, path) {
-  return {
-    ...action,
-    "~run"(dataset, config$1) {
-      const prevIssues = dataset.issues && [...dataset.issues];
-      dataset = action["~run"](dataset, config$1);
-      if (dataset.issues) {
-        for (const issue of dataset.issues) if (!prevIssues?.includes(issue)) {
-          let pathInput = dataset.value;
-          for (const key of path) {
-            const pathValue = pathInput[key];
-            const pathItem = {
-              type: "unknown",
-              origin: "value",
-              input: pathInput,
-              key,
-              value: pathValue
-            };
-            if (issue.path) issue.path.push(pathItem);
-            else issue.path = [pathItem];
-            if (!pathValue) break;
-            pathInput = pathValue;
-          }
-        }
-      }
-      return dataset;
-    }
-  };
-}
-__name(forward, "forward");
-// @__NO_SIDE_EFFECTS__
-function getDefault(schema, dataset, config$1) {
-  return typeof schema.default === "function" ? schema.default(dataset, config$1) : schema.default;
-}
-__name(getDefault, "getDefault");
-// @__NO_SIDE_EFFECTS__
-function array(item, message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "array",
-    reference: array,
-    expects: "Array",
-    async: false,
-    item,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      const input = dataset.value;
-      if (Array.isArray(input)) {
-        dataset.typed = true;
-        dataset.value = [];
-        for (let key = 0; key < input.length; key++) {
-          const value$1 = input[key];
-          const itemDataset = this.item["~run"]({ value: value$1 }, config$1);
-          if (itemDataset.issues) {
-            const pathItem = {
-              type: "array",
-              origin: "value",
-              input,
-              key,
-              value: value$1
-            };
-            for (const issue of itemDataset.issues) {
-              if (issue.path) issue.path.unshift(pathItem);
-              else issue.path = [pathItem];
-              dataset.issues?.push(issue);
-            }
-            if (!dataset.issues) dataset.issues = itemDataset.issues;
-            if (config$1.abortEarly) {
-              dataset.typed = false;
-              break;
-            }
-          }
-          if (!itemDataset.typed) dataset.typed = false;
-          dataset.value.push(itemDataset.value);
-        }
-      } else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(array, "array");
-// @__NO_SIDE_EFFECTS__
-function boolean(message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "boolean",
-    reference: boolean,
-    expects: "boolean",
-    async: false,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (typeof dataset.value === "boolean") dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(boolean, "boolean");
-// @__NO_SIDE_EFFECTS__
-function lazy(getter) {
-  return _standardSchema({
-    kind: "schema",
-    type: "lazy",
-    reference: lazy,
-    expects: "unknown",
-    async: false,
-    getter,
-    "~run"(dataset, config$1) {
-      return this.getter(dataset.value)["~run"](dataset, config$1);
-    }
-  });
-}
-__name(lazy, "lazy");
-// @__NO_SIDE_EFFECTS__
-function literal(literal_, message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "literal",
-    reference: literal,
-    expects: /* @__PURE__ */ _stringify(literal_),
-    async: false,
-    literal: literal_,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (/* @__PURE__ */ _isSameValueZero(dataset.value, this.literal)) dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(literal, "literal");
-// @__NO_SIDE_EFFECTS__
-function looseObject(entries$1, message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "loose_object",
-    reference: looseObject,
-    expects: "Object",
-    async: false,
-    entries: entries$1,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      const input = dataset.value;
-      if (input && typeof input === "object") {
-        dataset.typed = true;
-        dataset.value = {};
-        for (const key in this.entries) {
-          const valueSchema = this.entries[key];
-          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
-            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
-            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
-            if (valueDataset.issues) {
-              const pathItem = {
-                type: "object",
-                origin: "value",
-                input,
-                key,
-                value: value$1
-              };
-              for (const issue of valueDataset.issues) {
-                if (issue.path) issue.path.unshift(pathItem);
-                else issue.path = [pathItem];
-                dataset.issues?.push(issue);
-              }
-              if (!dataset.issues) dataset.issues = valueDataset.issues;
-              if (config$1.abortEarly) {
-                dataset.typed = false;
-                break;
-              }
-            }
-            if (!valueDataset.typed) dataset.typed = false;
-            dataset.value[key] = valueDataset.value;
-          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
-          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
-            _addIssue(this, "key", dataset, config$1, {
-              input: void 0,
-              expected: `"${key}"`,
-              path: [{
-                type: "object",
-                origin: "key",
-                input,
-                key,
-                value: input[key]
-              }]
-            });
-            if (config$1.abortEarly) break;
-          }
-        }
-        if (!dataset.issues || !config$1.abortEarly) {
-          for (const key in input) if (/* @__PURE__ */ _isValidObjectKey(input, key) && !Object.prototype.hasOwnProperty.call(this.entries, key)) dataset.value[key] = input[key];
-        }
-      } else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(looseObject, "looseObject");
-// @__NO_SIDE_EFFECTS__
-function null_(message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "null",
-    reference: null_,
-    expects: "null",
-    async: false,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (dataset.value === null) dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(null_, "null_");
-// @__NO_SIDE_EFFECTS__
-function nullable(wrapped, default_) {
-  return _standardSchema({
-    kind: "schema",
-    type: "nullable",
-    reference: nullable,
-    expects: `(${wrapped.expects} | null)`,
-    async: false,
-    wrapped,
-    default: default_,
-    "~run"(dataset, config$1) {
-      if (dataset.value === null) {
-        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
-        if (dataset.value === null) {
-          dataset.typed = true;
-          return dataset;
-        }
-      }
-      return this.wrapped["~run"](dataset, config$1);
-    }
-  });
-}
-__name(nullable, "nullable");
-// @__NO_SIDE_EFFECTS__
-function number(message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "number",
-    reference: number,
-    expects: "number",
-    async: false,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (typeof dataset.value === "number" && !isNaN(dataset.value)) dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(number, "number");
-// @__NO_SIDE_EFFECTS__
-function object(entries$1, message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "object",
-    reference: object,
-    expects: "Object",
-    async: false,
-    entries: entries$1,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      const input = dataset.value;
-      if (input && typeof input === "object") {
-        dataset.typed = true;
-        dataset.value = {};
-        for (const key in this.entries) {
-          const valueSchema = this.entries[key];
-          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
-            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
-            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
-            if (valueDataset.issues) {
-              const pathItem = {
-                type: "object",
-                origin: "value",
-                input,
-                key,
-                value: value$1
-              };
-              for (const issue of valueDataset.issues) {
-                if (issue.path) issue.path.unshift(pathItem);
-                else issue.path = [pathItem];
-                dataset.issues?.push(issue);
-              }
-              if (!dataset.issues) dataset.issues = valueDataset.issues;
-              if (config$1.abortEarly) {
-                dataset.typed = false;
-                break;
-              }
-            }
-            if (!valueDataset.typed) dataset.typed = false;
-            dataset.value[key] = valueDataset.value;
-          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
-          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
-            _addIssue(this, "key", dataset, config$1, {
-              input: void 0,
-              expected: `"${key}"`,
-              path: [{
-                type: "object",
-                origin: "key",
-                input,
-                key,
-                value: input[key]
-              }]
-            });
-            if (config$1.abortEarly) break;
-          }
-        }
-      } else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(object, "object");
-// @__NO_SIDE_EFFECTS__
-function objectWithRest(entries$1, rest, message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "object_with_rest",
-    reference: objectWithRest,
-    expects: "Object",
-    async: false,
-    entries: entries$1,
-    rest,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      const input = dataset.value;
-      if (input && typeof input === "object") {
-        dataset.typed = true;
-        dataset.value = {};
-        for (const key in this.entries) {
-          const valueSchema = this.entries[key];
-          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
-            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
-            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
-            if (valueDataset.issues) {
-              const pathItem = {
-                type: "object",
-                origin: "value",
-                input,
-                key,
-                value: value$1
-              };
-              for (const issue of valueDataset.issues) {
-                if (issue.path) issue.path.unshift(pathItem);
-                else issue.path = [pathItem];
-                dataset.issues?.push(issue);
-              }
-              if (!dataset.issues) dataset.issues = valueDataset.issues;
-              if (config$1.abortEarly) {
-                dataset.typed = false;
-                break;
-              }
-            }
-            if (!valueDataset.typed) dataset.typed = false;
-            dataset.value[key] = valueDataset.value;
-          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
-          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
-            _addIssue(this, "key", dataset, config$1, {
-              input: void 0,
-              expected: `"${key}"`,
-              path: [{
-                type: "object",
-                origin: "key",
-                input,
-                key,
-                value: input[key]
-              }]
-            });
-            if (config$1.abortEarly) break;
-          }
-        }
-        if (!dataset.issues || !config$1.abortEarly) {
-          for (const key in input) if (/* @__PURE__ */ _isValidObjectKey(input, key) && !Object.prototype.hasOwnProperty.call(this.entries, key)) {
-            const valueDataset = this.rest["~run"]({ value: input[key] }, config$1);
-            if (valueDataset.issues) {
-              const pathItem = {
-                type: "object",
-                origin: "value",
-                input,
-                key,
-                value: input[key]
-              };
-              for (const issue of valueDataset.issues) {
-                if (issue.path) issue.path.unshift(pathItem);
-                else issue.path = [pathItem];
-                dataset.issues?.push(issue);
-              }
-              if (!dataset.issues) dataset.issues = valueDataset.issues;
-              if (config$1.abortEarly) {
-                dataset.typed = false;
-                break;
-              }
-            }
-            if (!valueDataset.typed) dataset.typed = false;
-            dataset.value[key] = valueDataset.value;
-          }
-        }
-      } else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(objectWithRest, "objectWithRest");
-// @__NO_SIDE_EFFECTS__
-function optional(wrapped, default_) {
-  return _standardSchema({
-    kind: "schema",
-    type: "optional",
-    reference: optional,
-    expects: `(${wrapped.expects} | undefined)`,
-    async: false,
-    wrapped,
-    default: default_,
-    "~run"(dataset, config$1) {
-      if (dataset.value === void 0) {
-        if (this.default !== void 0) dataset.value = /* @__PURE__ */ getDefault(this, dataset, config$1);
-        if (dataset.value === void 0) {
-          dataset.typed = true;
-          return dataset;
-        }
-      }
-      return this.wrapped["~run"](dataset, config$1);
-    }
-  });
-}
-__name(optional, "optional");
-// @__NO_SIDE_EFFECTS__
-function picklist(options, message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "picklist",
-    reference: picklist,
-    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
-    async: false,
-    options,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (this.options.includes(dataset.value)) dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(picklist, "picklist");
-// @__NO_SIDE_EFFECTS__
-function record(key, value$1, message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "record",
-    reference: record,
-    expects: "Object",
-    async: false,
-    key,
-    value: value$1,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      const input = dataset.value;
-      if (input && typeof input === "object") {
-        dataset.typed = true;
-        dataset.value = {};
-        for (const entryKey in input) if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
-          const entryValue = input[entryKey];
-          const keyDataset = this.key["~run"]({ value: entryKey }, config$1);
-          if (keyDataset.issues) {
-            const pathItem = {
-              type: "object",
-              origin: "key",
-              input,
-              key: entryKey,
-              value: entryValue
-            };
-            for (const issue of keyDataset.issues) {
-              issue.path = [pathItem];
-              dataset.issues?.push(issue);
-            }
-            if (!dataset.issues) dataset.issues = keyDataset.issues;
-            if (config$1.abortEarly) {
-              dataset.typed = false;
-              break;
-            }
-          }
-          const valueDataset = this.value["~run"]({ value: entryValue }, config$1);
-          if (valueDataset.issues) {
-            const pathItem = {
-              type: "object",
-              origin: "value",
-              input,
-              key: entryKey,
-              value: entryValue
-            };
-            for (const issue of valueDataset.issues) {
-              if (issue.path) issue.path.unshift(pathItem);
-              else issue.path = [pathItem];
-              dataset.issues?.push(issue);
-            }
-            if (!dataset.issues) dataset.issues = valueDataset.issues;
-            if (config$1.abortEarly) {
-              dataset.typed = false;
-              break;
-            }
-          }
-          if (!keyDataset.typed || !valueDataset.typed) dataset.typed = false;
-          if (keyDataset.typed) dataset.value[keyDataset.value] = valueDataset.value;
-        }
-      } else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(record, "record");
-// @__NO_SIDE_EFFECTS__
-function strictObject(entries$1, message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "strict_object",
-    reference: strictObject,
-    expects: "Object",
-    async: false,
-    entries: entries$1,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      const input = dataset.value;
-      if (input && typeof input === "object") {
-        dataset.typed = true;
-        dataset.value = {};
-        for (const key in this.entries) {
-          const valueSchema = this.entries[key];
-          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && valueSchema.default !== void 0) {
-            const value$1 = key in input ? input[key] : /* @__PURE__ */ getDefault(valueSchema);
-            const valueDataset = valueSchema["~run"]({ value: value$1 }, config$1);
-            if (valueDataset.issues) {
-              const pathItem = {
-                type: "object",
-                origin: "value",
-                input,
-                key,
-                value: value$1
-              };
-              for (const issue of valueDataset.issues) {
-                if (issue.path) issue.path.unshift(pathItem);
-                else issue.path = [pathItem];
-                dataset.issues?.push(issue);
-              }
-              if (!dataset.issues) dataset.issues = valueDataset.issues;
-              if (config$1.abortEarly) {
-                dataset.typed = false;
-                break;
-              }
-            }
-            if (!valueDataset.typed) dataset.typed = false;
-            dataset.value[key] = valueDataset.value;
-          } else if (valueSchema.fallback !== void 0) dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
-          else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
-            _addIssue(this, "key", dataset, config$1, {
-              input: void 0,
-              expected: `"${key}"`,
-              path: [{
-                type: "object",
-                origin: "key",
-                input,
-                key,
-                value: input[key]
-              }]
-            });
-            if (config$1.abortEarly) break;
-          }
-        }
-        if (!dataset.issues || !config$1.abortEarly) {
-          for (const key in input) if (!Object.prototype.hasOwnProperty.call(this.entries, key)) {
-            _addIssue(this, "key", dataset, config$1, {
-              input: key,
-              expected: "never",
-              path: [{
-                type: "object",
-                origin: "key",
-                input,
-                key,
-                value: input[key]
-              }]
-            });
-            break;
-          }
-        }
-      } else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(strictObject, "strictObject");
-// @__NO_SIDE_EFFECTS__
-function string(message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "string",
-    reference: string,
-    expects: "string",
-    async: false,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      if (typeof dataset.value === "string") dataset.typed = true;
-      else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(string, "string");
-// @__NO_SIDE_EFFECTS__
-function _subIssues(datasets) {
-  let issues;
-  if (datasets) for (const dataset of datasets) if (issues) for (const issue of dataset.issues) issues.push(issue);
-  else issues = dataset.issues;
-  return issues;
-}
-__name(_subIssues, "_subIssues");
-// @__NO_SIDE_EFFECTS__
-function union(options, message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "union",
-    reference: union,
-    expects: /* @__PURE__ */ _joinExpects(options.map((option) => option.expects), "|"),
-    async: false,
-    options,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      let validDataset;
-      let typedDatasets;
-      let untypedDatasets;
-      for (const schema of this.options) {
-        const optionDataset = schema["~run"]({ value: dataset.value }, config$1);
-        if (optionDataset.typed) if (optionDataset.issues) if (typedDatasets) typedDatasets.push(optionDataset);
-        else typedDatasets = [optionDataset];
-        else {
-          validDataset = optionDataset;
-          break;
-        }
-        else if (untypedDatasets) untypedDatasets.push(optionDataset);
-        else untypedDatasets = [optionDataset];
-      }
-      if (validDataset) return validDataset;
-      if (typedDatasets) {
-        if (typedDatasets.length === 1) return typedDatasets[0];
-        _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(typedDatasets) });
-        dataset.typed = true;
-      } else if (untypedDatasets?.length === 1) return untypedDatasets[0];
-      else _addIssue(this, "type", dataset, config$1, { issues: /* @__PURE__ */ _subIssues(untypedDatasets) });
-      return dataset;
-    }
-  });
-}
-__name(union, "union");
-// @__NO_SIDE_EFFECTS__
-function unknown() {
-  return _standardSchema({
-    kind: "schema",
-    type: "unknown",
-    reference: unknown,
-    expects: "unknown",
-    async: false,
-    "~run"(dataset) {
-      dataset.typed = true;
-      return dataset;
-    }
-  });
-}
-__name(unknown, "unknown");
-// @__NO_SIDE_EFFECTS__
-function variant(key, options, message$1) {
-  return _standardSchema({
-    kind: "schema",
-    type: "variant",
-    reference: variant,
-    expects: "Object",
-    async: false,
-    key,
-    options,
-    message: message$1,
-    "~run"(dataset, config$1) {
-      const input = dataset.value;
-      if (input && typeof input === "object") {
-        let outputDataset;
-        let maxDiscriminatorPriority = 0;
-        let invalidDiscriminatorKey = this.key;
-        let expectedDiscriminators = [];
-        const parseOptions = /* @__PURE__ */ __name((variant$1, allKeys) => {
-          for (const schema of variant$1.options) {
-            if (schema.type === "variant") parseOptions(schema, new Set(allKeys).add(schema.key));
-            else {
-              let keysAreValid = true;
-              let currentPriority = 0;
-              for (const currentKey of allKeys) {
-                const discriminatorSchema = schema.entries[currentKey];
-                if (currentKey in input ? discriminatorSchema["~run"]({
-                  typed: false,
-                  value: input[currentKey]
-                }, ABORT_EARLY_CONFIG).issues : discriminatorSchema.type !== "exact_optional" && discriminatorSchema.type !== "optional" && discriminatorSchema.type !== "nullish") {
-                  keysAreValid = false;
-                  if (invalidDiscriminatorKey !== currentKey && (maxDiscriminatorPriority < currentPriority || maxDiscriminatorPriority === currentPriority && currentKey in input && !(invalidDiscriminatorKey in input))) {
-                    maxDiscriminatorPriority = currentPriority;
-                    invalidDiscriminatorKey = currentKey;
-                    expectedDiscriminators = [];
-                  }
-                  if (invalidDiscriminatorKey === currentKey) expectedDiscriminators.push(schema.entries[currentKey].expects);
-                  break;
-                }
-                currentPriority++;
-              }
-              if (keysAreValid) {
-                const optionDataset = schema["~run"]({ value: input }, config$1);
-                if (!outputDataset || !outputDataset.typed && optionDataset.typed) outputDataset = optionDataset;
-              }
-            }
-            if (outputDataset && !outputDataset.issues) break;
-          }
-        }, "parseOptions");
-        parseOptions(this, /* @__PURE__ */ new Set([this.key]));
-        if (outputDataset) return outputDataset;
-        _addIssue(this, "type", dataset, config$1, {
-          input: input[invalidDiscriminatorKey],
-          expected: /* @__PURE__ */ _joinExpects(expectedDiscriminators, "|"),
-          path: [{
-            type: "object",
-            origin: "value",
-            input,
-            key: invalidDiscriminatorKey,
-            value: input[invalidDiscriminatorKey]
-          }]
-        });
-      } else _addIssue(this, "type", dataset, config$1);
-      return dataset;
-    }
-  });
-}
-__name(variant, "variant");
-// @__NO_SIDE_EFFECTS__
-function omit(schema, keys) {
-  const entries$1 = { ...schema.entries };
-  for (const key of keys) delete entries$1[key];
-  return _standardSchema({
-    ...schema,
-    entries: entries$1
-  });
-}
-__name(omit, "omit");
-function parse(schema, input, config$1) {
-  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
-  if (dataset.issues) throw new ValiError(dataset.issues);
-  return dataset.value;
-}
-__name(parse, "parse");
-// @__NO_SIDE_EFFECTS__
-function partial(schema, keys) {
-  const entries$1 = {};
-  for (const key in schema.entries) entries$1[key] = !keys || keys.includes(key) ? /* @__PURE__ */ optional(schema.entries[key]) : schema.entries[key];
-  return _standardSchema({
-    ...schema,
-    entries: entries$1
-  });
-}
-__name(partial, "partial");
-// @__NO_SIDE_EFFECTS__
-function pick(schema, keys) {
-  const entries$1 = {};
-  for (const key of keys) entries$1[key] = schema.entries[key];
-  return _standardSchema({
-    ...schema,
-    entries: entries$1
-  });
-}
-__name(pick, "pick");
-// @__NO_SIDE_EFFECTS__
-function pipe(...pipe$1) {
-  return _standardSchema({
-    ...pipe$1[0],
-    pipe: pipe$1,
-    "~run"(dataset, config$1) {
-      for (const item of pipe$1) if (item.kind !== "metadata") {
-        if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
-          dataset.typed = false;
-          break;
-        }
-        if (!dataset.issues || !config$1.abortEarly && !config$1.abortPipeEarly) dataset = item["~run"](dataset, config$1);
-      }
-      return dataset;
-    }
-  });
-}
-__name(pipe, "pipe");
-// @__NO_SIDE_EFFECTS__
-function safeParse(schema, input, config$1) {
-  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
-  return {
-    typed: dataset.typed,
-    success: !dataset.issues,
-    output: dataset.value,
-    issues: dataset.issues
-  };
-}
-__name(safeParse, "safeParse");
-// @__NO_SIDE_EFFECTS__
-function summarize(issues) {
-  let summary = "";
-  for (const issue of issues) {
-    if (summary) summary += "\n";
-    summary += `\xD7 ${issue.message}`;
-    const dotPath = /* @__PURE__ */ getDotPath(issue);
-    if (dotPath) summary += `
-  \u2192 at ${dotPath}`;
-  }
-  return summary;
-}
-__name(summarize, "summarize");
-// @__NO_SIDE_EFFECTS__
-function unwrap(schema) {
-  return schema.wrapped;
-}
-__name(unwrap, "unwrap");
-
-// node_modules/.pnpm/@valibot+to-json-schema@1.8.0_valibot@1.5.0_typescript@7.0.2_/node_modules/@valibot/to-json-schema/dist/index.mjs
-function addError(errors, message) {
-  if (errors) {
-    errors.push(message);
-    return errors;
-  }
-  return [message];
-}
-__name(addError, "addError");
-var ESCAPE_REGEX = /[.*+?^${}()|[\]\\]/g;
-function escapeRegExp(string2) {
-  return string2.replace(ESCAPE_REGEX, "\\$&");
-}
-__name(escapeRegExp, "escapeRegExp");
-function handleError(message, config) {
-  switch (config?.errorMode) {
-    case "ignore":
-      break;
-    case "warn":
-      console.warn(message);
-      break;
-    default:
-      throw new Error(message);
-  }
-}
-__name(handleError, "handleError");
-function isJsonConstValue(value) {
-  return typeof value === "boolean" || typeof value === "number" && Number.isFinite(value) || typeof value === "string";
-}
-__name(isJsonConstValue, "isJsonConstValue");
-function isJsonEnumValues(values) {
-  return values.every(isJsonConstValue);
-}
-__name(isJsonEnumValues, "isJsonEnumValues");
-var ReferenceMap = class extends Map {
-  static {
-    __name(this, "ReferenceMap");
-  }
-  /**
-  * Creates an empty schema reference map.
-  */
-  constructor() {
-    super();
-    this.count = 0;
-    this.usedIds = /* @__PURE__ */ new Set();
-  }
-  /**
-  * Adds a schema reference and reserves its ID.
-  *
-  * @param schema The Valibot schema.
-  * @param referenceId The reference ID.
-  *
-  * @returns The reference map.
-  */
-  set(schema, referenceId) {
-    this.usedIds.add(referenceId);
-    return super.set(schema, referenceId);
-  }
-  /**
-  * Creates a reference ID that is not yet used.
-  *
-  * @param definitions The JSON Schema definitions.
-  *
-  * @returns The unused reference ID.
-  */
-  createId(definitions) {
-    while (this.usedIds.has(`${this.count}`) || `${this.count}` in definitions) this.count++;
-    return `${this.count++}`;
-  }
-};
-function getLowerBound(current, value) {
-  if (typeof current !== "number" || !Number.isFinite(current) || value > current) return value;
-  return current;
-}
-__name(getLowerBound, "getLowerBound");
-function getUpperBound(current, value) {
-  if (typeof current !== "number" || !Number.isFinite(current) || value < current) return value;
-  return current;
-}
-__name(getUpperBound, "getUpperBound");
-// @__NO_SIDE_EFFECTS__
-function getNotRestriction(current, value) {
-  return current !== void 0 ? { anyOf: [current, value] } : value;
-}
-__name(getNotRestriction, "getNotRestriction");
-function intersectEnum(jsonSchema, values) {
-  let enumValues = jsonSchema.enum ?? values;
-  if (jsonSchema.enum) {
-    const valueSet = new Set(values);
-    enumValues = enumValues.filter((value) => valueSet.has(value));
-  }
-  if (enumValues.length) jsonSchema.enum = [...new Set(enumValues)];
-  else {
-    delete jsonSchema.enum;
-    jsonSchema.not = /* @__PURE__ */ getNotRestriction(jsonSchema.not, {});
-  }
-}
-__name(intersectEnum, "intersectEnum");
-function convertAction(jsonSchema, valibotAction, config) {
-  if (config?.ignoreActions?.includes(valibotAction.type)) return jsonSchema;
-  let errors;
-  switch (valibotAction.type) {
-    case "base64":
-      jsonSchema.contentEncoding = "base64";
-      break;
-    case "bic":
-    case "cuid2":
-    case "decimal":
-    case "digits":
-    case "domain":
-    case "emoji":
-    case "hash":
-    case "hexadecimal":
-    case "hex_color":
-    case "isrc":
-    case "iso_time_second":
-    case "iso_week":
-    case "ksuid":
-    case "mac":
-    case "mac48":
-    case "mac64":
-    case "nanoid":
-    case "octal":
-    case "slug":
-    case "ulid":
-      if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
-      else jsonSchema.pattern = valibotAction.requirement.source;
-      break;
-    case "description":
-      jsonSchema.description = valibotAction.description;
-      break;
-    case "email":
-    case "rfc_email":
-      jsonSchema.format = "email";
-      break;
-    case "ends_with":
-      if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
-      else jsonSchema.pattern = `${escapeRegExp(valibotAction.requirement)}$`;
-      break;
-    case "empty":
-      if (jsonSchema.type === "array") jsonSchema.maxItems = 0;
-      else {
-        if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
-        jsonSchema.maxLength = 0;
-      }
-      break;
-    case "entries":
-      if (!Number.isInteger(valibotAction.requirement) || valibotAction.requirement < 0) {
-        errors = addError(errors, 'The requirement of the "entries" action must be a non-negative integer.');
-        break;
-      }
-      jsonSchema.minProperties = getLowerBound(jsonSchema.minProperties, valibotAction.requirement);
-      jsonSchema.maxProperties = getUpperBound(jsonSchema.maxProperties, valibotAction.requirement);
-      break;
-    case "examples":
-      if (Array.isArray(jsonSchema.examples)) jsonSchema.examples = [...jsonSchema.examples, ...valibotAction.examples];
-      else jsonSchema.examples = valibotAction.examples;
-      break;
-    case "gt_value":
-      if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") {
-        errors = addError(errors, `The "gt_value" action is not supported on type "${jsonSchema.type}".`);
-        break;
-      }
-      if (!Number.isFinite(valibotAction.requirement)) {
-        errors = addError(errors, 'The requirement of the "gt_value" action is not JSON compatible.');
-        break;
-      }
-      if (config?.target === "openapi-3.0") {
-        errors = addError(errors, 'The "gt_value" action is not supported for OpenAPI 3.0.');
-        break;
-      }
-      jsonSchema.exclusiveMinimum = getLowerBound(jsonSchema.exclusiveMinimum, valibotAction.requirement);
-      break;
-    case "includes":
-      if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
-      else jsonSchema.pattern = escapeRegExp(valibotAction.requirement);
-      break;
-    case "integer":
-      jsonSchema.type = "integer";
-      break;
-    case "ipv4":
-      jsonSchema.format = "ipv4";
-      break;
-    case "ipv6":
-      jsonSchema.format = "ipv6";
-      break;
-    case "iso_date":
-      jsonSchema.format = "date";
-      break;
-    case "iso_date_time":
-    case "iso_timestamp":
-      jsonSchema.format = "date-time";
-      break;
-    case "iso_time":
-      jsonSchema.format = "time";
-      break;
-    case "jws_compact":
-      if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
-      else jsonSchema.pattern = valibotAction.requirement.source;
-      break;
-    case "length":
-      if (!Number.isInteger(valibotAction.requirement) || valibotAction.requirement < 0) {
-        errors = addError(errors, 'The requirement of the "length" action must be a non-negative integer.');
-        break;
-      }
-      if (jsonSchema.type === "array") {
-        jsonSchema.minItems = getLowerBound(jsonSchema.minItems, valibotAction.requirement);
-        jsonSchema.maxItems = getUpperBound(jsonSchema.maxItems, valibotAction.requirement);
-      } else {
-        if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
-        jsonSchema.minLength = getLowerBound(jsonSchema.minLength, valibotAction.requirement);
-        jsonSchema.maxLength = getUpperBound(jsonSchema.maxLength, valibotAction.requirement);
-      }
-      break;
-    case "lt_value":
-      if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") {
-        errors = addError(errors, `The "lt_value" action is not supported on type "${jsonSchema.type}".`);
-        break;
-      }
-      if (!Number.isFinite(valibotAction.requirement)) {
-        errors = addError(errors, 'The requirement of the "lt_value" action is not JSON compatible.');
-        break;
-      }
-      if (config?.target === "openapi-3.0") {
-        errors = addError(errors, 'The "lt_value" action is not supported for OpenAPI 3.0.');
-        break;
-      }
-      jsonSchema.exclusiveMaximum = getUpperBound(jsonSchema.exclusiveMaximum, valibotAction.requirement);
-      break;
-    case "max_entries":
-      if (!Number.isInteger(valibotAction.requirement) || valibotAction.requirement < 0) {
-        errors = addError(errors, 'The requirement of the "max_entries" action must be a non-negative integer.');
-        break;
-      }
-      jsonSchema.maxProperties = getUpperBound(jsonSchema.maxProperties, valibotAction.requirement);
-      break;
-    case "max_length":
-      if (!Number.isInteger(valibotAction.requirement) || valibotAction.requirement < 0) {
-        errors = addError(errors, 'The requirement of the "max_length" action must be a non-negative integer.');
-        break;
-      }
-      if (jsonSchema.type === "array") jsonSchema.maxItems = getUpperBound(jsonSchema.maxItems, valibotAction.requirement);
-      else {
-        if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
-        jsonSchema.maxLength = getUpperBound(jsonSchema.maxLength, valibotAction.requirement);
-      }
-      break;
-    case "max_value":
-      if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") {
-        errors = addError(errors, `The "max_value" action is not supported on type "${jsonSchema.type}".`);
-        break;
-      }
-      if (!Number.isFinite(valibotAction.requirement)) {
-        errors = addError(errors, 'The requirement of the "max_value" action is not JSON compatible.');
-        break;
-      }
-      jsonSchema.maximum = getUpperBound(jsonSchema.maximum, valibotAction.requirement);
-      break;
-    case "metadata":
-      if (typeof valibotAction.metadata.title === "string") jsonSchema.title = valibotAction.metadata.title;
-      if (typeof valibotAction.metadata.description === "string") jsonSchema.description = valibotAction.metadata.description;
-      if (Array.isArray(valibotAction.metadata.examples)) if (Array.isArray(jsonSchema.examples)) jsonSchema.examples = [...jsonSchema.examples, ...valibotAction.metadata.examples];
-      else jsonSchema.examples = valibotAction.metadata.examples;
-      for (const key of Object.keys(valibotAction.metadata)) if (key !== "title" && key !== "description" && key !== "examples" && key !== "__proto__") jsonSchema[key] = valibotAction.metadata[key];
-      break;
-    case "min_entries":
-      if (!Number.isInteger(valibotAction.requirement) || valibotAction.requirement < 0) {
-        errors = addError(errors, 'The requirement of the "min_entries" action must be a non-negative integer.');
-        break;
-      }
-      jsonSchema.minProperties = getLowerBound(jsonSchema.minProperties, valibotAction.requirement);
-      break;
-    case "min_length":
-      if (!Number.isInteger(valibotAction.requirement) || valibotAction.requirement < 0) {
-        errors = addError(errors, 'The requirement of the "min_length" action must be a non-negative integer.');
-        break;
-      }
-      if (jsonSchema.type === "array") jsonSchema.minItems = getLowerBound(jsonSchema.minItems, valibotAction.requirement);
-      else {
-        if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
-        jsonSchema.minLength = getLowerBound(jsonSchema.minLength, valibotAction.requirement);
-      }
-      break;
-    case "min_value":
-      if (jsonSchema.type !== "number" && jsonSchema.type !== "integer") {
-        errors = addError(errors, `The "min_value" action is not supported on type "${jsonSchema.type}".`);
-        break;
-      }
-      if (!Number.isFinite(valibotAction.requirement)) {
-        errors = addError(errors, 'The requirement of the "min_value" action is not JSON compatible.');
-        break;
-      }
-      jsonSchema.minimum = getLowerBound(jsonSchema.minimum, valibotAction.requirement);
-      break;
-    case "multiple_of":
-      jsonSchema.multipleOf = valibotAction.requirement;
-      break;
-    case "non_empty":
-      if (jsonSchema.type === "array") jsonSchema.minItems = getLowerBound(jsonSchema.minItems, 1);
-      else {
-        if (jsonSchema.type !== "string") errors = addError(errors, `The "${valibotAction.type}" action is not supported on type "${jsonSchema.type}".`);
-        jsonSchema.minLength = getLowerBound(jsonSchema.minLength, 1);
-      }
-      break;
-    case "not_value":
-      if (!isJsonConstValue(valibotAction.requirement)) {
-        errors = addError(errors, 'The requirement of the "not_value" action is not JSON compatible.');
-        break;
-      }
-      jsonSchema.not = /* @__PURE__ */ getNotRestriction(jsonSchema.not, config?.target === "openapi-3.0" ? { enum: [valibotAction.requirement] } : { const: valibotAction.requirement });
-      break;
-    case "not_values":
-      if (!isJsonEnumValues(valibotAction.requirement)) {
-        errors = addError(errors, 'A requirement of the "not_values" action is not JSON compatible.');
-        break;
-      }
-      if (valibotAction.requirement.length) jsonSchema.not = /* @__PURE__ */ getNotRestriction(jsonSchema.not, { enum: [...new Set(valibotAction.requirement)] });
-      break;
-    case "regex":
-      if (valibotAction.requirement.flags) errors = addError(errors, "RegExp flags are not supported by JSON Schema.");
-      if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
-      else jsonSchema.pattern = valibotAction.requirement.source;
-      break;
-    case "safe_integer":
-      jsonSchema.type = "integer";
-      jsonSchema.minimum = getLowerBound(jsonSchema.minimum, Number.MIN_SAFE_INTEGER);
-      jsonSchema.maximum = getUpperBound(jsonSchema.maximum, Number.MAX_SAFE_INTEGER);
-      break;
-    case "starts_with":
-      if (jsonSchema.pattern) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with another regex action.`);
-      else jsonSchema.pattern = `^${escapeRegExp(valibotAction.requirement)}`;
-      break;
-    case "title":
-      jsonSchema.title = valibotAction.title;
-      break;
-    case "url":
-      jsonSchema.format = "uri";
-      break;
-    case "uuid":
-      jsonSchema.format = "uuid";
-      break;
-    case "value":
-      if (!isJsonConstValue(valibotAction.requirement)) {
-        errors = addError(errors, 'The requirement of the "value" action is not JSON compatible.');
-        break;
-      }
-      if (config?.target === "openapi-3.0") intersectEnum(jsonSchema, [valibotAction.requirement]);
-      else if ("const" in jsonSchema && jsonSchema.const !== valibotAction.requirement) errors = addError(errors, `The "${valibotAction.type}" action is not supported in combination with a different "const" restriction.`);
-      else jsonSchema.const = valibotAction.requirement;
-      break;
-    case "values":
-      if (!isJsonEnumValues(valibotAction.requirement)) {
-        errors = addError(errors, 'A requirement of the "values" action is not JSON compatible.');
-        break;
-      }
-      intersectEnum(jsonSchema, valibotAction.requirement);
-      break;
-    default:
-      errors = addError(errors, `The "${valibotAction.type}" action cannot be converted to JSON Schema.`);
-  }
-  if (config?.overrideAction) {
-    const actionOverride = config.overrideAction({
-      valibotAction,
-      jsonSchema,
-      errors
-    });
-    if (actionOverride) return { ...actionOverride };
-  }
-  if (errors) for (const message of errors) handleError(message, config);
-  return jsonSchema;
-}
-__name(convertAction, "convertAction");
-function flattenPipe(pipe2) {
-  return pipe2.flatMap((item) => "pipe" in item ? flattenPipe(item.pipe) : item);
-}
-__name(flattenPipe, "flattenPipe");
-function getDefinitionRef(referenceId) {
-  return `#/$defs/${referenceId.replaceAll("~", "~0").replaceAll("/", "~1")}`;
-}
-__name(getDefinitionRef, "getDefinitionRef");
-function convertSchema(jsonSchema, valibotSchema, config, context, skipRef = false) {
-  if (!skipRef) {
-    const referenceId = context.referenceMap.get(valibotSchema);
-    if (referenceId) {
-      jsonSchema.$ref = getDefinitionRef(referenceId);
-      if (config?.overrideRef) {
-        const refOverride = config.overrideRef({
-          ...context,
-          referenceId,
-          valibotSchema,
-          jsonSchema
-        });
-        if (refOverride) jsonSchema.$ref = refOverride;
-      }
-      return jsonSchema;
-    }
-  }
-  if ("pipe" in valibotSchema) {
-    const flatPipe = flattenPipe(valibotSchema.pipe);
-    let startIndex = 0;
-    let stopIndex = flatPipe.length - 1;
-    if (config?.typeMode === "input") {
-      const inputStopIndex = flatPipe.slice(1).findIndex((item) => item.kind === "schema" || item.kind === "transformation" && (item.type === "find_item" || item.type === "parse_json" || item.type === "raw_transform" || item.type === "reduce_items" || item.type === "stringify_json" || item.type === "to_bigint" || item.type === "to_boolean" || item.type === "to_date" || item.type === "to_number" || item.type === "to_string" || item.type === "transform"));
-      if (inputStopIndex !== -1) stopIndex = inputStopIndex;
-    } else if (config?.typeMode === "output") {
-      const outputStartIndex = flatPipe.findLastIndex((item) => item.kind === "schema");
-      if (outputStartIndex !== -1) startIndex = outputStartIndex;
-    }
-    for (let index = startIndex; index <= stopIndex; index++) {
-      const valibotPipeItem = flatPipe[index];
-      if (valibotPipeItem.kind === "schema") {
-        if (index > startIndex) handleError('Set the "typeMode" config to "input" or "output" to convert pipelines with multiple schemas.', config);
-        jsonSchema = convertSchema(jsonSchema, valibotPipeItem, config, context, true);
-      } else jsonSchema = convertAction(jsonSchema, valibotPipeItem, config);
-    }
-    return jsonSchema;
-  }
-  let errors;
-  switch (valibotSchema.type) {
-    case "boolean":
-      jsonSchema.type = "boolean";
-      break;
-    case "null":
-      if (config?.target === "openapi-3.0") jsonSchema.enum = [null];
-      else jsonSchema.type = "null";
-      break;
-    case "number":
-      jsonSchema.type = "number";
-      break;
-    case "string":
-      jsonSchema.type = "string";
-      break;
-    case "array":
-      jsonSchema.type = "array";
-      jsonSchema.items = convertSchema({}, valibotSchema.item, config, context);
-      break;
-    case "tuple":
-    case "tuple_with_rest":
-    case "loose_tuple":
-    case "strict_tuple":
-      jsonSchema.type = "array";
-      if (config?.target === "openapi-3.0") {
-        jsonSchema.items = { anyOf: [] };
-        jsonSchema.minItems = valibotSchema.items.length;
-        for (const item of valibotSchema.items) jsonSchema.items.anyOf.push(convertSchema({}, item, config, context));
-        if (valibotSchema.type === "tuple_with_rest") jsonSchema.items.anyOf.push(convertSchema({}, valibotSchema.rest, config, context));
-        else if (valibotSchema.type === "strict_tuple" || valibotSchema.type === "tuple") jsonSchema.maxItems = valibotSchema.items.length;
-      } else if (config?.target === "draft-2020-12") {
-        jsonSchema.prefixItems = [];
-        jsonSchema.minItems = valibotSchema.items.length;
-        for (const item of valibotSchema.items) jsonSchema.prefixItems.push(convertSchema({}, item, config, context));
-        if (valibotSchema.type === "tuple_with_rest") jsonSchema.items = convertSchema({}, valibotSchema.rest, config, context);
-        else if (valibotSchema.type === "strict_tuple") jsonSchema.items = false;
-      } else {
-        jsonSchema.items = [];
-        jsonSchema.minItems = valibotSchema.items.length;
-        for (const item of valibotSchema.items) jsonSchema.items.push(convertSchema({}, item, config, context));
-        if (valibotSchema.type === "tuple_with_rest") jsonSchema.additionalItems = convertSchema({}, valibotSchema.rest, config, context);
-        else if (valibotSchema.type === "strict_tuple") jsonSchema.additionalItems = false;
-      }
-      break;
-    case "object":
-    case "object_with_rest":
-    case "loose_object":
-    case "strict_object":
-      jsonSchema.type = "object";
-      jsonSchema.properties = {};
-      jsonSchema.required = [];
-      for (const key in valibotSchema.entries) {
-        const entry2 = valibotSchema.entries[key];
-        jsonSchema.properties[key] = convertSchema({}, entry2, config, context);
-        if (entry2.type !== "exact_optional" && entry2.type !== "nullish" && entry2.type !== "optional") jsonSchema.required.push(key);
-      }
-      if (valibotSchema.type === "object_with_rest") jsonSchema.additionalProperties = convertSchema({}, valibotSchema.rest, config, context);
-      else if (valibotSchema.type === "strict_object") jsonSchema.additionalProperties = false;
-      break;
-    case "record":
-      if (config?.target === "openapi-3.0" && "pipe" in valibotSchema.key) errors = addError(errors, 'The "record" schema with a schema for the key that contains a "pipe" cannot be converted to JSON Schema.');
-      if (valibotSchema.key.type !== "string") errors = addError(errors, `The "record" schema with the "${valibotSchema.key.type}" schema for the key cannot be converted to JSON Schema.`);
-      jsonSchema.type = "object";
-      if (config?.target !== "openapi-3.0") jsonSchema.propertyNames = convertSchema({}, valibotSchema.key, config, context);
-      jsonSchema.additionalProperties = convertSchema({}, valibotSchema.value, config, context);
-      break;
-    case "any":
-    case "unknown":
-      break;
-    case "never":
-      jsonSchema.not = {};
-      break;
-    case "nullable":
-    case "nullish":
-      if (config?.target === "openapi-3.0") {
-        const innerSchema = convertSchema({}, valibotSchema.wrapped, config, context);
-        Object.assign(jsonSchema, innerSchema);
-        jsonSchema.nullable = true;
-      } else jsonSchema.anyOf = [convertSchema({}, valibotSchema.wrapped, config, context), { type: "null" }];
-      if (valibotSchema.default !== void 0) jsonSchema.default = typeof valibotSchema.default === "function" ? valibotSchema.default() : valibotSchema.default;
-      break;
-    case "exact_optional":
-    case "optional":
-    case "undefinedable":
-      jsonSchema = convertSchema(jsonSchema, valibotSchema.wrapped, config, context);
-      if (valibotSchema.default !== void 0) jsonSchema.default = typeof valibotSchema.default === "function" ? valibotSchema.default() : valibotSchema.default;
-      break;
-    case "literal":
-      if (!isJsonConstValue(valibotSchema.literal)) {
-        errors = addError(errors, 'The value of the "literal" schema is not JSON compatible.');
-        break;
-      }
-      if (config?.target === "openapi-3.0") jsonSchema.enum = [valibotSchema.literal];
-      else jsonSchema.const = valibotSchema.literal;
-      break;
-    case "enum":
-    case "picklist": {
-      const options = valibotSchema.options;
-      if (!options.every((option) => typeof option === "string" || typeof option === "number" && Number.isFinite(option))) {
-        errors = addError(errors, `An option of the "${valibotSchema.type}" schema is not JSON compatible.`);
-        break;
-      }
-      jsonSchema.enum = options;
-      if (options.every((option) => typeof option === "string")) jsonSchema.type = "string";
-      else if (options.every((option) => typeof option === "number")) jsonSchema.type = "number";
-      else if (config?.target !== "openapi-3.0") jsonSchema.type = ["string", "number"];
-      break;
-    }
-    case "union":
-      jsonSchema.anyOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
-      break;
-    case "variant":
-      jsonSchema.oneOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
-      break;
-    case "intersect":
-      jsonSchema.allOf = valibotSchema.options.map((option) => convertSchema({}, option, config, context));
-      break;
-    case "lazy": {
-      let wrappedValibotSchema = context.getterMap.get(valibotSchema.getter);
-      if (!wrappedValibotSchema) {
-        wrappedValibotSchema = valibotSchema.getter(void 0);
-        context.getterMap.set(valibotSchema.getter, wrappedValibotSchema);
-      }
-      let referenceId = context.referenceMap.get(wrappedValibotSchema);
-      if (!referenceId) {
-        referenceId = context.referenceMap.createId(context.definitions);
-        context.referenceMap.set(wrappedValibotSchema, referenceId);
-        context.definitions[referenceId] = convertSchema({}, wrappedValibotSchema, config, context, true);
-      }
-      jsonSchema.$ref = getDefinitionRef(referenceId);
-      if (config?.overrideRef) {
-        const refOverride = config.overrideRef({
-          ...context,
-          referenceId,
-          valibotSchema: wrappedValibotSchema,
-          jsonSchema
-        });
-        if (refOverride) jsonSchema.$ref = refOverride;
-      }
-      break;
-    }
-    default:
-      errors = addError(errors, `The "${valibotSchema.type}" schema cannot be converted to JSON Schema.`);
-  }
-  if (config?.overrideSchema) {
-    const schemaOverride = config.overrideSchema({
-      ...context,
-      referenceId: context.referenceMap.get(valibotSchema),
-      valibotSchema,
-      jsonSchema,
-      errors
-    });
-    if (schemaOverride) return { ...schemaOverride };
-  }
-  if (errors) for (const message of errors) handleError(message, config);
-  return jsonSchema;
-}
-__name(convertSchema, "convertSchema");
-var store;
-function getGlobalDefs() {
-  return store;
-}
-__name(getGlobalDefs, "getGlobalDefs");
-function toJsonSchema(schema, config) {
-  const context = {
-    definitions: {},
-    referenceMap: new ReferenceMap(),
-    getterMap: /* @__PURE__ */ new Map()
-  };
-  const definitions = config?.definitions ?? getGlobalDefs();
-  if (definitions) {
-    for (const key in definitions) context.referenceMap.set(definitions[key], key);
-    for (const key in definitions) context.definitions[key] = convertSchema({}, definitions[key], config, context, true);
-  }
-  const jsonSchema = convertSchema({}, schema, config, context);
-  const target = config?.target ?? "draft-07";
-  if (target === "draft-2020-12") jsonSchema.$schema = "https://json-schema.org/draft/2020-12/schema";
-  else if (target === "draft-07") jsonSchema.$schema = "http://json-schema.org/draft-07/schema#";
-  if (context.referenceMap.size) jsonSchema.$defs = context.definitions;
-  return jsonSchema;
-}
-__name(toJsonSchema, "toJsonSchema");
-var SUPPORTED_TARGETS = [
-  "draft-07",
-  "draft-2020-12",
-  "openapi-3.0"
-];
-function toStandardJsonSchema(schema) {
-  return { "~standard": {
-    ...schema["~standard"],
-    jsonSchema: {
-      input(options) {
-        if (SUPPORTED_TARGETS.includes(options.target)) return toJsonSchema(schema, {
-          typeMode: "input",
-          target: options.target,
-          ...options.libraryOptions
-        });
-        throw new Error(`Unsupported target: ${options.target}`);
-      },
-      output(options) {
-        if (SUPPORTED_TARGETS.includes(options.target)) return toJsonSchema(schema, {
-          typeMode: "output",
-          target: options.target,
-          ...options.libraryOptions
-        });
-        throw new Error(`Unsupported target: ${options.target}`);
-      }
-    }
-  } };
-}
-__name(toStandardJsonSchema, "toStandardJsonSchema");
-
-// node_modules/.pnpm/@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/registry.js
-var word = pipe(string(), regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "a lower-case word, words joined by -"));
-var SNAKE_CASE = /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/;
-var text = pipe(string(), regex(/\S/, "must not be empty"));
-var dottedId = pipe(string(), regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/, "dotted lower-case words, such as `page.next`"));
-var RegistryError = class extends Error {
-  static {
-    __name(this, "RegistryError");
-  }
-  registry;
-  problems;
-  constructor(registry, problems) {
-    super(`${registry} registry: ${problems.join("; ")}`);
-    this.registry = registry;
-    this.problems = problems;
-    this.name = "RegistryError";
-  }
-};
-var issuesOf = /* @__PURE__ */ __name((issues) => issues.map((issue) => {
-  const path = getDotPath(issue);
-  return path ? `${path}: ${issue.message}` : issue.message;
-}), "issuesOf");
-var parseRegistry = /* @__PURE__ */ __name((registry, schema, input, check2 = () => []) => {
-  const parsed = safeParse(schema, input);
-  if (!parsed.success)
-    throw new RegistryError(registry, issuesOf(parsed.issues));
-  const problems = check2(parsed.output);
-  if (problems.length > 0)
-    throw new RegistryError(registry, problems);
-  return parsed.output;
-}, "parseRegistry");
-var duplicates = /* @__PURE__ */ __name((values) => [...new Set(values.filter((value, index) => values.indexOf(value) !== index))].sort(), "duplicates");
-var jsonSchemaOf = /* @__PURE__ */ __name((schema, definitions) => toJsonSchema(schema, { target: "draft-2020-12", ...definitions ? { definitions } : {} }), "jsonSchemaOf");
-var PLACEHOLDER = /\{([a-z][a-z0-9]*(?:_[a-z0-9]+)*)\}/g;
-var placeholders = /* @__PURE__ */ __name((template) => [...template.matchAll(PLACEHOLDER)].map((match) => match[1] ?? ""), "placeholders");
-var fill = /* @__PURE__ */ __name((template, values) => template.replace(PLACEHOLDER, (_, name) => {
-  const value = values[name];
-  if (value === void 0)
-    throw new Error(`no value for {${name}} in "${template}"`);
-  return String(value);
-}), "fill");
-
-// node_modules/.pnpm/@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/exit-codes.js
-var EXIT_CODES = {
-  validation_error: 2,
-  configuration_error: 3,
-  authentication_error: 4,
-  permission_error: 5,
-  not_found: 6,
-  confirmation_required: 7,
-  rate_limited: 8,
-  timeout: 9,
-  network_error: 10,
-  provider_error: 11,
-  provider_unavailable: 12,
-  invalid_response: 13,
-  outcome_unknown: 14,
-  cancelled: 130
-};
-var exitCodeFor = /* @__PURE__ */ __name((code) => EXIT_CODES[code], "exitCodeFor");
-var GENERIC_FAILURE = 1;
-
-// node_modules/.pnpm/@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/sanitize.js
-var CONTROL = (
-  // biome-ignore lint/suspicious/noControlCharactersInRegex: matching them is the whole point
-  /[\u0000-\u0008\u000B-\u001F\u007F-\u009F\u200B\u200E\u200F\u202A-\u202E\u2066-\u2069\uFEFF\u{E0000}-\u{E007F}]/gu
-);
-var SUBDIVISION_FLAG = /\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}/gu;
-var LINE_BREAKS = /[\t\n\u2028\u2029]/g;
-var escaped = /* @__PURE__ */ __name((c) => {
-  const code = c.codePointAt(0) ?? 0;
-  if (code > 65535)
-    return `\\u{${code.toString(16)}}`;
-  return code > 255 ? `\\u${code.toString(16).padStart(4, "0")}` : `\\x${code.toString(16).padStart(2, "0")}`;
-}, "escaped");
-var visibleControls = /* @__PURE__ */ __name((text2) => {
-  let at = 0;
-  let result = "";
-  for (const flag of text2.matchAll(SUBDIVISION_FLAG)) {
-    result += text2.slice(at, flag.index).replace(CONTROL, escaped) + flag[0];
-    at = flag.index + flag[0].length;
-  }
-  return result + text2.slice(at).replace(CONTROL, escaped);
-}, "visibleControls");
-var singleLine = /* @__PURE__ */ __name((text2) => visibleControls(text2).replace(LINE_BREAKS, escaped), "singleLine");
-
-// node_modules/.pnpm/@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/effects.js
-var EFFECT_LEVELS = ["none", "read", "write"];
-var effectsSchema = strictObject({
-  remote: picklist(EFFECT_LEVELS),
-  local: picklist(EFFECT_LEVELS)
-});
-var writes = /* @__PURE__ */ __name((effects) => effects === void 0 || effects.remote === "write" || effects.local === "write", "writes");
-
-// node_modules/.pnpm/@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/output.js
-var MAX_NEXT_STEPS = 2;
-var COMPACT_FLAG = "--compact";
-var isoTime = pipe(string(), isoTimestamp("an ISO 8601 time in UTC"), endsWith("Z", "an ISO 8601 time in UTC, ending in `Z`"));
-var localTime = pipe(string(), regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}[+-]\d{2}:\d{2}$/, "an ISO 8601 time with its offset"));
-var reference = pipe(string(), regex(/^[a-z]+:\S+$/, "a reference such as `note:42`"));
-var nextStepSchema = variant("kind", [
-  strictObject({
-    kind: literal("command"),
-    step: dottedId,
-    /** The command path as one string, `messages list` — what the MCP router tools take as `command`. */
-    command: text,
-    args: record(string(), unknown()),
-    /**
-     * The whole line to type, with the tool and the profile it ran with: `tg personal mcp config`. Only the CLI
-     * knows the profile, so it fills this; MCP answers leave it out.
-     */
-    line: optional(text),
-    why: text,
-    /** True only when the target command is known to write nothing, here or at the provider. */
-    safe_to_auto_execute: boolean()
-  }),
-  /** Something only the person can do — sign in on the phone, approve a device. */
-  strictObject({
-    kind: literal("user_action"),
-    step: dottedId,
-    why: text,
-    safe_to_auto_execute: literal(false)
-  })
-]);
-var missingSchema = strictObject({
-  field: text,
-  why: text,
-  /** Left out when there is nothing to run that would fill the field. */
-  step: optional(dottedId)
-});
-var limit = pipe(number(), integer(), minValue(1));
-var totalSchema = strictObject({
-  value: pipe(number(), integer(), minValue(0)),
-  relation: picklist(["eq", "gte"])
-});
-var pageSchema = variant("mode", [
-  strictObject({
-    mode: literal("page"),
-    limit,
-    has_more: boolean(),
-    next_page: optional(pipe(number(), integer(), minValue(2))),
-    total: optional(totalSchema)
-  }),
-  strictObject({
-    mode: literal("cursor"),
-    limit,
-    has_more: boolean(),
-    next_cursor: optional(text),
-    total: optional(totalSchema)
-  })
-]);
-var issueSchema = strictObject({
-  code: picklist(errorCodes),
-  reason: optional(dottedId),
-  /** The account, provider or source that is missing from the answer. */
-  source: text
-});
-var metaSchema = strictObject({
-  run_id: text,
-  duration_ms: pipe(number(), integer(), minValue(0)),
-  accounts: optional(array(text)),
-  complete: boolean(),
-  issues: optional(array(issueSchema)),
-  truncated: optional(boolean()),
-  timezone: optional(text),
-  /** When the command answered, for an agent that plans from "now" (WC-TIME-7); `timezone` names the zone of `now_local`. */
-  now: optional(isoTime),
-  now_local: optional(localTime),
-  window: optional(strictObject({ since: optional(isoTime), until: optional(isoTime) }))
-});
-var nextSteps = optional(pipe(array(nextStepSchema), maxLength(MAX_NEXT_STEPS)));
-var listEnvelopeSchema = /* @__PURE__ */ __name((item) => strictObject({
-  items: array(item),
-  page: pageSchema,
-  next: nextSteps,
-  missing: optional(array(missingSchema)),
-  meta: metaSchema
-}), "listEnvelopeSchema");
-var itemEnvelopeSchema = /* @__PURE__ */ __name((item) => strictObject({
-  item,
-  next: nextSteps,
-  missing: optional(array(missingSchema)),
-  meta: metaSchema
-}), "itemEnvelopeSchema");
-var jsonlEndSchema = strictObject({
-  type: literal("end"),
-  complete: boolean(),
-  issues: optional(array(issueSchema)),
-  page: pageSchema
-});
-var jsonlOf = /* @__PURE__ */ __name(({ items, page, meta }) => [
-  ...items.map((data) => JSON.stringify({ type: "item", data })),
-  JSON.stringify({ type: "end", complete: meta.complete, ...meta.issues ? { issues: meta.issues } : {}, page })
-].join("\n"), "jsonlOf");
-
-// node_modules/.pnpm/@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/errors.js
-var CRASH_CODE = "internal_error";
-var CRASH_REASON = "command.crashed";
-var errorObjectSchema = strictObject({
-  error: strictObject({
-    code: picklist([...errorCodes, CRASH_CODE]),
-    reason: dottedId,
-    message: text,
-    /** The option or argument at fault. */
-    param: optional(text),
-    details: optional(record(string(), unknown())),
-    next: optional(pipe(array(nextStepSchema), maxLength(MAX_NEXT_STEPS))),
-    /** Whether running the same command again may work and cannot do harm; never for a write that may have landed. */
-    retry: strictObject({
-      safe: boolean(),
-      after_ms: optional(pipe(number(), integer(), minValue(0)))
-    }),
-    /** Optional until every CLI keeps a run for each failure. */
-    run_id: optional(text)
-  })
-});
-var reasonSchema = strictObject({
-  reason: dottedId,
-  code: picklist([...errorCodes, CRASH_CODE]),
-  /** `{name}` placeholders, each one of `details`. */
-  message: pipe(text, maxLength(120)),
-  details: array(pipe(string(), regex(SNAKE_CASE, "a snake_case key"))),
-  step: optional(dottedId)
-});
-var defineReasons = /* @__PURE__ */ __name((input) => parseRegistry("error reasons", array(reasonSchema), input, (reasons) => [
-  ...duplicates(reasons.map((entry2) => entry2.reason)).map((reason) => `"${reason}" is listed twice`),
-  ...reasons.flatMap((entry2) => placeholders(entry2.message).filter((name) => !entry2.details.includes(name)).map((name) => `${entry2.reason}: the message names {${name}}, which is not one of its details`))
-]), "defineReasons");
-var COMMON_DETAILS = ["attempts", "status", "request_id", "operation", "operation_id"];
-var BASE_REASONS = defineReasons([
-  { reason: "input.invalid", code: "validation_error", message: "the input is not valid", details: [] },
-  {
-    reason: "batch.read-budget",
-    code: "validation_error",
-    message: "batch stored-text read budget exhausted",
-    details: []
-  },
-  { reason: "batch.output-budget", code: "validation_error", message: "batch output budget exhausted", details: [] },
-  { reason: "config.invalid", code: "configuration_error", message: "the configuration is not valid", details: [] },
-  { reason: "auth.failed", code: "authentication_error", message: "the sign-in did not work", details: [] },
-  { reason: "access.denied", code: "permission_error", message: "this account may not do that", details: [] },
-  { reason: "item.not-found", code: "not_found", message: "nothing found by that name", details: [] },
-  {
-    reason: "tool.not-installed",
-    code: "not_found",
-    message: "no wcat-<name> program by that name is on PATH",
-    details: ["tool", "installed"]
-  },
-  {
-    reason: "confirmation.required",
-    code: "confirmation_required",
-    message: "this changes something; confirm it",
-    details: []
-  },
-  { reason: "provider.rate-limited", code: "rate_limited", message: "too many requests; wait", details: [] },
-  { reason: "command.timed-out", code: "timeout", message: "the command took too long", details: ["timeout_ms"] },
-  { reason: "network.failed", code: "network_error", message: "the network did not answer", details: [] },
-  { reason: "provider.refused", code: "provider_error", message: "the provider refused", details: [] },
-  { reason: "provider.unavailable", code: "provider_unavailable", message: "the provider is down", details: [] },
-  {
-    reason: "provider.invalid-response",
-    code: "invalid_response",
-    message: "the answer could not be read",
-    details: []
-  },
-  {
-    reason: "output.too-large",
-    code: "invalid_response",
-    message: "the output is over {max_bytes} bytes",
-    details: ["max_bytes", "buffered_bytes", "partial_output"]
-  },
-  {
-    reason: "output.fields-unavailable",
-    code: "invalid_response",
-    message: "fields can be picked only from whole JSON values",
-    details: []
-  },
-  { reason: "outcome.unknown", code: "outcome_unknown", message: "it is not known whether it worked", details: [] },
-  { reason: "command.cancelled", code: "cancelled", message: "the command was cancelled", details: [] },
-  { reason: CRASH_REASON, code: CRASH_CODE, message: "the command failed; this is a bug", details: [] }
-]);
-
-// node_modules/.pnpm/@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/standards/steps.js
-var SAME_COMMAND = "*";
-var commandPath = pipe(string(), regex(/^[a-z][a-z0-9-]*( [a-z][a-z0-9-]*)*$/, "a command path such as `messages sync`"));
-var stepSchema = union([
-  strictObject({
-    id: dottedId,
-    kind: optional(literal("command"), "command"),
-    command: union([literal(SAME_COMMAND), commandPath]),
-    args: array(strictObject({
-      name: pipe(string(), regex(SNAKE_CASE, "an argument or option name in snake_case")),
-      required: boolean()
-    })),
-    why: pipe(text, maxLength(120))
-  }),
-  strictObject({ id: dottedId, kind: literal("user_action"), why: pipe(text, maxLength(120)) })
-]);
-var argsOf = /* @__PURE__ */ __name((step) => step.kind === "command" ? step.args : [], "argsOf");
-var defineSteps = /* @__PURE__ */ __name((input) => parseRegistry("steps", array(stepSchema), input, (steps) => [
-  ...duplicates(steps.map((step) => step.id)).map((id) => `"${id}" is listed twice`),
-  ...steps.flatMap((step) => duplicates(argsOf(step).map((arg) => arg.name)).map((name) => `${step.id}: argument "${name}" is listed twice`))
-]), "defineSteps");
-var BINDS = /^[^\p{Cc}\u2028\u2029]*$/u;
-var binds = /* @__PURE__ */ __name((value) => typeof value === "number" || typeof value === "boolean" || typeof value === "string" && BINDS.test(value), "binds");
-var stepOf = /* @__PURE__ */ __name((definition, input = {}) => {
-  const args = input.args ?? {};
-  if (definition.kind === "user_action")
-    return {
-      kind: "user_action",
-      step: definition.id,
-      why: fill(definition.why, { ...input.values }),
-      safe_to_auto_execute: false
-    };
-  const command = definition.command === SAME_COMMAND ? input.command : definition.command;
-  if (!command)
-    throw new Error(`${definition.id}: the step runs the same command, so pass the command`);
-  const known = new Set(definition.args.map((arg) => arg.name));
-  if (definition.command !== SAME_COMMAND) {
-    for (const name of Object.keys(args))
-      if (!known.has(name))
-        throw new Error(`${definition.id}: no argument "${name}"`);
-  }
-  for (const arg of definition.args)
-    if (arg.required && args[arg.name] === void 0)
-      throw new Error(`${definition.id}: argument "${arg.name}" is required`);
-  for (const [name, value] of Object.entries(args))
-    if (!(Array.isArray(value) ? value.every(binds) : binds(value)))
-      throw new Error(`${definition.id}: "${name}" is not a value an option takes`);
-  const target = input.targets?.(command);
-  if (input.targets && !target)
-    throw new Error(`${definition.id}: no command "${command}"`);
-  const names = new Set(target?.names ?? []);
-  if (target) {
-    for (const name of Object.keys(args))
-      if (!names.has(name))
-        throw new Error(`${definition.id}: "${command}" takes no "${name}"`);
-  }
-  const scalars = Object.fromEntries(Object.entries(args).filter((entry2) => ["string", "number"].includes(typeof entry2[1])));
-  return {
-    kind: "command",
-    step: definition.id,
-    command,
-    args: { ...args },
-    why: fill(definition.why, { ...scalars, ...input.values }),
-    safe_to_auto_execute: target?.effects !== void 0 && !writes(target.effects)
-  };
-}, "stepOf");
-var STEPS = defineSteps([
-  {
-    id: "page.next",
-    command: SAME_COMMAND,
-    args: [
-      { name: "cursor", required: false },
-      { name: "page", required: false },
-      { name: "limit", required: false }
-    ],
-    why: "{shown} shown, more exist"
-  }
-]);
-
-// node_modules/.pnpm/@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/failure.js
-var recognise = /* @__PURE__ */ __name((failure) => {
-  if (isCliError(failure))
-    return failure;
-  if (!(failure instanceof Error) || failure.name !== "CliError")
-    return void 0;
-  const { code, details } = failure;
-  if (!errorCodes.includes(code))
-    return void 0;
-  return {
-    code,
-    message: failure.message,
-    details: typeof details === "object" && details !== null ? details : {}
-  };
-}, "recognise");
-var reasonFor = /* @__PURE__ */ __name((code, named, reasons) => reasons.find((entry2) => entry2.reason === named && entry2.code === code) ?? BASE_REASONS.find((entry2) => entry2.reason === named && entry2.code === code) ?? // The first base reason for each code is its fallback.
-BASE_REASONS.find((entry2) => entry2.code === code), "reasonFor");
-var nextFor = /* @__PURE__ */ __name((reason, details, context) => {
-  const definition = reason.step ? context.steps?.find((step) => step.id === reason.step) : void 0;
-  if (!definition)
-    return [];
-  const known = new Set(definition.kind === "command" ? definition.args.map((arg) => arg.name) : []);
-  const args = Object.fromEntries(Object.entries(details).filter(([key, value]) => known.has(key) && value !== void 0));
-  try {
-    return [stepOf(definition, { args, ...context.targets ? { targets: context.targets } : {} })];
-  } catch {
-    return [];
-  }
-}, "nextFor");
-var TRANSIENT = [
-  "rate_limited",
-  "timeout",
-  "network_error",
-  "provider_unavailable"
-];
-var retryOf = /* @__PURE__ */ __name((code, details, effects) => {
-  const transient = details.retryable !== false && (TRANSIENT.includes(code) || code === "provider_error" && details.retryable === true);
-  const safe = code !== "outcome_unknown" && transient && (!writes(effects) || details.sent === false);
-  const after = details.retry_after_ms;
-  return safe && typeof after === "number" && Number.isInteger(after) && after >= 0 ? { safe, after_ms: after } : { safe };
-}, "retryOf");
-var errorObjectOf = /* @__PURE__ */ __name((failure, context = {}) => {
-  const reasons = context.reasons ?? [];
-  const recognised = recognise(failure);
-  if (!recognised) {
-    const reason2 = reasonFor(CRASH_CODE, CRASH_REASON, reasons);
-    return {
-      error: {
-        code: CRASH_CODE,
-        reason: reason2.reason,
-        message: reason2.message,
-        retry: { safe: false },
-        ...context.runId ? { run_id: context.runId } : {}
-      }
-    };
-  }
-  const { code, message, details } = recognised;
-  const reason = reasonFor(code, details.reason, reasons);
-  const allowed = /* @__PURE__ */ new Set([...COMMON_DETAILS, ...context.details ?? [], ...reason.details]);
-  allowed.delete("cause");
-  const kept = Object.fromEntries(Object.entries(details).filter(([key, value]) => allowed.has(key) && value !== void 0));
-  const next = nextFor(reason, details, context);
-  const runId = context.runId ?? (typeof details.run_id === "string" ? details.run_id : void 0);
-  return {
-    error: {
-      code,
-      reason: reason.reason,
-      message,
-      ...typeof details.param === "string" ? { param: details.param } : {},
-      ...Object.keys(kept).length > 0 ? { details: kept } : {},
-      ...next.length > 0 ? { next } : {},
-      retry: retryOf(code, details, context.effects),
-      ...runId ? { run_id: runId } : {}
-    }
-  };
-}, "errorObjectOf");
-var exitCodeOfError = /* @__PURE__ */ __name(({ error }) => error.code === CRASH_CODE ? GENERIC_FAILURE : EXIT_CODES[error.code], "exitCodeOfError");
-var exitCodeOfAnswer = /* @__PURE__ */ __name((meta, partial2 = false) => {
-  if (meta.complete || partial2)
-    return 0;
-  const code = meta.issues?.[0]?.code;
-  return code === void 0 ? GENERIC_FAILURE : EXIT_CODES[code];
-}, "exitCodeOfAnswer");
-var kebab = /* @__PURE__ */ __name((name) => name.replaceAll("_", "-"), "kebab");
-var commandLine = /* @__PURE__ */ __name((cli, step) => [
-  cli,
-  step.command,
-  ...Object.entries(step.args).map(([name, value]) => value === true ? `--${kebab(name)}` : `--${kebab(name)} ${JSON.stringify(value)}`)
-].join(" "), "commandLine");
-var STACK_FRAMES = 10;
-var errorRecordOf = /* @__PURE__ */ __name((failure, object3, options) => {
-  const thrown = failure instanceof Error ? failure : void 0;
-  const { cause, ...details } = recognise(failure)?.details ?? {};
-  const stack = thrown?.stack?.split("\n").slice(1, STACK_FRAMES + 1).map((line) => visibleControls(line.trim()));
-  const reason = thrown?.cause ?? cause;
-  return {
-    time: (options.time ?? /* @__PURE__ */ new Date()).toISOString(),
-    severity: "error",
-    body: "command.failed",
-    ...object3.error.run_id ? { run_id: object3.error.run_id } : {},
-    command: options.command,
-    attributes: {
-      code: object3.error.code,
-      reason: object3.error.reason,
-      message: object3.error.message,
-      ...Object.keys(details).length > 0 ? { details } : {},
-      ...thrown ? { name: thrown.name, thrown_message: visibleControls(thrown.message) } : { thrown: String(failure) },
-      ...reason === void 0 ? {} : { cause: visibleControls(reason instanceof Error ? reason.message : String(reason)) },
-      ...stack && stack.length > 0 ? { stack } : {}
-    },
-    resource: { service: options.service, version: options.version }
-  };
-}, "errorRecordOf");
-var renderError = /* @__PURE__ */ __name((object3, options) => {
-  if (!options.interactive)
-    return [JSON.stringify(object3), ...options.record ? [JSON.stringify(options.record)] : []].join("\n");
-  const { message, next, run_id: runId } = object3.error;
-  const step = next?.[0];
-  return [
-    `\u2717 ${visibleControls(message)}`,
-    ...step?.kind === "command" ? [`\u2192 ${visibleControls(step.why)}: ${visibleControls(step.line ?? commandLine(options.cli, step))}`] : step ? [`\u2192 ${visibleControls(step.why)}`] : [],
-    ...options.record ? [JSON.stringify(options.record, null, 2)] : runId ? [`details: ${options.cli} runs show ${runId}`] : []
-  ].join("\n");
-}, "renderError");
-var mcpErrorResult = /* @__PURE__ */ __name((object3) => ({
-  content: [{ type: "text", text: JSON.stringify(object3) }],
-  structuredContent: object3,
-  isError: true
-}), "mcpErrorResult");
-var catchCrashes = /* @__PURE__ */ __name((options) => {
-  const target = options.target ?? process;
-  const write = options.write ?? ((text2) => process.stderr.write(`${text2}
-`));
-  const exit = options.exit ?? ((code) => process.exit(code));
-  const crashed = /* @__PURE__ */ __name((failure) => {
-    const object3 = errorObjectOf(failure, options);
-    write(renderError(object3, { cli: options.cli, interactive: options.interactive }));
-    exit(exitCodeOfError(object3));
-  }, "crashed");
-  target.on("uncaughtException", crashed);
-  target.on("unhandledRejection", crashed);
-  return () => {
-    target.off("uncaughtException", crashed);
-    target.off("unhandledRejection", crashed);
-  };
-}, "catchCrashes");
-
 // node_modules/.pnpm/@wirecat+cli-base@0.75.0_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/paths.js
 import { homedir, userInfo } from "node:os";
 import { join, posix, win32 } from "node:path";
@@ -4501,14 +2138,14 @@ var fieldsOf = /* @__PURE__ */ __name((value) => {
   validate(paths);
   return [...new Set(paths)];
 }, "fieldsOf");
-var object2 = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value), "object");
+var object = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object" && !Array.isArray(value), "object");
 var retained = /* @__PURE__ */ new Set(["operation_id", "page", "next", "missing", "meta", "coverage"]);
 var itemPaths = /* @__PURE__ */ __name((paths) => paths.map((path) => path.startsWith("items.") ? path.slice(6) : path), "itemPaths");
 var onePaths = /* @__PURE__ */ __name((paths) => paths.map((path) => path.startsWith("item.") ? path.slice(5) : path), "onePaths");
 var select = /* @__PURE__ */ __name((value, paths) => {
   if (Array.isArray(value))
     return value.map((item) => select(item, paths));
-  if (!object2(value))
+  if (!object(value))
     return value;
   const result = {};
   const groups = /* @__PURE__ */ new Map();
@@ -4526,9 +2163,9 @@ var select = /* @__PURE__ */ __name((value, paths) => {
     const found = value[key];
     if (children.includes(""))
       result[key] = found;
-    else if (object2(found) || Array.isArray(found)) {
+    else if (object(found) || Array.isArray(found)) {
       const selected = select(found, children);
-      if (Array.isArray(selected) || object2(selected) && Object.keys(selected).length > 0)
+      if (Array.isArray(selected) || object(selected) && Object.keys(selected).length > 0)
         result[key] = selected;
     }
   }
@@ -4540,15 +2177,15 @@ var select = /* @__PURE__ */ __name((value, paths) => {
 var project = /* @__PURE__ */ __name((value, fields) => {
   if (Array.isArray(value))
     return value.map((item) => select(item, itemPaths(fields)));
-  if (object2(value) && Object.hasOwn(value, "type") && value.type === "item" && Object.hasOwn(value, "data") && Object.keys(value).every((key) => ["type", "data"].includes(key)))
+  if (object(value) && Object.hasOwn(value, "type") && value.type === "item" && Object.hasOwn(value, "data") && Object.keys(value).every((key) => ["type", "data"].includes(key)))
     return { ...value, data: project(value.data, fields) };
-  if (object2(value) && Object.hasOwn(value, "type") && value.type === "end" && Object.hasOwn(value, "complete") && typeof value.complete === "boolean")
+  if (object(value) && Object.hasOwn(value, "type") && value.type === "end" && Object.hasOwn(value, "complete") && typeof value.complete === "boolean")
     return value;
-  if (object2(value) && Object.hasOwn(value, "item") && (Object.hasOwn(value, "meta") || Object.keys(value).every((key) => ["item", "next", "missing"].includes(key))))
+  if (object(value) && Object.hasOwn(value, "item") && (Object.hasOwn(value, "meta") || Object.keys(value).every((key) => ["item", "next", "missing"].includes(key))))
     return { ...value, item: project(value.item, onePaths(fields)) };
-  if (object2(value) && Array.isArray(value.items))
+  if (object(value) && Array.isArray(value.items))
     return { ...value, items: value.items.map((item) => select(item, itemPaths(fields))) };
-  return select(value, object2(value) && !Object.hasOwn(value, "items") ? itemPaths(fields) : fields);
+  return select(value, object(value) && !Object.hasOwn(value, "items") ? itemPaths(fields) : fields);
 }, "project");
 var projectFields = /* @__PURE__ */ __name((value, fields) => {
   validate(fields);
@@ -4567,7 +2204,7 @@ function invalid(message) {
   throw new CliError("validation_error", message);
 }
 __name(invalid, "invalid");
-var limit2 = /* @__PURE__ */ __name((value, maximum, name) => {
+var limit = /* @__PURE__ */ __name((value, maximum, name) => {
   if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
     invalid(`invalid batch ${name} limit`);
   return value;
@@ -4591,13 +2228,13 @@ var prepareBatch = /* @__PURE__ */ __name((input, handlers) => {
     invalid("batch takes 1\u201332 requests");
   const ids = /* @__PURE__ */ new Set();
   return requests.map((request) => {
-    if (!record2(request) || Object.keys(request).some((key) => !["id", "command", "args"].includes(key)) || typeof request.id !== "string" || !/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,63}$/.test(request.id) || ids.has(request.id) || !Array.isArray(request.command) || request.command.length < 1 || request.command.length > 8 || request.command.some((word2) => typeof word2 !== "string" || !/^[a-z][a-z0-9-]{0,63}$/.test(word2)) || !Array.isArray(request.args) || request.args.length > 128 || request.args.some((arg) => typeof arg !== "string" || arg.includes("\0")))
+    if (!record2(request) || Object.keys(request).some((key) => !["id", "command", "args"].includes(key)) || typeof request.id !== "string" || !/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,63}$/.test(request.id) || ids.has(request.id) || !Array.isArray(request.command) || request.command.length < 1 || request.command.length > 8 || request.command.some((word) => typeof word !== "string" || !/^[a-z][a-z0-9-]{0,63}$/.test(word)) || !Array.isArray(request.args) || request.args.length > 128 || request.args.some((arg) => typeof arg !== "string" || arg.includes("\0")))
       invalid("each batch request needs a unique id, registered command path and string args array");
     const id = request.id;
     const command = [...request.command];
     const args = request.args;
     ids.add(id);
-    const handler = handlers.find((entry2) => entry2.command.length === command.length && entry2.command.every((word2, i) => word2 === command[i]));
+    const handler = handlers.find((entry2) => entry2.command.length === command.length && entry2.command.every((word, i) => word === command[i]));
     if (!handler)
       invalid(`unsupported batch command: ${command.join(" ")}`);
     return { id, command, operation: handler.prepare(args) };
@@ -4628,15 +2265,15 @@ var runBatch = /* @__PURE__ */ __name(async (requests, options = {}) => {
     invalid("batch takes 1\u201332 requests");
   if (options.fields)
     projectFields({}, options.fields);
-  const maxReadBytes = limit2(options.maxReadBytes ?? BATCH_LIMITS.read_bytes, BATCH_LIMITS.read_bytes, "read");
-  const maxOutputBytes = limit2(options.maxOutputBytes ?? BATCH_LIMITS.output_bytes, BATCH_LIMITS.output_bytes, "output");
+  const maxReadBytes = limit(options.maxReadBytes ?? BATCH_LIMITS.read_bytes, BATCH_LIMITS.read_bytes, "read");
+  const maxOutputBytes = limit(options.maxOutputBytes ?? BATCH_LIMITS.output_bytes, BATCH_LIMITS.output_bytes, "output");
   if (maxOutputBytes < 8192 + requests.length * 2048)
     invalid("batch output budget cannot hold its result framing");
   const errorOf = /* @__PURE__ */ __name((error) => {
-    const object3 = errorObjectOf(error, options.failureContext).error;
+    const object2 = errorObjectOf(error, options.failureContext).error;
     try {
-      if (Buffer.byteLength(JSON.stringify(object3), "utf8") <= 512)
-        return object3;
+      if (Buffer.byteLength(JSON.stringify(object2), "utf8") <= 512)
+        return object2;
     } catch {
     }
     const fallback = errorObjectOf(error).error;
@@ -4652,7 +2289,7 @@ var runBatch = /* @__PURE__ */ __name(async (requests, options = {}) => {
   const context = {
     signal: options.signal,
     reserveReadBytes(bytes) {
-      limit2(bytes, BATCH_LIMITS.read_bytes, "operation read");
+      limit(bytes, BATCH_LIMITS.read_bytes, "operation read");
       if (bytes > maxReadBytes - reserved)
         throw budgetError("read");
       reserved += bytes;
@@ -4681,11 +2318,11 @@ var runBatch = /* @__PURE__ */ __name(async (requests, options = {}) => {
         }
       } catch (error) {
         options.signal?.throwIfAborted();
-        const object3 = errorOf(error);
+        const object2 = errorOf(error);
         result = {
           ...framing,
-          status: object3.reason === "batch.read-budget" ? "not_run" : "error",
-          error: object3,
+          status: object2.reason === "batch.read-budget" ? "not_run" : "error",
+          error: object2,
           complete: false
         };
       }
@@ -4828,12 +2465,12 @@ var Credentials = class {
         return "keyring";
       }
     }
-    const store2 = this.#readFile();
-    if (!store2) {
+    const store = this.#readFile();
+    if (!store) {
       throw new CliError("configuration_error", `${this.#path()} cannot be read as a credentials file; storing now would replace every secret in it. Fix the file or move it aside, then try again.`);
     }
-    store2[account] = { secret };
-    this.#writeFile(store2);
+    store[account] = { secret };
+    this.#writeFile(store);
     return "file";
   }
   remove(account) {
@@ -4851,11 +2488,11 @@ var Credentials = class {
     return removed;
   }
   #removeFromFile(account) {
-    const store2 = this.#readFile();
-    if (store2?.[account] === void 0)
+    const store = this.#readFile();
+    if (store?.[account] === void 0)
       return false;
-    delete store2[account];
-    this.#writeFile(store2);
+    delete store[account];
+    this.#writeFile(store);
     return true;
   }
   /** Only for the warning: a keyring that fails here must not fail a removal that already happened. */
@@ -4886,8 +2523,8 @@ var Credentials = class {
       return void 0;
     }
   }
-  #writeFile(store2) {
-    writeSecurely(this.#path(), `${JSON.stringify(store2, null, 2)}
+  #writeFile(store) {
+    writeSecurely(this.#path(), `${JSON.stringify(store, null, 2)}
 `, 384);
   }
   #tryKeyring(operation) {
@@ -5064,10 +2701,10 @@ var CONTENT_WORDS = /* @__PURE__ */ new Set([
   "token"
 ]);
 var CONTENT_LAST_WORDS = /* @__PURE__ */ new Set(["message", "name"]);
-var wordsOf = /* @__PURE__ */ __name((key) => key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_.-]+/).filter(Boolean).map((word2) => word2.toLowerCase()), "wordsOf");
+var wordsOf = /* @__PURE__ */ __name((key) => key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_.-]+/).filter(Boolean).map((word) => word.toLowerCase()), "wordsOf");
 var isContentKey = /* @__PURE__ */ __name((key) => {
   const words = wordsOf(key);
-  return words.some((word2) => CONTENT_WORDS.has(word2)) || CONTENT_LAST_WORDS.has(words.at(-1) ?? "");
+  return words.some((word) => CONTENT_WORDS.has(word)) || CONTENT_LAST_WORDS.has(words.at(-1) ?? "");
 }, "isContentKey");
 var TRACEPARENT = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(-.*)?$/;
 var traceIdOf = /* @__PURE__ */ __name((traceparent) => {
@@ -5179,90 +2816,6 @@ var silent = {
 };
 
 export {
-  errorCodes,
-  CliError,
-  isCliError,
-  EXIT_CODES,
-  exitCodeFor,
-  GENERIC_FAILURE,
-  visibleControls,
-  singleLine,
-  getDotPath,
-  ValiError,
-  check,
-  description,
-  finite,
-  integer,
-  isoDate,
-  isoTimestamp,
-  maxLength,
-  maxValue,
-  minLength,
-  minValue,
-  nonEmpty,
-  regex,
-  safeInteger,
-  transform,
-  trim,
-  forward,
-  array,
-  boolean,
-  lazy,
-  literal,
-  looseObject,
-  null_,
-  nullable,
-  number,
-  object,
-  objectWithRest,
-  optional,
-  picklist,
-  record,
-  strictObject,
-  string,
-  union,
-  unknown,
-  variant,
-  omit,
-  parse,
-  partial,
-  pick,
-  pipe,
-  safeParse,
-  summarize,
-  unwrap,
-  effectsSchema,
-  writes,
-  toJsonSchema,
-  toStandardJsonSchema,
-  word,
-  SNAKE_CASE,
-  text,
-  RegistryError,
-  parseRegistry,
-  duplicates,
-  jsonSchemaOf,
-  MAX_NEXT_STEPS,
-  COMPACT_FLAG,
-  isoTime,
-  reference,
-  pageSchema,
-  listEnvelopeSchema,
-  itemEnvelopeSchema,
-  jsonlOf,
-  CRASH_CODE,
-  errorObjectSchema,
-  defineReasons,
-  defineSteps,
-  stepOf,
-  STEPS,
-  errorObjectOf,
-  exitCodeOfError,
-  exitCodeOfAnswer,
-  errorRecordOf,
-  renderError,
-  mcpErrorResult,
-  catchCrashes,
   fieldsOf,
   projectFields,
   BATCH_LIMITS,