@wirecat/mail-cli 0.0.0-stage → 0.1.0

package/dist/bundle/chunk-LQ37ALDJ.js

@@ -0,0 +1,2416 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  errorCodes,
+  isCliError,
+  visibleControls
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_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/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/@wirecat+cli-base@0.68.1_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/@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 entry = valibotSchema.entries[key];
+        jsonSchema.properties[key] = convertSchema({}, entry, config, context);
+        if (entry.type !== "exact_optional" && entry.type !== "nullish" && entry.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.68.1_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.68.1_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 isoTime = pipe(string(), isoTimestamp("an ISO 8601 time in UTC"), endsWith("Z", "an ISO 8601 time in UTC, ending in `Z`"));
+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),
+  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.68.1_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((entry) => entry.reason)).map((reason) => `"${reason}" is listed twice`),
+  ...reasons.flatMap((entry) => placeholders(entry.message).filter((name) => !entry.details.includes(name)).map((name) => `${entry.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.68.1_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((entry) => ["string", "number"].includes(typeof entry[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.68.1_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((entry) => entry.reason === named && entry.code === code) ?? BASE_REASONS.find((entry) => entry.reason === named && entry.code === code) ?? // The first base reason for each code is its fallback.
+BASE_REASONS.find((entry) => entry.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, object2, 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",
+    ...object2.error.run_id ? { run_id: object2.error.run_id } : {},
+    command: options.command,
+    attributes: {
+      code: object2.error.code,
+      reason: object2.error.reason,
+      message: object2.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((object2, options) => {
+  if (!options.interactive)
+    return [JSON.stringify(object2), ...options.record ? [JSON.stringify(options.record)] : []].join("\n");
+  const { message, next, run_id: runId } = object2.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((object2) => ({
+  content: [{ type: "text", text: JSON.stringify(object2) }],
+  structuredContent: object2,
+  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 object2 = errorObjectOf(failure, options);
+    write(renderError(object2, { cli: options.cli, interactive: options.interactive }));
+    exit(exitCodeOfError(object2));
+  }, "crashed");
+  target.on("uncaughtException", crashed);
+  target.on("unhandledRejection", crashed);
+  return () => {
+    target.off("uncaughtException", crashed);
+    target.off("unhandledRejection", crashed);
+  };
+}, "catchCrashes");
+
+export {
+  EXIT_CODES,
+  exitCodeFor,
+  GENERIC_FAILURE,
+  getDotPath,
+  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,
+  dottedId,
+  RegistryError,
+  parseRegistry,
+  duplicates,
+  jsonSchemaOf,
+  MAX_NEXT_STEPS,
+  isoTime,
+  reference,
+  pageSchema,
+  listEnvelopeSchema,
+  itemEnvelopeSchema,
+  jsonlOf,
+  CRASH_CODE,
+  errorObjectSchema,
+  defineReasons,
+  defineSteps,
+  stepOf,
+  STEPS,
+  retryOf,
+  errorObjectOf,
+  exitCodeOfError,
+  exitCodeOfAnswer,
+  errorRecordOf,
+  renderError,
+  mcpErrorResult,
+  catchCrashes
+};