@jeffreyjyz/opencode-command-code 0.2.9 → 0.3.0

package/dist/index.js

@@ -1,7 +1,2416 @@
 // @bun
-// src/index.ts
-import { tool } from "@opencode-ai/plugin";
+// node_modules/zod/v4/core/core.js
+var NEVER = Object.freeze({
+  status: "aborted"
+});
+function $constructor(name, initializer, params) {
+  function init(inst, def) {
+    var _a;
+    Object.defineProperty(inst, "_zod", {
+      value: inst._zod ?? {},
+      enumerable: false
+    });
+    (_a = inst._zod).traits ?? (_a.traits = new Set);
+    inst._zod.traits.add(name);
+    initializer(inst, def);
+    for (const k in _.prototype) {
+      if (!(k in inst))
+        Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+    }
+    inst._zod.constr = _;
+    inst._zod.def = def;
+  }
+  const Parent = params?.Parent ?? Object;
+
+  class Definition extends Parent {
+  }
+  Object.defineProperty(Definition, "name", { value: name });
+  function _(def) {
+    var _a;
+    const inst = params?.Parent ? new Definition : this;
+    init(inst, def);
+    (_a = inst._zod).deferred ?? (_a.deferred = []);
+    for (const fn of inst._zod.deferred) {
+      fn();
+    }
+    return inst;
+  }
+  Object.defineProperty(_, "init", { value: init });
+  Object.defineProperty(_, Symbol.hasInstance, {
+    value: (inst) => {
+      if (params?.Parent && inst instanceof params.Parent)
+        return true;
+      return inst?._zod?.traits?.has(name);
+    }
+  });
+  Object.defineProperty(_, "name", { value: name });
+  return _;
+}
+var $brand = Symbol("zod_brand");
+
+class $ZodAsyncError extends Error {
+  constructor() {
+    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+  }
+}
+
+class $ZodEncodeError extends Error {
+  constructor(name) {
+    super(`Encountered unidirectional transform during encode: ${name}`);
+    this.name = "ZodEncodeError";
+  }
+}
+var globalConfig = {};
+function config(newConfig) {
+  if (newConfig)
+    Object.assign(globalConfig, newConfig);
+  return globalConfig;
+}
+// node_modules/zod/v4/core/util.js
+function jsonStringifyReplacer(_, value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  return value;
+}
+function cached(getter) {
+  const set = false;
+  return {
+    get value() {
+      if (!set) {
+        const value = getter();
+        Object.defineProperty(this, "value", { value });
+        return value;
+      }
+      throw new Error("cached value already set");
+    }
+  };
+}
+function nullish(input) {
+  return input === null || input === undefined;
+}
+function cleanRegex(source) {
+  const start = source.startsWith("^") ? 1 : 0;
+  const end = source.endsWith("$") ? source.length - 1 : source.length;
+  return source.slice(start, end);
+}
+var EVALUATING = Symbol("evaluating");
+function defineLazy(object, key, getter) {
+  let value = undefined;
+  Object.defineProperty(object, key, {
+    get() {
+      if (value === EVALUATING) {
+        return;
+      }
+      if (value === undefined) {
+        value = EVALUATING;
+        value = getter();
+      }
+      return value;
+    },
+    set(v) {
+      Object.defineProperty(object, key, {
+        value: v
+      });
+    },
+    configurable: true
+  });
+}
+var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
+function isObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+var allowsEval = cached(() => {
+  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
+    return false;
+  }
+  try {
+    const F = Function;
+    new F("");
+    return true;
+  } catch (_) {
+    return false;
+  }
+});
+function isPlainObject(o) {
+  if (isObject(o) === false)
+    return false;
+  const ctor = o.constructor;
+  if (ctor === undefined)
+    return true;
+  const prot = ctor.prototype;
+  if (isObject(prot) === false)
+    return false;
+  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
+    return false;
+  }
+  return true;
+}
+function shallowClone(o) {
+  if (isPlainObject(o))
+    return { ...o };
+  if (Array.isArray(o))
+    return [...o];
+  return o;
+}
+var propertyKeyTypes = new Set(["string", "number", "symbol"]);
+var primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function clone(inst, def, params) {
+  const cl = new inst._zod.constr(def ?? inst._zod.def);
+  if (!def || params?.parent)
+    cl._zod.parent = inst;
+  return cl;
+}
+function normalizeParams(_params) {
+  const params = _params;
+  if (!params)
+    return {};
+  if (typeof params === "string")
+    return { error: () => params };
+  if (params?.message !== undefined) {
+    if (params?.error !== undefined)
+      throw new Error("Cannot specify both `message` and `error` params");
+    params.error = params.message;
+  }
+  delete params.message;
+  if (typeof params.error === "string")
+    return { ...params, error: () => params.error };
+  return params;
+}
+var NUMBER_FORMAT_RANGES = {
+  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+  int32: [-2147483648, 2147483647],
+  uint32: [0, 4294967295],
+  float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
+  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+};
+function aborted(x, startIndex = 0) {
+  if (x.aborted === true)
+    return true;
+  for (let i = startIndex;i < x.issues.length; i++) {
+    if (x.issues[i]?.continue !== true) {
+      return true;
+    }
+  }
+  return false;
+}
+function prefixIssues(path, issues) {
+  return issues.map((iss) => {
+    var _a;
+    (_a = iss).path ?? (_a.path = []);
+    iss.path.unshift(path);
+    return iss;
+  });
+}
+function unwrapMessage(message) {
+  return typeof message === "string" ? message : message?.message;
+}
+function finalizeIssue(iss, ctx, config) {
+  const full = { ...iss, path: iss.path ?? [] };
+  if (!iss.message) {
+    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
+    full.message = message;
+  }
+  delete full.inst;
+  delete full.continue;
+  if (!ctx?.reportInput) {
+    delete full.input;
+  }
+  return full;
+}
+function getLengthableOrigin(input) {
+  if (Array.isArray(input))
+    return "array";
+  if (typeof input === "string")
+    return "string";
+  return "unknown";
+}
+function issue(...args) {
+  const [iss, input, inst] = args;
+  if (typeof iss === "string") {
+    return {
+      message: iss,
+      code: "custom",
+      input,
+      inst
+    };
+  }
+  return { ...iss };
+}
+
+// node_modules/zod/v4/core/errors.js
+var initializer = (inst, def) => {
+  inst.name = "$ZodError";
+  Object.defineProperty(inst, "_zod", {
+    value: inst._zod,
+    enumerable: false
+  });
+  Object.defineProperty(inst, "issues", {
+    value: def,
+    enumerable: false
+  });
+  inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
+  Object.defineProperty(inst, "toString", {
+    value: () => inst.message,
+    enumerable: false
+  });
+};
+var $ZodError = $constructor("$ZodError", initializer);
+var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+function flattenError(error, mapper = (issue) => issue.message) {
+  const fieldErrors = {};
+  const formErrors = [];
+  for (const sub of error.issues) {
+    if (sub.path.length > 0) {
+      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+      fieldErrors[sub.path[0]].push(mapper(sub));
+    } else {
+      formErrors.push(mapper(sub));
+    }
+  }
+  return { formErrors, fieldErrors };
+}
+function formatError(error, _mapper) {
+  const mapper = _mapper || function(issue) {
+    return issue.message;
+  };
+  const fieldErrors = { _errors: [] };
+  const processError = (error) => {
+    for (const issue of error.issues) {
+      if (issue.code === "invalid_union" && issue.errors.length) {
+        issue.errors.map((issues) => processError({ issues }));
+      } else if (issue.code === "invalid_key") {
+        processError({ issues: issue.issues });
+      } else if (issue.code === "invalid_element") {
+        processError({ issues: issue.issues });
+      } else if (issue.path.length === 0) {
+        fieldErrors._errors.push(mapper(issue));
+      } else {
+        let curr = fieldErrors;
+        let i = 0;
+        while (i < issue.path.length) {
+          const el = issue.path[i];
+          const terminal = i === issue.path.length - 1;
+          if (!terminal) {
+            curr[el] = curr[el] || { _errors: [] };
+          } else {
+            curr[el] = curr[el] || { _errors: [] };
+            curr[el]._errors.push(mapper(issue));
+          }
+          curr = curr[el];
+          i++;
+        }
+      }
+    }
+  };
+  processError(error);
+  return fieldErrors;
+}
+
+// node_modules/zod/v4/core/parse.js
+var _parse = (_Err) => (schema, value, _ctx, _params) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError;
+  }
+  if (result.issues.length) {
+    const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+    captureStackTrace(e, _params?.callee);
+    throw e;
+  }
+  return result.value;
+};
+var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  if (result.issues.length) {
+    const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+    captureStackTrace(e, params?.callee);
+    throw e;
+  }
+  return result.value;
+};
+var _safeParse = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError;
+  }
+  return result.issues.length ? {
+    success: false,
+    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+};
+var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
+var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  return result.issues.length ? {
+    success: false,
+    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+};
+var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+var _encode = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+  return _parse(_Err)(schema, value, ctx);
+};
+var _decode = (_Err) => (schema, value, _ctx) => {
+  return _parse(_Err)(schema, value, _ctx);
+};
+var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+  return _parseAsync(_Err)(schema, value, ctx);
+};
+var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
+  return _parseAsync(_Err)(schema, value, _ctx);
+};
+var _safeEncode = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+  return _safeParse(_Err)(schema, value, ctx);
+};
+var _safeDecode = (_Err) => (schema, value, _ctx) => {
+  return _safeParse(_Err)(schema, value, _ctx);
+};
+var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
+  return _safeParseAsync(_Err)(schema, value, ctx);
+};
+var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
+  return _safeParseAsync(_Err)(schema, value, _ctx);
+};
+// node_modules/zod/v4/core/regexes.js
+var cuid = /^[cC][^\s-]{8,}$/;
+var cuid2 = /^[0-9a-z]+$/;
+var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
+var xid = /^[0-9a-vA-V]{20}$/;
+var ksuid = /^[A-Za-z0-9]{27}$/;
+var nanoid = /^[a-zA-Z0-9_-]{21}$/;
+var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
+var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
+var uuid = (version) => {
+  if (!version)
+    return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
+  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+};
+var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
+var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+function emoji() {
+  return new RegExp(_emoji, "u");
+}
+var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
+var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
+var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
+var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
+var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
+var base64url = /^[A-Za-z0-9_-]*$/;
+var hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
+var e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
+var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
+var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
+function timeSource(args) {
+  const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
+  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+  return regex;
+}
+function time(args) {
+  return new RegExp(`^${timeSource(args)}$`);
+}
+function datetime(args) {
+  const time = timeSource({ precision: args.precision });
+  const opts = ["Z"];
+  if (args.local)
+    opts.push("");
+  if (args.offset)
+    opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
+  const timeRegex = `${time}(?:${opts.join("|")})`;
+  return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
+}
+var string = (params) => {
+  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+  return new RegExp(`^${regex}$`);
+};
+var lowercase = /^[^A-Z]*$/;
+var uppercase = /^[^a-z]*$/;
+
+// node_modules/zod/v4/core/checks.js
+var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
+  var _a;
+  inst._zod ?? (inst._zod = {});
+  inst._zod.def = def;
+  (_a = inst._zod).onattach ?? (_a.onattach = []);
+});
+var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  (_a = inst._zod.def).when ?? (_a.when = (payload) => {
+    const val = payload.value;
+    return !nullish(val) && val.length !== undefined;
+  });
+  inst._zod.onattach.push((inst) => {
+    const curr = inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
+    if (def.maximum < curr)
+      inst._zod.bag.maximum = def.maximum;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const length = input.length;
+    if (length <= def.maximum)
+      return;
+    const origin = getLengthableOrigin(input);
+    payload.issues.push({
+      origin,
+      code: "too_big",
+      maximum: def.maximum,
+      inclusive: true,
+      input,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  (_a = inst._zod.def).when ?? (_a.when = (payload) => {
+    const val = payload.value;
+    return !nullish(val) && val.length !== undefined;
+  });
+  inst._zod.onattach.push((inst) => {
+    const curr = inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
+    if (def.minimum > curr)
+      inst._zod.bag.minimum = def.minimum;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const length = input.length;
+    if (length >= def.minimum)
+      return;
+    const origin = getLengthableOrigin(input);
+    payload.issues.push({
+      origin,
+      code: "too_small",
+      minimum: def.minimum,
+      inclusive: true,
+      input,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  (_a = inst._zod.def).when ?? (_a.when = (payload) => {
+    const val = payload.value;
+    return !nullish(val) && val.length !== undefined;
+  });
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    bag.minimum = def.length;
+    bag.maximum = def.length;
+    bag.length = def.length;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const length = input.length;
+    if (length === def.length)
+      return;
+    const origin = getLengthableOrigin(input);
+    const tooBig = length > def.length;
+    payload.issues.push({
+      origin,
+      ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
+      inclusive: true,
+      exact: true,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
+  var _a, _b;
+  $ZodCheck.init(inst, def);
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    bag.format = def.format;
+    if (def.pattern) {
+      bag.patterns ?? (bag.patterns = new Set);
+      bag.patterns.add(def.pattern);
+    }
+  });
+  if (def.pattern)
+    (_a = inst._zod).check ?? (_a.check = (payload) => {
+      def.pattern.lastIndex = 0;
+      if (def.pattern.test(payload.value))
+        return;
+      payload.issues.push({
+        origin: "string",
+        code: "invalid_format",
+        format: def.format,
+        input: payload.value,
+        ...def.pattern ? { pattern: def.pattern.toString() } : {},
+        inst,
+        continue: !def.abort
+      });
+    });
+  else
+    (_b = inst._zod).check ?? (_b.check = () => {});
+});
+var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
+  $ZodCheckStringFormat.init(inst, def);
+  inst._zod.check = (payload) => {
+    def.pattern.lastIndex = 0;
+    if (def.pattern.test(payload.value))
+      return;
+    payload.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "regex",
+      input: payload.value,
+      pattern: def.pattern.toString(),
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
+  def.pattern ?? (def.pattern = lowercase);
+  $ZodCheckStringFormat.init(inst, def);
+});
+var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
+  def.pattern ?? (def.pattern = uppercase);
+  $ZodCheckStringFormat.init(inst, def);
+});
+var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const escapedRegex = escapeRegex(def.includes);
+  const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
+  def.pattern = pattern;
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    bag.patterns ?? (bag.patterns = new Set);
+    bag.patterns.add(pattern);
+  });
+  inst._zod.check = (payload) => {
+    if (payload.value.includes(def.includes, def.position))
+      return;
+    payload.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "includes",
+      includes: def.includes,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
+  def.pattern ?? (def.pattern = pattern);
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    bag.patterns ?? (bag.patterns = new Set);
+    bag.patterns.add(pattern);
+  });
+  inst._zod.check = (payload) => {
+    if (payload.value.startsWith(def.prefix))
+      return;
+    payload.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "starts_with",
+      prefix: def.prefix,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
+  def.pattern ?? (def.pattern = pattern);
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    bag.patterns ?? (bag.patterns = new Set);
+    bag.patterns.add(pattern);
+  });
+  inst._zod.check = (payload) => {
+    if (payload.value.endsWith(def.suffix))
+      return;
+    payload.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "ends_with",
+      suffix: def.suffix,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.check = (payload) => {
+    payload.value = def.tx(payload.value);
+  };
+});
+
+// node_modules/zod/v4/core/versions.js
+var version = {
+  major: 4,
+  minor: 1,
+  patch: 8
+};
+
+// node_modules/zod/v4/core/schemas.js
+var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
+  var _a;
+  inst ?? (inst = {});
+  inst._zod.def = def;
+  inst._zod.bag = inst._zod.bag || {};
+  inst._zod.version = version;
+  const checks = [...inst._zod.def.checks ?? []];
+  if (inst._zod.traits.has("$ZodCheck")) {
+    checks.unshift(inst);
+  }
+  for (const ch of checks) {
+    for (const fn of ch._zod.onattach) {
+      fn(inst);
+    }
+  }
+  if (checks.length === 0) {
+    (_a = inst._zod).deferred ?? (_a.deferred = []);
+    inst._zod.deferred?.push(() => {
+      inst._zod.run = inst._zod.parse;
+    });
+  } else {
+    const runChecks = (payload, checks, ctx) => {
+      let isAborted = aborted(payload);
+      let asyncResult;
+      for (const ch of checks) {
+        if (ch._zod.def.when) {
+          const shouldRun = ch._zod.def.when(payload);
+          if (!shouldRun)
+            continue;
+        } else if (isAborted) {
+          continue;
+        }
+        const currLen = payload.issues.length;
+        const _ = ch._zod.check(payload);
+        if (_ instanceof Promise && ctx?.async === false) {
+          throw new $ZodAsyncError;
+        }
+        if (asyncResult || _ instanceof Promise) {
+          asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
+            await _;
+            const nextLen = payload.issues.length;
+            if (nextLen === currLen)
+              return;
+            if (!isAborted)
+              isAborted = aborted(payload, currLen);
+          });
+        } else {
+          const nextLen = payload.issues.length;
+          if (nextLen === currLen)
+            continue;
+          if (!isAborted)
+            isAborted = aborted(payload, currLen);
+        }
+      }
+      if (asyncResult) {
+        return asyncResult.then(() => {
+          return payload;
+        });
+      }
+      return payload;
+    };
+    const handleCanaryResult = (canary, payload, ctx) => {
+      if (aborted(canary)) {
+        canary.aborted = true;
+        return canary;
+      }
+      const checkResult = runChecks(payload, checks, ctx);
+      if (checkResult instanceof Promise) {
+        if (ctx.async === false)
+          throw new $ZodAsyncError;
+        return checkResult.then((checkResult) => inst._zod.parse(checkResult, ctx));
+      }
+      return inst._zod.parse(checkResult, ctx);
+    };
+    inst._zod.run = (payload, ctx) => {
+      if (ctx.skipChecks) {
+        return inst._zod.parse(payload, ctx);
+      }
+      if (ctx.direction === "backward") {
+        const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
+        if (canary instanceof Promise) {
+          return canary.then((canary) => {
+            return handleCanaryResult(canary, payload, ctx);
+          });
+        }
+        return handleCanaryResult(canary, payload, ctx);
+      }
+      const result = inst._zod.parse(payload, ctx);
+      if (result instanceof Promise) {
+        if (ctx.async === false)
+          throw new $ZodAsyncError;
+        return result.then((result) => runChecks(result, checks, ctx));
+      }
+      return runChecks(result, checks, ctx);
+    };
+  }
+  inst["~standard"] = {
+    validate: (value) => {
+      try {
+        const r = safeParse(inst, value);
+        return r.success ? { value: r.data } : { issues: r.error?.issues };
+      } catch (_) {
+        return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
+      }
+    },
+    vendor: "zod",
+    version: 1
+  };
+});
+var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
+  inst._zod.parse = (payload, _) => {
+    if (def.coerce)
+      try {
+        payload.value = String(payload.value);
+      } catch (_) {}
+    if (typeof payload.value === "string")
+      return payload;
+    payload.issues.push({
+      expected: "string",
+      code: "invalid_type",
+      input: payload.value,
+      inst
+    });
+    return payload;
+  };
+});
+var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
+  $ZodCheckStringFormat.init(inst, def);
+  $ZodString.init(inst, def);
+});
+var $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => {
+  def.pattern ?? (def.pattern = guid);
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
+  if (def.version) {
+    const versionMap = {
+      v1: 1,
+      v2: 2,
+      v3: 3,
+      v4: 4,
+      v5: 5,
+      v6: 6,
+      v7: 7,
+      v8: 8
+    };
+    const v = versionMap[def.version];
+    if (v === undefined)
+      throw new Error(`Invalid UUID version: "${def.version}"`);
+    def.pattern ?? (def.pattern = uuid(v));
+  } else
+    def.pattern ?? (def.pattern = uuid());
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => {
+  def.pattern ?? (def.pattern = email);
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
+  $ZodStringFormat.init(inst, def);
+  inst._zod.check = (payload) => {
+    try {
+      const trimmed = payload.value.trim();
+      const url = new URL(trimmed);
+      if (def.hostname) {
+        def.hostname.lastIndex = 0;
+        if (!def.hostname.test(url.hostname)) {
+          payload.issues.push({
+            code: "invalid_format",
+            format: "url",
+            note: "Invalid hostname",
+            pattern: hostname.source,
+            input: payload.value,
+            inst,
+            continue: !def.abort
+          });
+        }
+      }
+      if (def.protocol) {
+        def.protocol.lastIndex = 0;
+        if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
+          payload.issues.push({
+            code: "invalid_format",
+            format: "url",
+            note: "Invalid protocol",
+            pattern: def.protocol.source,
+            input: payload.value,
+            inst,
+            continue: !def.abort
+          });
+        }
+      }
+      if (def.normalize) {
+        payload.value = url.href;
+      } else {
+        payload.value = trimmed;
+      }
+      return;
+    } catch (_) {
+      payload.issues.push({
+        code: "invalid_format",
+        format: "url",
+        input: payload.value,
+        inst,
+        continue: !def.abort
+      });
+    }
+  };
+});
+var $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => {
+  def.pattern ?? (def.pattern = emoji());
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
+  def.pattern ?? (def.pattern = nanoid);
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
+  def.pattern ?? (def.pattern = cuid);
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => {
+  def.pattern ?? (def.pattern = cuid2);
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => {
+  def.pattern ?? (def.pattern = ulid);
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => {
+  def.pattern ?? (def.pattern = xid);
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => {
+  def.pattern ?? (def.pattern = ksuid);
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
+  def.pattern ?? (def.pattern = datetime(def));
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
+  def.pattern ?? (def.pattern = date);
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
+  def.pattern ?? (def.pattern = time(def));
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
+  def.pattern ?? (def.pattern = duration);
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
+  def.pattern ?? (def.pattern = ipv4);
+  $ZodStringFormat.init(inst, def);
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    bag.format = `ipv4`;
+  });
+});
+var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
+  def.pattern ?? (def.pattern = ipv6);
+  $ZodStringFormat.init(inst, def);
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    bag.format = `ipv6`;
+  });
+  inst._zod.check = (payload) => {
+    try {
+      new URL(`http://[${payload.value}]`);
+    } catch {
+      payload.issues.push({
+        code: "invalid_format",
+        format: "ipv6",
+        input: payload.value,
+        inst,
+        continue: !def.abort
+      });
+    }
+  };
+});
+var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
+  def.pattern ?? (def.pattern = cidrv4);
+  $ZodStringFormat.init(inst, def);
+});
+var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
+  def.pattern ?? (def.pattern = cidrv6);
+  $ZodStringFormat.init(inst, def);
+  inst._zod.check = (payload) => {
+    const parts = payload.value.split("/");
+    try {
+      if (parts.length !== 2)
+        throw new Error;
+      const [address, prefix] = parts;
+      if (!prefix)
+        throw new Error;
+      const prefixNum = Number(prefix);
+      if (`${prefixNum}` !== prefix)
+        throw new Error;
+      if (prefixNum < 0 || prefixNum > 128)
+        throw new Error;
+      new URL(`http://[${address}]`);
+    } catch {
+      payload.issues.push({
+        code: "invalid_format",
+        format: "cidrv6",
+        input: payload.value,
+        inst,
+        continue: !def.abort
+      });
+    }
+  };
+});
+function isValidBase64(data) {
+  if (data === "")
+    return true;
+  if (data.length % 4 !== 0)
+    return false;
+  try {
+    atob(data);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
+  def.pattern ?? (def.pattern = base64);
+  $ZodStringFormat.init(inst, def);
+  inst._zod.onattach.push((inst) => {
+    inst._zod.bag.contentEncoding = "base64";
+  });
+  inst._zod.check = (payload) => {
+    if (isValidBase64(payload.value))
+      return;
+    payload.issues.push({
+      code: "invalid_format",
+      format: "base64",
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+function isValidBase64URL(data) {
+  if (!base64url.test(data))
+    return false;
+  const base64 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
+  const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+  return isValidBase64(padded);
+}
+var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
+  def.pattern ?? (def.pattern = base64url);
+  $ZodStringFormat.init(inst, def);
+  inst._zod.onattach.push((inst) => {
+    inst._zod.bag.contentEncoding = "base64url";
+  });
+  inst._zod.check = (payload) => {
+    if (isValidBase64URL(payload.value))
+      return;
+    payload.issues.push({
+      code: "invalid_format",
+      format: "base64url",
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
+  def.pattern ?? (def.pattern = e164);
+  $ZodStringFormat.init(inst, def);
+});
+function isValidJWT(token, algorithm = null) {
+  try {
+    const tokensParts = token.split(".");
+    if (tokensParts.length !== 3)
+      return false;
+    const [header] = tokensParts;
+    if (!header)
+      return false;
+    const parsedHeader = JSON.parse(atob(header));
+    if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
+      return false;
+    if (!parsedHeader.alg)
+      return false;
+    if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm))
+      return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
+  $ZodStringFormat.init(inst, def);
+  inst._zod.check = (payload) => {
+    if (isValidJWT(payload.value, def.alg))
+      return;
+    payload.issues.push({
+      code: "invalid_format",
+      format: "jwt",
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+function handleArrayResult(result, final, index) {
+  if (result.issues.length) {
+    final.issues.push(...prefixIssues(index, result.issues));
+  }
+  final.value[index] = result.value;
+}
+var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    if (!Array.isArray(input)) {
+      payload.issues.push({
+        expected: "array",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    }
+    payload.value = Array(input.length);
+    const proms = [];
+    for (let i = 0;i < input.length; i++) {
+      const item = input[i];
+      const result = def.element._zod.run({
+        value: item,
+        issues: []
+      }, ctx);
+      if (result instanceof Promise) {
+        proms.push(result.then((result) => handleArrayResult(result, payload, i)));
+      } else {
+        handleArrayResult(result, payload, i);
+      }
+    }
+    if (proms.length) {
+      return Promise.all(proms).then(() => payload);
+    }
+    return payload;
+  };
+});
+function handleUnionResults(results, final, inst, ctx) {
+  for (const result of results) {
+    if (result.issues.length === 0) {
+      final.value = result.value;
+      return final;
+    }
+  }
+  const nonaborted = results.filter((r) => !aborted(r));
+  if (nonaborted.length === 1) {
+    final.value = nonaborted[0].value;
+    return nonaborted[0];
+  }
+  final.issues.push({
+    code: "invalid_union",
+    input: final.value,
+    inst,
+    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  });
+  return final;
+}
+var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : undefined);
+  defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : undefined);
+  defineLazy(inst._zod, "values", () => {
+    if (def.options.every((o) => o._zod.values)) {
+      return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
+    }
+    return;
+  });
+  defineLazy(inst._zod, "pattern", () => {
+    if (def.options.every((o) => o._zod.pattern)) {
+      const patterns = def.options.map((o) => o._zod.pattern);
+      return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
+    }
+    return;
+  });
+  const single = def.options.length === 1;
+  const first = def.options[0]._zod.run;
+  inst._zod.parse = (payload, ctx) => {
+    if (single) {
+      return first(payload, ctx);
+    }
+    let async = false;
+    const results = [];
+    for (const option of def.options) {
+      const result = option._zod.run({
+        value: payload.value,
+        issues: []
+      }, ctx);
+      if (result instanceof Promise) {
+        results.push(result);
+        async = true;
+      } else {
+        if (result.issues.length === 0)
+          return result;
+        results.push(result);
+      }
+    }
+    if (!async)
+      return handleUnionResults(results, payload, inst, ctx);
+    return Promise.all(results).then((results) => {
+      return handleUnionResults(results, payload, inst, ctx);
+    });
+  };
+});
+var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    const input = payload.value;
+    const left = def.left._zod.run({ value: input, issues: [] }, ctx);
+    const right = def.right._zod.run({ value: input, issues: [] }, ctx);
+    const async = left instanceof Promise || right instanceof Promise;
+    if (async) {
+      return Promise.all([left, right]).then(([left, right]) => {
+        return handleIntersectionResults(payload, left, right);
+      });
+    }
+    return handleIntersectionResults(payload, left, right);
+  };
+});
+function mergeValues(a, b) {
+  if (a === b) {
+    return { valid: true, data: a };
+  }
+  if (a instanceof Date && b instanceof Date && +a === +b) {
+    return { valid: true, data: a };
+  }
+  if (isPlainObject(a) && isPlainObject(b)) {
+    const bKeys = Object.keys(b);
+    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
+    const newObj = { ...a, ...b };
+    for (const key of sharedKeys) {
+      const sharedValue = mergeValues(a[key], b[key]);
+      if (!sharedValue.valid) {
+        return {
+          valid: false,
+          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
+        };
+      }
+      newObj[key] = sharedValue.data;
+    }
+    return { valid: true, data: newObj };
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return { valid: false, mergeErrorPath: [] };
+    }
+    const newArray = [];
+    for (let index = 0;index < a.length; index++) {
+      const itemA = a[index];
+      const itemB = b[index];
+      const sharedValue = mergeValues(itemA, itemB);
+      if (!sharedValue.valid) {
+        return {
+          valid: false,
+          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
+        };
+      }
+      newArray.push(sharedValue.data);
+    }
+    return { valid: true, data: newArray };
+  }
+  return { valid: false, mergeErrorPath: [] };
+}
+function handleIntersectionResults(result, left, right) {
+  if (left.issues.length) {
+    result.issues.push(...left.issues);
+  }
+  if (right.issues.length) {
+    result.issues.push(...right.issues);
+  }
+  if (aborted(result))
+    return result;
+  const merged = mergeValues(left.value, right.value);
+  if (!merged.valid) {
+    throw new Error(`Unmergable intersection. Error path: ` + `${JSON.stringify(merged.mergeErrorPath)}`);
+  }
+  result.value = merged.data;
+  return result;
+}
+var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      throw new $ZodEncodeError(inst.constructor.name);
+    }
+    const _out = def.transform(payload.value, payload);
+    if (ctx.async) {
+      const output = _out instanceof Promise ? _out : Promise.resolve(_out);
+      return output.then((output) => {
+        payload.value = output;
+        return payload;
+      });
+    }
+    if (_out instanceof Promise) {
+      throw new $ZodAsyncError;
+    }
+    payload.value = _out;
+    return payload;
+  };
+});
+function handleOptionalResult(result, input) {
+  if (result.issues.length && input === undefined) {
+    return { issues: [], value: undefined };
+  }
+  return result;
+}
+var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.optin = "optional";
+  inst._zod.optout = "optional";
+  defineLazy(inst._zod, "values", () => {
+    return def.innerType._zod.values ? new Set([...def.innerType._zod.values, undefined]) : undefined;
+  });
+  defineLazy(inst._zod, "pattern", () => {
+    const pattern = def.innerType._zod.pattern;
+    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : undefined;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    if (def.innerType._zod.optin === "optional") {
+      const result = def.innerType._zod.run(payload, ctx);
+      if (result instanceof Promise)
+        return result.then((r) => handleOptionalResult(r, payload.value));
+      return handleOptionalResult(result, payload.value);
+    }
+    if (payload.value === undefined) {
+      return payload;
+    }
+    return def.innerType._zod.run(payload, ctx);
+  };
+});
+var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+  defineLazy(inst._zod, "pattern", () => {
+    const pattern = def.innerType._zod.pattern;
+    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : undefined;
+  });
+  defineLazy(inst._zod, "values", () => {
+    return def.innerType._zod.values ? new Set([...def.innerType._zod.values, null]) : undefined;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    if (payload.value === null)
+      return payload;
+    return def.innerType._zod.run(payload, ctx);
+  };
+});
+var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.optin = "optional";
+  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+  inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      return def.innerType._zod.run(payload, ctx);
+    }
+    if (payload.value === undefined) {
+      payload.value = def.defaultValue;
+      return payload;
+    }
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then((result) => handleDefaultResult(result, def));
+    }
+    return handleDefaultResult(result, def);
+  };
+});
+function handleDefaultResult(payload, def) {
+  if (payload.value === undefined) {
+    payload.value = def.defaultValue;
+  }
+  return payload;
+}
+var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.optin = "optional";
+  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+  inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      return def.innerType._zod.run(payload, ctx);
+    }
+    if (payload.value === undefined) {
+      payload.value = def.defaultValue;
+    }
+    return def.innerType._zod.run(payload, ctx);
+  };
+});
+var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "values", () => {
+    const v = def.innerType._zod.values;
+    return v ? new Set([...v].filter((x) => x !== undefined)) : undefined;
+  });
+  inst._zod.parse = (payload, ctx) => {
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then((result) => handleNonOptionalResult(result, inst));
+    }
+    return handleNonOptionalResult(result, inst);
+  };
+});
+function handleNonOptionalResult(payload, inst) {
+  if (!payload.issues.length && payload.value === undefined) {
+    payload.issues.push({
+      code: "invalid_type",
+      expected: "nonoptional",
+      input: payload.value,
+      inst
+    });
+  }
+  return payload;
+}
+var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+  inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      return def.innerType._zod.run(payload, ctx);
+    }
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then((result) => {
+        payload.value = result.value;
+        if (result.issues.length) {
+          payload.value = def.catchValue({
+            ...payload,
+            error: {
+              issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+            },
+            input: payload.value
+          });
+          payload.issues = [];
+        }
+        return payload;
+      });
+    }
+    payload.value = result.value;
+    if (result.issues.length) {
+      payload.value = def.catchValue({
+        ...payload,
+        error: {
+          issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
+        },
+        input: payload.value
+      });
+      payload.issues = [];
+    }
+    return payload;
+  };
+});
+var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "values", () => def.in._zod.values);
+  defineLazy(inst._zod, "optin", () => def.in._zod.optin);
+  defineLazy(inst._zod, "optout", () => def.out._zod.optout);
+  defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
+  inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      const right = def.out._zod.run(payload, ctx);
+      if (right instanceof Promise) {
+        return right.then((right) => handlePipeResult(right, def.in, ctx));
+      }
+      return handlePipeResult(right, def.in, ctx);
+    }
+    const left = def.in._zod.run(payload, ctx);
+    if (left instanceof Promise) {
+      return left.then((left) => handlePipeResult(left, def.out, ctx));
+    }
+    return handlePipeResult(left, def.out, ctx);
+  };
+});
+function handlePipeResult(left, next, ctx) {
+  if (left.issues.length) {
+    left.aborted = true;
+    return left;
+  }
+  return next._zod.run({ value: left.value, issues: left.issues }, ctx);
+}
+var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
+  $ZodType.init(inst, def);
+  defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
+  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
+  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
+  inst._zod.parse = (payload, ctx) => {
+    if (ctx.direction === "backward") {
+      return def.innerType._zod.run(payload, ctx);
+    }
+    const result = def.innerType._zod.run(payload, ctx);
+    if (result instanceof Promise) {
+      return result.then(handleReadonlyResult);
+    }
+    return handleReadonlyResult(result);
+  };
+});
+function handleReadonlyResult(payload) {
+  payload.value = Object.freeze(payload.value);
+  return payload;
+}
+var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, _) => {
+    return payload;
+  };
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const r = def.fn(input);
+    if (r instanceof Promise) {
+      return r.then((r) => handleRefineResult(r, payload, input, inst));
+    }
+    handleRefineResult(r, payload, input, inst);
+    return;
+  };
+});
+function handleRefineResult(result, payload, input, inst) {
+  if (!result) {
+    const _iss = {
+      code: "custom",
+      input,
+      inst,
+      path: [...inst._zod.def.path ?? []],
+      continue: !inst._zod.def.abort
+    };
+    if (inst._zod.def.params)
+      _iss.params = inst._zod.def.params;
+    payload.issues.push(issue(_iss));
+  }
+}
+// node_modules/zod/v4/core/registries.js
+var $output = Symbol("ZodOutput");
+var $input = Symbol("ZodInput");
+
+class $ZodRegistry {
+  constructor() {
+    this._map = new WeakMap;
+    this._idmap = new Map;
+  }
+  add(schema, ..._meta) {
+    const meta = _meta[0];
+    this._map.set(schema, meta);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      if (this._idmap.has(meta.id)) {
+        throw new Error(`ID ${meta.id} already exists in the registry`);
+      }
+      this._idmap.set(meta.id, schema);
+    }
+    return this;
+  }
+  clear() {
+    this._map = new WeakMap;
+    this._idmap = new Map;
+    return this;
+  }
+  remove(schema) {
+    const meta = this._map.get(schema);
+    if (meta && typeof meta === "object" && "id" in meta) {
+      this._idmap.delete(meta.id);
+    }
+    this._map.delete(schema);
+    return this;
+  }
+  get(schema) {
+    const p = schema._zod.parent;
+    if (p) {
+      const pm = { ...this.get(p) ?? {} };
+      delete pm.id;
+      const f = { ...pm, ...this._map.get(schema) };
+      return Object.keys(f).length ? f : undefined;
+    }
+    return this._map.get(schema);
+  }
+  has(schema) {
+    return this._map.has(schema);
+  }
+}
+function registry() {
+  return new $ZodRegistry;
+}
+var globalRegistry = /* @__PURE__ */ registry();
+// node_modules/zod/v4/core/api.js
+function _string(Class, params) {
+  return new Class({
+    type: "string",
+    ...normalizeParams(params)
+  });
+}
+function _email(Class, params) {
+  return new Class({
+    type: "string",
+    format: "email",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _guid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "guid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _uuid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _uuidv4(Class, params) {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v4",
+    ...normalizeParams(params)
+  });
+}
+function _uuidv6(Class, params) {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v6",
+    ...normalizeParams(params)
+  });
+}
+function _uuidv7(Class, params) {
+  return new Class({
+    type: "string",
+    format: "uuid",
+    check: "string_format",
+    abort: false,
+    version: "v7",
+    ...normalizeParams(params)
+  });
+}
+function _url(Class, params) {
+  return new Class({
+    type: "string",
+    format: "url",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _emoji2(Class, params) {
+  return new Class({
+    type: "string",
+    format: "emoji",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _nanoid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "nanoid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _cuid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "cuid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _cuid2(Class, params) {
+  return new Class({
+    type: "string",
+    format: "cuid2",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _ulid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "ulid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _xid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "xid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _ksuid(Class, params) {
+  return new Class({
+    type: "string",
+    format: "ksuid",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _ipv4(Class, params) {
+  return new Class({
+    type: "string",
+    format: "ipv4",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _ipv6(Class, params) {
+  return new Class({
+    type: "string",
+    format: "ipv6",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _cidrv4(Class, params) {
+  return new Class({
+    type: "string",
+    format: "cidrv4",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _cidrv6(Class, params) {
+  return new Class({
+    type: "string",
+    format: "cidrv6",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _base64(Class, params) {
+  return new Class({
+    type: "string",
+    format: "base64",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _base64url(Class, params) {
+  return new Class({
+    type: "string",
+    format: "base64url",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _e164(Class, params) {
+  return new Class({
+    type: "string",
+    format: "e164",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _jwt(Class, params) {
+  return new Class({
+    type: "string",
+    format: "jwt",
+    check: "string_format",
+    abort: false,
+    ...normalizeParams(params)
+  });
+}
+function _isoDateTime(Class, params) {
+  return new Class({
+    type: "string",
+    format: "datetime",
+    check: "string_format",
+    offset: false,
+    local: false,
+    precision: null,
+    ...normalizeParams(params)
+  });
+}
+function _isoDate(Class, params) {
+  return new Class({
+    type: "string",
+    format: "date",
+    check: "string_format",
+    ...normalizeParams(params)
+  });
+}
+function _isoTime(Class, params) {
+  return new Class({
+    type: "string",
+    format: "time",
+    check: "string_format",
+    precision: null,
+    ...normalizeParams(params)
+  });
+}
+function _isoDuration(Class, params) {
+  return new Class({
+    type: "string",
+    format: "duration",
+    check: "string_format",
+    ...normalizeParams(params)
+  });
+}
+function _maxLength(maximum, params) {
+  const ch = new $ZodCheckMaxLength({
+    check: "max_length",
+    ...normalizeParams(params),
+    maximum
+  });
+  return ch;
+}
+function _minLength(minimum, params) {
+  return new $ZodCheckMinLength({
+    check: "min_length",
+    ...normalizeParams(params),
+    minimum
+  });
+}
+function _length(length, params) {
+  return new $ZodCheckLengthEquals({
+    check: "length_equals",
+    ...normalizeParams(params),
+    length
+  });
+}
+function _regex(pattern, params) {
+  return new $ZodCheckRegex({
+    check: "string_format",
+    format: "regex",
+    ...normalizeParams(params),
+    pattern
+  });
+}
+function _lowercase(params) {
+  return new $ZodCheckLowerCase({
+    check: "string_format",
+    format: "lowercase",
+    ...normalizeParams(params)
+  });
+}
+function _uppercase(params) {
+  return new $ZodCheckUpperCase({
+    check: "string_format",
+    format: "uppercase",
+    ...normalizeParams(params)
+  });
+}
+function _includes(includes, params) {
+  return new $ZodCheckIncludes({
+    check: "string_format",
+    format: "includes",
+    ...normalizeParams(params),
+    includes
+  });
+}
+function _startsWith(prefix, params) {
+  return new $ZodCheckStartsWith({
+    check: "string_format",
+    format: "starts_with",
+    ...normalizeParams(params),
+    prefix
+  });
+}
+function _endsWith(suffix, params) {
+  return new $ZodCheckEndsWith({
+    check: "string_format",
+    format: "ends_with",
+    ...normalizeParams(params),
+    suffix
+  });
+}
+function _overwrite(tx) {
+  return new $ZodCheckOverwrite({
+    check: "overwrite",
+    tx
+  });
+}
+function _normalize(form) {
+  return _overwrite((input) => input.normalize(form));
+}
+function _trim() {
+  return _overwrite((input) => input.trim());
+}
+function _toLowerCase() {
+  return _overwrite((input) => input.toLowerCase());
+}
+function _toUpperCase() {
+  return _overwrite((input) => input.toUpperCase());
+}
+function _array(Class, element, params) {
+  return new Class({
+    type: "array",
+    element,
+    ...normalizeParams(params)
+  });
+}
+function _refine(Class, fn, _params) {
+  const schema = new Class({
+    type: "custom",
+    check: "custom",
+    fn,
+    ...normalizeParams(_params)
+  });
+  return schema;
+}
+function _superRefine(fn) {
+  const ch = _check((payload) => {
+    payload.addIssue = (issue2) => {
+      if (typeof issue2 === "string") {
+        payload.issues.push(issue(issue2, payload.value, ch._zod.def));
+      } else {
+        const _issue = issue2;
+        if (_issue.fatal)
+          _issue.continue = false;
+        _issue.code ?? (_issue.code = "custom");
+        _issue.input ?? (_issue.input = payload.value);
+        _issue.inst ?? (_issue.inst = ch);
+        _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
+        payload.issues.push(issue(_issue));
+      }
+    };
+    return fn(payload.value, payload);
+  });
+  return ch;
+}
+function _check(fn, params) {
+  const ch = new $ZodCheck({
+    check: "custom",
+    ...normalizeParams(params)
+  });
+  ch._zod.check = fn;
+  return ch;
+}
+// node_modules/zod/v4/classic/iso.js
+var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
+  $ZodISODateTime.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function datetime2(params) {
+  return _isoDateTime(ZodISODateTime, params);
+}
+var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
+  $ZodISODate.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function date2(params) {
+  return _isoDate(ZodISODate, params);
+}
+var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
+  $ZodISOTime.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function time2(params) {
+  return _isoTime(ZodISOTime, params);
+}
+var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
+  $ZodISODuration.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function duration2(params) {
+  return _isoDuration(ZodISODuration, params);
+}
+
+// node_modules/zod/v4/classic/errors.js
+var initializer2 = (inst, issues) => {
+  $ZodError.init(inst, issues);
+  inst.name = "ZodError";
+  Object.defineProperties(inst, {
+    format: {
+      value: (mapper) => formatError(inst, mapper)
+    },
+    flatten: {
+      value: (mapper) => flattenError(inst, mapper)
+    },
+    addIssue: {
+      value: (issue) => {
+        inst.issues.push(issue);
+        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+      }
+    },
+    addIssues: {
+      value: (issues) => {
+        inst.issues.push(...issues);
+        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+      }
+    },
+    isEmpty: {
+      get() {
+        return inst.issues.length === 0;
+      }
+    }
+  });
+};
+var ZodError = $constructor("ZodError", initializer2);
+var ZodRealError = $constructor("ZodError", initializer2, {
+  Parent: Error
+});
+
+// node_modules/zod/v4/classic/parse.js
+var parse3 = /* @__PURE__ */ _parse(ZodRealError);
+var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
+var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
+var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
+var encode = /* @__PURE__ */ _encode(ZodRealError);
+var decode = /* @__PURE__ */ _decode(ZodRealError);
+var encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
+var decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
+var safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
+var safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
+var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
+var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 
+// node_modules/zod/v4/classic/schemas.js
+var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst.def = def;
+  inst.type = def.type;
+  Object.defineProperty(inst, "_def", { value: def });
+  inst.check = (...checks) => {
+    return inst.clone({
+      ...def,
+      checks: [
+        ...def.checks ?? [],
+        ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
+      ]
+    });
+  };
+  inst.clone = (def, params) => clone(inst, def, params);
+  inst.brand = () => inst;
+  inst.register = (reg, meta) => {
+    reg.add(inst, meta);
+    return inst;
+  };
+  inst.parse = (data, params) => parse3(inst, data, params, { callee: inst.parse });
+  inst.safeParse = (data, params) => safeParse2(inst, data, params);
+  inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
+  inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
+  inst.spa = inst.safeParseAsync;
+  inst.encode = (data, params) => encode(inst, data, params);
+  inst.decode = (data, params) => decode(inst, data, params);
+  inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params);
+  inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params);
+  inst.safeEncode = (data, params) => safeEncode(inst, data, params);
+  inst.safeDecode = (data, params) => safeDecode(inst, data, params);
+  inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params);
+  inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params);
+  inst.refine = (check, params) => inst.check(refine(check, params));
+  inst.superRefine = (refinement) => inst.check(superRefine(refinement));
+  inst.overwrite = (fn) => inst.check(_overwrite(fn));
+  inst.optional = () => optional(inst);
+  inst.nullable = () => nullable(inst);
+  inst.nullish = () => optional(nullable(inst));
+  inst.nonoptional = (params) => nonoptional(inst, params);
+  inst.array = () => array(inst);
+  inst.or = (arg) => union([inst, arg]);
+  inst.and = (arg) => intersection(inst, arg);
+  inst.transform = (tx) => pipe(inst, transform(tx));
+  inst.default = (def) => _default(inst, def);
+  inst.prefault = (def) => prefault(inst, def);
+  inst.catch = (params) => _catch(inst, params);
+  inst.pipe = (target) => pipe(inst, target);
+  inst.readonly = () => readonly(inst);
+  inst.describe = (description) => {
+    const cl = inst.clone();
+    globalRegistry.add(cl, { description });
+    return cl;
+  };
+  Object.defineProperty(inst, "description", {
+    get() {
+      return globalRegistry.get(inst)?.description;
+    },
+    configurable: true
+  });
+  inst.meta = (...args) => {
+    if (args.length === 0) {
+      return globalRegistry.get(inst);
+    }
+    const cl = inst.clone();
+    globalRegistry.add(cl, args[0]);
+    return cl;
+  };
+  inst.isOptional = () => inst.safeParse(undefined).success;
+  inst.isNullable = () => inst.safeParse(null).success;
+  return inst;
+});
+var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
+  $ZodString.init(inst, def);
+  ZodType.init(inst, def);
+  const bag = inst._zod.bag;
+  inst.format = bag.format ?? null;
+  inst.minLength = bag.minimum ?? null;
+  inst.maxLength = bag.maximum ?? null;
+  inst.regex = (...args) => inst.check(_regex(...args));
+  inst.includes = (...args) => inst.check(_includes(...args));
+  inst.startsWith = (...args) => inst.check(_startsWith(...args));
+  inst.endsWith = (...args) => inst.check(_endsWith(...args));
+  inst.min = (...args) => inst.check(_minLength(...args));
+  inst.max = (...args) => inst.check(_maxLength(...args));
+  inst.length = (...args) => inst.check(_length(...args));
+  inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
+  inst.lowercase = (params) => inst.check(_lowercase(params));
+  inst.uppercase = (params) => inst.check(_uppercase(params));
+  inst.trim = () => inst.check(_trim());
+  inst.normalize = (...args) => inst.check(_normalize(...args));
+  inst.toLowerCase = () => inst.check(_toLowerCase());
+  inst.toUpperCase = () => inst.check(_toUpperCase());
+});
+var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
+  $ZodString.init(inst, def);
+  _ZodString.init(inst, def);
+  inst.email = (params) => inst.check(_email(ZodEmail, params));
+  inst.url = (params) => inst.check(_url(ZodURL, params));
+  inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
+  inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params));
+  inst.guid = (params) => inst.check(_guid(ZodGUID, params));
+  inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
+  inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
+  inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
+  inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
+  inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
+  inst.guid = (params) => inst.check(_guid(ZodGUID, params));
+  inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
+  inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
+  inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
+  inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
+  inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
+  inst.xid = (params) => inst.check(_xid(ZodXID, params));
+  inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
+  inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
+  inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
+  inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
+  inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
+  inst.e164 = (params) => inst.check(_e164(ZodE164, params));
+  inst.datetime = (params) => inst.check(datetime2(params));
+  inst.date = (params) => inst.check(date2(params));
+  inst.time = (params) => inst.check(time2(params));
+  inst.duration = (params) => inst.check(duration2(params));
+});
+function string2(params) {
+  return _string(ZodString, params);
+}
+var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
+  $ZodStringFormat.init(inst, def);
+  _ZodString.init(inst, def);
+});
+var ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => {
+  $ZodEmail.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
+  $ZodGUID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
+  $ZodUUID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
+  $ZodURL.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
+  $ZodEmoji.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
+  $ZodNanoID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
+  $ZodCUID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
+  $ZodCUID2.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
+  $ZodULID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
+  $ZodXID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
+  $ZodKSUID.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
+  $ZodIPv4.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
+  $ZodIPv6.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
+  $ZodCIDRv4.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
+  $ZodCIDRv6.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
+  $ZodBase64.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
+  $ZodBase64URL.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
+  $ZodE164.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
+  $ZodJWT.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
+  $ZodArray.init(inst, def);
+  ZodType.init(inst, def);
+  inst.element = def.element;
+  inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
+  inst.nonempty = (params) => inst.check(_minLength(1, params));
+  inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
+  inst.length = (len, params) => inst.check(_length(len, params));
+  inst.unwrap = () => inst.element;
+});
+function array(element, params) {
+  return _array(ZodArray, element, params);
+}
+var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
+  $ZodUnion.init(inst, def);
+  ZodType.init(inst, def);
+  inst.options = def.options;
+});
+function union(options, params) {
+  return new ZodUnion({
+    type: "union",
+    options,
+    ...normalizeParams(params)
+  });
+}
+var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
+  $ZodIntersection.init(inst, def);
+  ZodType.init(inst, def);
+});
+function intersection(left, right) {
+  return new ZodIntersection({
+    type: "intersection",
+    left,
+    right
+  });
+}
+var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
+  $ZodTransform.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.parse = (payload, _ctx) => {
+    if (_ctx.direction === "backward") {
+      throw new $ZodEncodeError(inst.constructor.name);
+    }
+    payload.addIssue = (issue2) => {
+      if (typeof issue2 === "string") {
+        payload.issues.push(issue(issue2, payload.value, def));
+      } else {
+        const _issue = issue2;
+        if (_issue.fatal)
+          _issue.continue = false;
+        _issue.code ?? (_issue.code = "custom");
+        _issue.input ?? (_issue.input = payload.value);
+        _issue.inst ?? (_issue.inst = inst);
+        payload.issues.push(issue(_issue));
+      }
+    };
+    const output = def.transform(payload.value, payload);
+    if (output instanceof Promise) {
+      return output.then((output) => {
+        payload.value = output;
+        return payload;
+      });
+    }
+    payload.value = output;
+    return payload;
+  };
+});
+function transform(fn) {
+  return new ZodTransform({
+    type: "transform",
+    transform: fn
+  });
+}
+var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
+  $ZodOptional.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function optional(innerType) {
+  return new ZodOptional({
+    type: "optional",
+    innerType
+  });
+}
+var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
+  $ZodNullable.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function nullable(innerType) {
+  return new ZodNullable({
+    type: "nullable",
+    innerType
+  });
+}
+var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
+  $ZodDefault.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+  inst.removeDefault = inst.unwrap;
+});
+function _default(innerType, defaultValue) {
+  return new ZodDefault({
+    type: "default",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
+    }
+  });
+}
+var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
+  $ZodPrefault.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function prefault(innerType, defaultValue) {
+  return new ZodPrefault({
+    type: "prefault",
+    innerType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
+    }
+  });
+}
+var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
+  $ZodNonOptional.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function nonoptional(innerType, params) {
+  return new ZodNonOptional({
+    type: "nonoptional",
+    innerType,
+    ...normalizeParams(params)
+  });
+}
+var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
+  $ZodCatch.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+  inst.removeCatch = inst.unwrap;
+});
+function _catch(innerType, catchValue) {
+  return new ZodCatch({
+    type: "catch",
+    innerType,
+    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
+  });
+}
+var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
+  $ZodPipe.init(inst, def);
+  ZodType.init(inst, def);
+  inst.in = def.in;
+  inst.out = def.out;
+});
+function pipe(in_, out) {
+  return new ZodPipe({
+    type: "pipe",
+    in: in_,
+    out
+  });
+}
+var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
+  $ZodReadonly.init(inst, def);
+  ZodType.init(inst, def);
+  inst.unwrap = () => inst._zod.def.innerType;
+});
+function readonly(innerType) {
+  return new ZodReadonly({
+    type: "readonly",
+    innerType
+  });
+}
+var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
+  $ZodCustom.init(inst, def);
+  ZodType.init(inst, def);
+});
+function refine(fn, _params = {}) {
+  return _refine(ZodCustom, fn, _params);
+}
+function superRefine(fn) {
+  return _superRefine(fn);
+}
 // src/api.ts
 var API_BASE = "https://api.commandcode.ai";
 function authHeaders(key) {
@@ -180,6 +2589,107 @@ async function resolveKey(getAuth) {
   } catch {}
   throw new Error("No Command Code API key found. Run /connect, choose Command Code, and paste your key (or `cmd login` in a terminal, or set CMD_API_KEY).");
 }
+
+// src/catalog.ts
+var MODEL_CATALOG = {
+  "claude-fable-5": { name: "Claude Fable 5", context: 1e6, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 }, modalities: ["text", "image"] },
+  "claude-fable-5-1": { name: "Claude Fable 5.1", context: 1e6, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 10, output: 50, cacheRead: 0.25, cacheWrite: 12.5 }, modalities: ["text", "image"] },
+  "claude-haiku-4-5-20251001": { name: "Claude Haiku 4.5", context: 200000, efforts: null, cost: { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 }, modalities: ["text", "image"] },
+  "claude-opus-4-7": { name: "Claude Opus 4.7", context: 1e6, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }, modalities: ["text", "image"] },
+  "claude-opus-4-8": { name: "Claude Opus 4.8", context: 1e6, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }, modalities: ["text", "image"] },
+  "claude-opus-5": { name: "Claude Opus 5", context: 1e6, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 }, modalities: ["text", "image"] },
+  "claude-opus-5-5": { name: "Claude Opus 5.5", context: 1e6, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 4, output: 20, cacheRead: 0.2, cacheWrite: 5 }, modalities: ["text", "image"] },
+  "claude-sonnet-4-6": { name: "Claude Sonnet 4.6", context: 1e6, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 }, modalities: ["text", "image"] },
+  "claude-sonnet-5": { name: "Claude Sonnet 5", context: 1e6, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 }, modalities: ["text", "image"] },
+  "deepseek/deepseek-v4-flash": { name: "DeepSeek V4 Flash (latest)", context: 1e6, efforts: ["high", "max"], cost: { input: 0.15, output: 0.6, cacheRead: 0.003, cacheWrite: 0 }, modalities: ["text"] },
+  "deepseek/deepseek-v4-flash-fast": { name: "DeepSeek V4 Flash Fast", context: 1e6, efforts: ["low", "high", "max"], cost: { input: 0.28, output: 0.56, cacheRead: 0.07, cacheWrite: 0 }, modalities: ["text"] },
+  "deepseek/deepseek-v4-flash-vision-exp": { name: "DeepSeek V4 Flash Vision (exp)", context: 1e6, efforts: ["high", "max"], cost: { input: 0.15, output: 0.6, cacheRead: 0.003, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "deepseek/deepseek-v4-pro": { name: "DeepSeek V4 Pro (latest)", context: 1e6, efforts: ["high", "max"], cost: { input: 0.66, output: 1.98, cacheRead: 0.022, cacheWrite: 0 }, modalities: ["text"] },
+  "deepseek/deepseek-v4.1-flash": { name: "DeepSeek V4.1 Flash", context: 1e6, efforts: ["low", "high", "max"], cost: { input: 0.15, output: 0.6, cacheRead: 0.003, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "google/gemini-3.1-flash-lite": { name: "Gemini 3.1 Flash Lite", context: 1e6, efforts: ["low", "medium", "high"], cost: { input: 0.25, output: 1.5, cacheRead: 0.03, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "google/gemini-3.5-flash": { name: "Gemini 3.5 Flash", context: 1e6, efforts: ["low", "medium", "high"], cost: { input: 1.5, output: 9, cacheRead: 0.15, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "google/gemini-3.5-flash-lite": { name: "Gemini 3.5 Flash Lite", context: 1e6, efforts: ["low", "medium", "high"], cost: { input: 0.3, output: 2.5, cacheRead: 0.03, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "google/gemini-3.6-flash": { name: "Gemini 3.6 Flash", context: 1e6, efforts: ["low", "medium", "high"], cost: { input: 1.5, output: 7.5, cacheRead: 0.15, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "google/gemini-3.7-flash": { name: "Gemini 3.7 Flash", context: 1050000, efforts: ["low", "medium", "high"], cost: { input: 1.5, output: 7.5, cacheRead: 0.15, cacheWrite: 0.08334 }, modalities: ["text", "image"] },
+  "google/gemini-3.8-flash": { name: "Gemini 3.8 Flash", context: 1e6, efforts: ["low", "medium", "high"], cost: { input: 1.5, output: 7.5, cacheRead: 0.15, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "gpt-5.3-codex": { name: "GPT-5.3 Codex", context: 400000, efforts: ["low", "medium", "high", "xhigh"], cost: { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "gpt-5.4": { name: "GPT-5.4", context: 400000, efforts: ["low", "medium", "high", "xhigh"], cost: { input: 2.5, output: 15, cacheRead: 0.25, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "gpt-5.4-mini": { name: "GPT-5.4 Mini", context: 400000, efforts: ["low", "medium", "high"], cost: { input: 0.75, output: 4.5, cacheRead: 0.075, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "gpt-5.5": { name: "GPT-5.5", context: 400000, efforts: ["low", "medium", "high", "xhigh"], cost: { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "gpt-5.6-luna": { name: "GPT-5.6 Luna", context: 1050000, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 0.2, output: 1.2, cacheRead: 0.02, cacheWrite: 0.25 }, modalities: ["text", "image"] },
+  "gpt-5.6-sol": { name: "GPT-5.6 Sol", context: 1050000, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 6.25 }, modalities: ["text", "image"] },
+  "gpt-5.6-terra": { name: "GPT-5.6 Terra", context: 1050000, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 2, output: 12, cacheRead: 0.2, cacheWrite: 2.5 }, modalities: ["text", "image"] },
+  "gpt-6-astra": { name: "GPT-6 Astra", context: 1050000, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 }, modalities: ["text", "image"] },
+  "gpt-6-luna": { name: "GPT-6 Luna", context: 1050000, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 0.1, output: 0.5, cacheRead: 0.01, cacheWrite: 0.125 }, modalities: ["text", "image"] },
+  "gpt-6-sol": { name: "GPT-6 Sol", context: 1050000, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 }, modalities: ["text", "image"] },
+  "inclusionai/ling-3.0-flash-sante:free": { name: "Ling 3.0 Flash Sante", context: 262000, efforts: null, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, modalities: ["text"] },
+  "meituan/LongCat-2.0": { name: "LongCat 2.0", context: 1050000, efforts: null, cost: { input: 0.3, output: 1.2, cacheRead: 0.006, cacheWrite: 0 }, modalities: ["text"] },
+  "meta/muse-spark-1.1": { name: "Muse Spark 1.1", context: 1050000, efforts: ["low", "medium", "high", "xhigh"], cost: { input: 1.25, output: 4.25, cacheRead: 0.15, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "meta/muse-spark-1.2": { name: "Muse Spark 1.2", context: 1050000, efforts: ["low", "medium", "high", "xhigh"], cost: { input: 1.25, output: 4.25, cacheRead: 0.15, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "meta/muse-spark-1.2-contributor": { name: "Muse Spark 1.2 Contributor", context: 1050000, efforts: ["low", "medium", "high", "xhigh"], cost: { input: 0.1, output: 0.2, cacheRead: 0.002, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "meta/muse-spark-1.3": { name: "Muse Spark 1.3", context: 1050000, efforts: ["low", "medium", "high", "xhigh", "max"], cost: { input: 1.25, output: 4.25, cacheRead: 0.15, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "meta/muse-spark-1.3-contributor": { name: "Muse Spark 1.3 Contributor", context: 1050000, efforts: ["low", "medium", "high", "xhigh"], cost: { input: 0.1, output: 0.2, cacheRead: 0.002, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "MiniMaxAI/MiniMax-M2.5": { name: "MiniMax M2.5", context: 200000, efforts: null, cost: { input: 0.3, output: 1.2, cacheRead: 0.03, cacheWrite: 0 }, modalities: ["text"] },
+  "MiniMaxAI/MiniMax-M2.7": { name: "MiniMax M2.7", context: 0, efforts: null, cost: { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0 }, modalities: ["text"] },
+  "MiniMaxAI/MiniMax-M3": { name: "MiniMax M3", context: 1e6, efforts: ["low", "medium", "high"], cost: { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "moonshotai/Kimi-K2.5": { name: "Kimi K2.5", context: 256000, efforts: null, cost: { input: 0.6, output: 3, cacheRead: 0.1, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "moonshotai/Kimi-K2.6": { name: "Kimi K2.6", context: 256000, efforts: null, cost: { input: 0.95, output: 4, cacheRead: 0.16, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "moonshotai/Kimi-K2.7-Code": { name: "Kimi K2.7 Code", context: 256000, efforts: null, cost: { input: 0.95, output: 4, cacheRead: 0.19, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "moonshotai/Kimi-K2.7-Code-Highspeed": { name: "Kimi K2.7 Code HighSpeed", context: 262000, efforts: null, cost: { input: 1.9, output: 8, cacheRead: 0.38, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "moonshotai/Kimi-K3": { name: "Kimi K3", context: 1e6, efforts: ["low", "high", "max"], cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "nvidia/nemotron-3-ultra-550b-a55b": { name: "Nemotron 3 Ultra", context: 1e6, efforts: null, cost: { input: 0.6, output: 2.4, cacheRead: 0.12, cacheWrite: 0 }, modalities: ["text"] },
+  "poolside/laguna-s-2.1-free": { name: "Laguna S 2.1", context: 256000, efforts: null, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, modalities: ["text"] },
+  "Qwen/Qwen3.6-Max-Preview": { name: "Qwen 3.6 Max Preview", context: 0, efforts: null, cost: { input: 1.3, output: 7.8, cacheRead: 0.26, cacheWrite: 1.63 }, modalities: ["text"] },
+  "Qwen/Qwen3.6-Plus": { name: "Qwen 3.6 Plus", context: 0, efforts: null, cost: { input: 0.5, output: 3, cacheRead: 0.1, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "Qwen/Qwen3.7-Flash": { name: "Qwen 3.7 Flash", context: 1e6, efforts: null, cost: { input: 0.03, output: 0.13, cacheRead: 0.006, cacheWrite: 0.038 }, modalities: ["text", "image"] },
+  "Qwen/Qwen3.7-Max": { name: "Qwen 3.7 Max", context: 1e6, efforts: null, cost: { input: 2.5, output: 7.5, cacheRead: 0.5, cacheWrite: 3.13 }, modalities: ["text"] },
+  "Qwen/Qwen3.7-Plus": { name: "Qwen 3.7 Plus", context: 1e6, efforts: null, cost: { input: 0.4, output: 1.6, cacheRead: 0.08, cacheWrite: 0.5 }, modalities: ["text", "image"] },
+  "Qwen/Qwen3.8-27B": { name: "Qwen 3.8 27B", context: 262000, efforts: ["low", "medium", "xhigh"], cost: { input: 0.4, output: 3, cacheRead: 0.04, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "Qwen/Qwen3.8-Flash": { name: "Qwen 3.8 Flash", context: 1e6, efforts: ["low", "medium", "xhigh"], cost: { input: 0.16, output: 0.47, cacheRead: 0.016, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "Qwen/Qwen3.8-Max": { name: "Qwen 3.8 Max", context: 1e6, efforts: ["low", "medium", "xhigh"], cost: { input: 2, output: 6, cacheRead: 0.25, cacheWrite: 2.5 }, modalities: ["text", "image"] },
+  "Qwen/Qwen3.8-Max-0902": { name: "Qwen 3.8 Max 0902", context: 1e6, efforts: ["low", "medium", "xhigh"], cost: { input: 2, output: 6, cacheRead: 0.25, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "Qwen/Qwen3.8-Omni-Flash": { name: "Qwen 3.8 Omni Flash", context: 1e6, efforts: ["low", "medium", "xhigh"], cost: { input: 0.15, output: 0.47, cacheRead: 0.016, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "sakana/fugu-ultra": { name: "Fugu Ultra", context: 1e6, efforts: ["high", "xhigh"], cost: { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "stealth/space-bunny-alpha": { name: "Space Bunny Alpha", context: 1e6, efforts: ["low", "medium", "high"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "stepfun/Step-3.5-Flash": { name: "Step 3.5 Flash", context: 1e6, efforts: null, cost: { input: 0.1, output: 0.3, cacheRead: 0.02, cacheWrite: 0 }, modalities: ["text"] },
+  "stepfun/Step-3.7-Flash": { name: "Step 3.7 Flash", context: 256000, efforts: null, cost: { input: 0.2, output: 1.15, cacheRead: 0.04, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "stepfun/Step-5-Preview": { name: "Step 5 Preview", context: 1e6, efforts: ["low", "medium", "high"], cost: { input: 1, output: 2.7, cacheRead: 0.05, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "tencent/hy3-paid": { name: "Tencent Hy3", context: 262000, efforts: null, cost: { input: 0.14, output: 0.58, cacheRead: 0.035, cacheWrite: 0 }, modalities: ["text"] },
+  "tencent/hy4-preview": { name: "Tencent Hy4 Preview", context: 1050000, efforts: ["low", "medium", "high"], cost: { input: 0.834, output: 2.501, cacheRead: 0.042, cacheWrite: 0 }, modalities: ["text"] },
+  "thinkingmachines/inkling": { name: "Inkling", context: 256000, efforts: null, cost: { input: 1, output: 4.05, cacheRead: 0.17, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "thinkingmachines/inkling-small": { name: "Inkling Small", context: 1e6, efforts: null, cost: { input: 0.5, output: 1.2, cacheRead: 0.1, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "xai/grok-4.5": { name: "Grok 4.5", context: 500000, efforts: ["low", "medium", "high"], cost: { input: 2, output: 6, cacheRead: 0.5, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "xai/grok-4.6": { name: "Grok 4.6", context: 500000, efforts: ["low", "medium", "high", "xhigh"], cost: { input: 2, output: 6, cacheRead: 0.5, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "xai/grok-4.7": { name: "Grok 4.7", context: 500000, efforts: ["low", "medium", "high", "xhigh"], cost: { input: 1.2, output: 3.6, cacheRead: 0.3, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "xiaomi/mimo-v2.5": { name: "MiMo V2.5", context: 1e6, efforts: null, cost: { input: 0.14, output: 0.28, cacheRead: 0.0028, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "xiaomi/mimo-v2.5-pro": { name: "MiMo V2.5 Pro", context: 1e6, efforts: null, cost: { input: 0.435, output: 0.87, cacheRead: 0.0036, cacheWrite: 0 }, modalities: ["text"] },
+  "xiaomi/mimo-v2.6-flash": { name: "MiMo V2.6 Flash", context: 1050000, efforts: null, cost: { input: 0.14, output: 0.28, cacheRead: 0.0028, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "xiaomi/mimo-v2.6-pro": { name: "MiMo V2.6 Pro", context: 1050000, efforts: null, cost: { input: 0.435, output: 0.87, cacheRead: 0.0036, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "xiaomi/mimo-v2.6-pro-ultraspeed": { name: "MiMo V2.6 Pro UltraSpeed", context: 1050000, efforts: null, cost: { input: 4.35, output: 8.7, cacheRead: 0.036, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "z-ai/glm-5.3-flash": { name: "GLM-5.3 Flash", context: 1050000, efforts: ["low", "high", "max"], cost: { input: 0.15, output: 0.5, cacheRead: 0.03, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "z-ai/glm-5.3-flashx": { name: "GLM-5.3 FlashX", context: 1e6, efforts: ["low", "high", "max"], cost: { input: 0.37, output: 1.25, cacheRead: 0.075, cacheWrite: 0 }, modalities: ["text", "image"] },
+  "zai-org/GLM-5": { name: "GLM-5", context: 200000, efforts: null, cost: { input: 1, output: 3.2, cacheRead: 0.2, cacheWrite: 0 }, modalities: ["text"] },
+  "zai-org/GLM-5.1": { name: "GLM-5.1", context: 0, efforts: null, cost: { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 }, modalities: ["text"] },
+  "zai-org/GLM-5.2": { name: "GLM-5.2", context: 1e6, efforts: ["high", "max"], cost: { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 }, modalities: ["text"] },
+  "zai-org/GLM-5.2-Fast": { name: "GLM-5.2 Fast", context: 1e6, efforts: null, cost: { input: 3, output: 10.25, cacheRead: 0.5, cacheWrite: 0 }, modalities: ["text"] },
+  "zai-org/GLM-5.3": { name: "GLM-5.3", context: 1e6, efforts: ["low", "high", "max"], cost: { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 }, modalities: ["text"] }
+};
+var TEXT_ONLY = ["text"];
+function inputModalities(id) {
+  return MODEL_CATALOG[id]?.modalities ?? TEXT_ONLY;
+}
+function supportsImage(id) {
+  return inputModalities(id).includes("image");
+}
+function modelCost(id) {
+  return MODEL_CATALOG[id]?.cost;
+}
+function reasoningVariants(id) {
+  const efforts = MODEL_CATALOG[id]?.efforts;
+  if (!efforts || efforts.length === 0)
+    return;
+  return Object.fromEntries(efforts.map((effort) => [effort, { reasoningEffort: effort }]));
+}
 // ../core/gating.json
 var gating_default = {
   extractedAt: "2026-09-12T06:01:01.385Z",
@@ -544,8 +3054,655 @@ async function loadModels(key) {
   return { claude, open };
 }
 
+// src/provider/stream.ts
+function sseDecoder(onEvent) {
+  let buffer = "";
+  return (text) => {
+    buffer += text;
+    for (;; ) {
+      const nl = buffer.indexOf(`
+`);
+      if (nl < 0)
+        return;
+      const line = buffer.slice(0, nl).replace(/\r$/, "");
+      buffer = buffer.slice(nl + 1);
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith(":") || trimmed.startsWith("event:"))
+        continue;
+      const payload = trimmed.startsWith("data:") ? trimmed.slice(5).trim() : trimmed;
+      if (!payload || payload === "[DONE]")
+        continue;
+      try {
+        const parsed = JSON.parse(payload);
+        if (parsed && typeof parsed === "object")
+          onEvent(parsed);
+      } catch {}
+    }
+  };
+}
+var text = (v) => typeof v === "string" ? v : "";
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var rec = (v) => v && typeof v === "object" ? v : {};
+var TOOL_FINISH = new Set(["tool_use", "tool_calls", "tool-call", "function_call"]);
+var LENGTH_FINISH = new Set(["length", "max_tokens", "max_output_tokens", "model_context_window_exceeded"]);
+function finishReason(raw) {
+  const value = (raw ?? "unknown").toLowerCase();
+  if (TOOL_FINISH.has(value))
+    return { unified: "tool-calls", raw };
+  if (LENGTH_FINISH.has(value))
+    return { unified: "length", raw };
+  if (value === "error")
+    return { unified: "error", raw };
+  return { unified: "stop", raw };
+}
+function usageFrom(total, noCache, cacheRead, cacheWrite, output, reasoning) {
+  return {
+    inputTokens: { total, noCache, cacheRead, cacheWrite },
+    outputTokens: { total: output, text: Math.max(0, output - reasoning), reasoning }
+  };
+}
+function anthropicUsage(raw) {
+  const total = num(raw.input_tokens);
+  const cacheRead = num(raw.cache_read_input_tokens);
+  const cacheWrite = num(raw.cache_creation_input_tokens);
+  const output = num(raw.output_tokens);
+  return usageFrom(total, Math.max(0, total - cacheRead - cacheWrite), cacheRead, cacheWrite, output, 0);
+}
+function openaiUsage(raw) {
+  const total = num(raw.prompt_tokens);
+  const cached = num(rec(raw.prompt_tokens_details).cached_tokens);
+  const output = num(raw.completion_tokens);
+  const reasoning = num(rec(raw.completion_tokens_details).reasoning_tokens);
+  return usageFrom(total, Math.max(0, total - cached), cached, 0, output, reasoning);
+}
+function anthropicReducer() {
+  const blocks = new Map;
+  let finished = false;
+  let warningsEmitted = false;
+  let last = { unified: "stop", raw: "unknown" };
+  const open = (index, kind) => {
+    const id = `${kind === "text" ? "text" : "reasoning"}-${index}`;
+    blocks.set(index, { type: kind, id });
+    return [{ type: kind === "text" ? "text-start" : "reasoning-start", id }];
+  };
+  return {
+    feed(event) {
+      const type = text(event.type);
+      if (type === "message_start") {
+        if (warningsEmitted)
+          return [];
+        warningsEmitted = true;
+        return [{ type: "stream-start", warnings: [] }];
+      }
+      if (type === "content_block_start") {
+        const index = num(event.index);
+        const block = rec(event.content_block);
+        const blockType = text(block.type);
+        if (blockType === "text")
+          return open(index, "text");
+        if (blockType === "thinking")
+          return open(index, "thinking");
+        if (blockType === "tool_use") {
+          const id = text(block.id) || `tool-${index}`;
+          blocks.set(index, { type: "tool_use", id });
+          return [{ type: "tool-input-start", id, toolName: text(block.name) }];
+        }
+        blocks.set(index, { type: "other", id: `block-${index}` });
+        return [];
+      }
+      if (type === "content_block_delta") {
+        const index = num(event.index);
+        const delta = rec(event.delta);
+        const block = blocks.get(index);
+        const textDelta = text(delta.text);
+        if (textDelta) {
+          const parts = block?.type === "text" ? [] : open(index, "text");
+          const id = blocks.get(index)?.id ?? `text-${index}`;
+          return [...parts, { type: "text-delta", id, delta: textDelta }];
+        }
+        const thinking = text(delta.thinking);
+        if (thinking) {
+          const parts = block?.type === "thinking" ? [] : open(index, "thinking");
+          const id = blocks.get(index)?.id ?? `reasoning-${index}`;
+          return [...parts, { type: "reasoning-delta", id, delta: thinking }];
+        }
+        const partial = text(delta.partial_json);
+        if (partial && block?.type === "tool_use") {
+          return [{ type: "tool-input-delta", id: block.id, delta: partial }];
+        }
+        return [];
+      }
+      if (type === "content_block_stop") {
+        const index = num(event.index);
+        const block = blocks.get(index);
+        if (!block)
+          return [];
+        blocks.delete(index);
+        if (block.type === "text")
+          return [{ type: "text-end", id: block.id }];
+        if (block.type === "thinking")
+          return [{ type: "reasoning-end", id: block.id }];
+        if (block.type === "tool_use")
+          return [{ type: "tool-input-end", id: block.id }];
+        return [];
+      }
+      if (type === "message_delta") {
+        const delta = rec(event.delta);
+        last = finishReason(text(delta.stop_reason) || undefined);
+        if (text(delta.stop_reason) === "pause_turn")
+          last = { unified: "stop", raw: "pause_turn" };
+        if (finished)
+          return [];
+        finished = true;
+        return [{ type: "finish", finishReason: last, usage: anthropicUsage(rec(event.usage)) }];
+      }
+      if (type === "message_stop" && !finished) {
+        finished = true;
+        return [{ type: "finish", finishReason: last, usage: usageFrom(0, 0, 0, 0, 0, 0) }];
+      }
+      return [];
+    },
+    close() {
+      const parts = [];
+      for (const block of blocks.values()) {
+        if (block.type === "text")
+          parts.push({ type: "text-end", id: block.id });
+        if (block.type === "thinking")
+          parts.push({ type: "reasoning-end", id: block.id });
+        if (block.type === "tool_use")
+          parts.push({ type: "tool-input-end", id: block.id });
+      }
+      blocks.clear();
+      return parts;
+    }
+  };
+}
+function openaiReducer() {
+  const tools = new Map;
+  let textId;
+  let reasoningId;
+  let pending;
+  let usage;
+  let finished = false;
+  const closeText = () => {
+    if (!textId)
+      return [];
+    const id = textId;
+    textId = undefined;
+    return [{ type: "text-end", id }];
+  };
+  const closeReasoning = () => {
+    if (!reasoningId)
+      return [];
+    const id = reasoningId;
+    reasoningId = undefined;
+    return [{ type: "reasoning-end", id }];
+  };
+  const completeIfParsed = (buffer) => {
+    if (!buffer.opened || buffer.closed)
+      return [];
+    try {
+      JSON.parse(buffer.input);
+    } catch {
+      return [];
+    }
+    buffer.closed = true;
+    return [
+      { type: "tool-input-end", id: buffer.id },
+      { type: "tool-call", toolCallId: buffer.id, toolName: buffer.name, input: buffer.input }
+    ];
+  };
+  const flushTools = () => {
+    const parts = [];
+    for (const [index, buffer] of tools) {
+      if (buffer.opened && !buffer.closed) {
+        parts.push({ type: "tool-input-end", id: buffer.id });
+        parts.push({ type: "tool-call", toolCallId: buffer.id, toolName: buffer.name, input: buffer.input });
+        buffer.closed = true;
+      }
+      tools.delete(index);
+    }
+    return parts;
+  };
+  return {
+    feed(event) {
+      if (text(event.type) === "error" || event.error !== undefined) {
+        const message = text(rec(event.error).message) || text(event.message) || "provider stream error";
+        return [{ type: "error", error: new Error(message) }];
+      }
+      const parts = [];
+      const choices = Array.isArray(event.choices) ? event.choices : [];
+      const choice = rec(choices[0]);
+      const delta = rec(choice.delta);
+      const reasoning = text(delta.reasoning) || text(delta.reasoning_content);
+      if (reasoning) {
+        if (!reasoningId) {
+          parts.push(...closeText());
+          reasoningId = "reasoning-0";
+          parts.push({ type: "reasoning-start", id: reasoningId });
+        }
+        parts.push({ type: "reasoning-delta", id: reasoningId, delta: reasoning });
+      }
+      const content = text(delta.content);
+      if (content) {
+        if (reasoningId)
+          parts.push(...closeReasoning());
+        if (!textId) {
+          textId = "text-0";
+          parts.push({ type: "text-start", id: textId });
+        }
+        parts.push({ type: "text-delta", id: textId, delta: content });
+      }
+      const calls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+      if (calls.length > 0) {
+        parts.push(...closeReasoning(), ...closeText());
+        for (const raw of calls) {
+          const call = rec(raw);
+          const fn = rec(call.function);
+          const index = typeof call.index === "number" ? call.index : tools.size;
+          let buffer = tools.get(index);
+          if (!buffer) {
+            buffer = { id: text(call.id) || `tool-${index}`, name: text(fn.name), input: "", opened: false, closed: false };
+            tools.set(index, buffer);
+          }
+          if (text(call.id))
+            buffer.id = text(call.id);
+          if (text(fn.name))
+            buffer.name = text(fn.name);
+          const args = text(fn.arguments);
+          if (!buffer.opened && buffer.name) {
+            buffer.opened = true;
+            parts.push({ type: "tool-input-start", id: buffer.id, toolName: buffer.name });
+            if (buffer.input)
+              parts.push({ type: "tool-input-delta", id: buffer.id, delta: buffer.input });
+          } else if (args && !buffer.closed) {
+            parts.push({ type: "tool-input-delta", id: buffer.id, delta: args });
+          }
+          if (!buffer.closed) {
+            buffer.input += args;
+            parts.push(...completeIfParsed(buffer));
+          }
+        }
+      }
+      const rawFinish = text(choice.finish_reason) || text(choice.finishReason) || text(event.finish_reason) || text(event.finishReason);
+      if (rawFinish)
+        pending = finishReason(rawFinish);
+      if (event.usage !== undefined && event.usage !== null)
+        usage = openaiUsage(rec(event.usage));
+      if (pending && !finished && (usage !== undefined || choices.length === 0)) {
+        finished = true;
+        parts.push(...closeReasoning(), ...closeText(), ...flushTools());
+        parts.push({ type: "finish", finishReason: pending, usage: usage ?? usageFrom(0, 0, 0, 0, 0, 0) });
+      }
+      return parts;
+    },
+    close() {
+      const parts = [...closeReasoning(), ...closeText(), ...flushTools()];
+      if (pending && !finished) {
+        finished = true;
+        parts.push({ type: "finish", finishReason: pending, usage: usage ?? usageFrom(0, 0, 0, 0, 0, 0) });
+      }
+      return parts;
+    }
+  };
+}
+
+// src/provider/wire.ts
+var DEFAULT_MAX_TOKENS = 64000;
+function capTokens(value) {
+  const n = typeof value === "number" && Number.isFinite(value) ? value : DEFAULT_MAX_TOKENS;
+  return Math.min(n, DEFAULT_MAX_TOKENS);
+}
+function textOf(part) {
+  const p = part;
+  return typeof p.text === "string" ? p.text : "";
+}
+function resultText(part) {
+  const output = part.output ?? part.result;
+  if (typeof output === "string")
+    return output;
+  if (output && typeof output === "object") {
+    const o = output;
+    if (typeof o.value === "string")
+      return o.value;
+    if (o.value !== undefined)
+      return JSON.stringify(o.value);
+    if (typeof o.reason === "string")
+      return o.reason;
+  }
+  return JSON.stringify(output ?? "");
+}
+function imageUrl(part) {
+  const p = part;
+  const mime = p.mediaType ?? p.mimeType ?? "application/octet-stream";
+  const data = p.data;
+  if (typeof data === "string")
+    return data.startsWith("data:") ? data : `data:${mime};base64,${data}`;
+  if (data instanceof Uint8Array)
+    return `data:${mime};base64,${Buffer.from(data).toString("base64")}`;
+  if (data instanceof URL)
+    return data.href;
+  return;
+}
+function pairedToolCallIds(prompt) {
+  const calls = new Set;
+  const results = new Set;
+  for (const message of prompt) {
+    for (const part of message.content) {
+      if (part.type === "tool-call" && typeof part.toolCallId === "string")
+        calls.add(part.toolCallId);
+      if (part.type === "tool-result" && typeof part.toolCallId === "string")
+        results.add(part.toolCallId);
+    }
+  }
+  return new Set([...calls].filter((id) => results.has(id)));
+}
+function systemText(prompt) {
+  return prompt.filter((m) => m.role === "system").map((m) => m.content).join(`
+`);
+}
+function anthropicUserContent(content, images) {
+  if (typeof content === "string")
+    return content;
+  const parts = content ?? [];
+  const blocks = [];
+  for (const part of parts) {
+    if (part.type === "text")
+      blocks.push({ type: "text", text: textOf(part) });
+    else if (part.type === "file" && images) {
+      const url = imageUrl(part);
+      if (url?.startsWith("data:")) {
+        const [head, b64] = url.slice(5).split(";base64,");
+        blocks.push({ type: "image", source: { type: "base64", media_type: head, data: b64 } });
+      }
+    }
+  }
+  if (blocks.length === 1 && blocks[0].type === "text") {
+    return blocks[0].text;
+  }
+  return blocks;
+}
+function openaiUserContent(content, images) {
+  if (typeof content === "string")
+    return content;
+  const parts = content ?? [];
+  const blocks = [];
+  for (const part of parts) {
+    if (part.type === "text")
+      blocks.push({ type: "text", text: textOf(part) });
+    else if (part.type === "file" && images) {
+      const url = imageUrl(part);
+      if (url)
+        blocks.push({ type: "image_url", image_url: { url } });
+    }
+  }
+  if (blocks.every((b) => b.type === "text")) {
+    return blocks.map((b) => b.text).join(`
+`);
+  }
+  return blocks;
+}
+function anthropicBody(model, prompt, options) {
+  const paired = pairedToolCallIds(prompt);
+  const messages = [];
+  for (const message of prompt) {
+    if (message.role === "system")
+      continue;
+    if (message.role === "user") {
+      messages.push({ role: "user", content: anthropicUserContent(message.content, options.images) });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const content = [];
+      for (const part of message.content) {
+        if (part.type === "text") {
+          const text = textOf(part);
+          if (text)
+            content.push({ type: "text", text });
+        } else if (part.type === "tool-call" && paired.has(String(part.toolCallId))) {
+          content.push({ type: "tool_use", id: part.toolCallId, name: part.toolName, input: part.input ?? {} });
+        }
+      }
+      if (content.length > 0)
+        messages.push({ role: "assistant", content });
+      continue;
+    }
+    for (const part of message.content) {
+      if (part.type !== "tool-result" || !paired.has(String(part.toolCallId)))
+        continue;
+      messages.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: part.toolCallId,
+            content: resultText(part)
+          }
+        ]
+      });
+    }
+  }
+  const system = systemText(prompt);
+  const body = { model, stream: true, messages, max_tokens: capTokens(options.maxOutputTokens) };
+  if (system)
+    body.system = [{ type: "text", text: system, cache_control: { type: "ephemeral" } }];
+  if (options.tools?.length) {
+    body.tools = options.tools.map((t) => ({ name: t.name, description: t.description, input_schema: t.inputSchema ?? {} }));
+  }
+  if (options.temperature !== undefined)
+    body.temperature = options.temperature;
+  if (options.reasoningEffort)
+    body.reasoning_effort = options.reasoningEffort;
+  return body;
+}
+function openaiBody(model, prompt, options) {
+  const paired = pairedToolCallIds(prompt);
+  const messages = [];
+  const system = systemText(prompt);
+  if (system)
+    messages.push({ role: "system", content: system });
+  for (const message of prompt) {
+    if (message.role === "system")
+      continue;
+    if (message.role === "user") {
+      messages.push({ role: "user", content: openaiUserContent(message.content, options.images) });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const calls = message.content.filter((p) => p.type === "tool-call" && paired.has(String(p.toolCallId)));
+      const texts = message.content.filter((p) => p.type === "text").map(textOf).filter(Boolean);
+      const reasoning = message.content.filter((p) => p.type === "reasoning").map(textOf).join("");
+      if (calls.length > 0) {
+        messages.push({
+          role: "assistant",
+          ...reasoning ? { reasoning_content: reasoning } : {},
+          content: texts.length ? texts.join(`
+`) : null,
+          tool_calls: calls.map((c) => ({
+            id: c.toolCallId,
+            type: "function",
+            function: { name: c.toolName, arguments: JSON.stringify(c.input ?? {}) }
+          }))
+        });
+      } else if (texts.length > 0) {
+        messages.push({ role: "assistant", ...reasoning ? { reasoning_content: reasoning } : {}, content: texts.join(`
+`) });
+      }
+      continue;
+    }
+    for (const part of message.content) {
+      if (part.type !== "tool-result" || !paired.has(String(part.toolCallId)))
+        continue;
+      messages.push({
+        role: "tool",
+        tool_call_id: part.toolCallId,
+        content: resultText(part)
+      });
+    }
+  }
+  const body = { model, stream: true, messages, max_tokens: capTokens(options.maxOutputTokens) };
+  if (options.tools?.length) {
+    body.tools = options.tools.map((t) => ({
+      type: "function",
+      function: { name: t.name, description: t.description, parameters: t.inputSchema ?? {} }
+    }));
+  }
+  if (options.temperature !== undefined)
+    body.temperature = options.temperature;
+  if (options.reasoningEffort)
+    body.reasoning_effort = options.reasoningEffort;
+  body.stream_options = { include_usage: true };
+  return body;
+}
+function requestBody(lane, model, prompt, options) {
+  return lane === "anthropic" ? anthropicBody(model, prompt, options) : openaiBody(model, prompt, options);
+}
+
+// src/provider/index.ts
+var DEFAULT_BASE_URL = "https://api.commandcode.ai";
+function laneOf(modelId) {
+  const bare = modelId.includes("/") ? modelId.slice(modelId.lastIndexOf("/") + 1) : modelId;
+  return bare.toLowerCase().startsWith("claude") ? "anthropic" : "openai";
+}
+function endpoint(lane) {
+  return lane === "anthropic" ? "/provider/v1/messages" : "/provider/v1/chat/completions";
+}
+function effortFrom(options) {
+  const providerOptions = options.providerOptions ?? {};
+  const top = providerOptions.reasoning ?? providerOptions.reasoningEffort;
+  if (typeof top === "string")
+    return top;
+  const namespaced = providerOptions.commandcode;
+  if (namespaced && typeof namespaced === "object") {
+    const value = namespaced.reasoning ?? namespaced.reasoningEffort;
+    if (typeof value === "string")
+      return value;
+  }
+  return;
+}
+function toolsOf(options) {
+  const tools = options.tools ?? [];
+  if (tools.length === 0)
+    return;
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: "description" in tool ? tool.description : undefined,
+    inputSchema: tool.inputSchema ?? {}
+  }));
+}
+function createCommandCode(options = {}, images = () => false) {
+  const baseURL = (options.baseURL ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const doFetch = options.fetch ?? fetch;
+  function model(modelId) {
+    const lane = laneOf(modelId);
+    return {
+      specificationVersion: "v3",
+      provider: "command-code",
+      modelId,
+      supportedUrls: {},
+      async doStream(callOptions) {
+        const body = requestBody(lane, modelId, callOptions.prompt, {
+          maxOutputTokens: callOptions.maxOutputTokens,
+          temperature: callOptions.temperature,
+          tools: toolsOf(callOptions),
+          reasoningEffort: effortFrom(callOptions) ?? options.reasoningEffort,
+          images: images(modelId)
+        });
+        const response = await doFetch(`${baseURL}${endpoint(lane)}`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${options.apiKey ?? ""}`,
+            ...options.headers ?? {},
+            ...callOptions.headers ?? {}
+          },
+          body: JSON.stringify(body),
+          signal: callOptions.abortSignal
+        });
+        if (!response.ok || !response.body) {
+          const detail = await response.text().catch(() => "");
+          throw new Error(`command-code ${lane} ${response.status}: ${detail.slice(0, 300)}`);
+        }
+        const reducer = lane === "anthropic" ? anthropicReducer() : openaiReducer();
+        const stream = new ReadableStream({
+          async start(controller) {
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder;
+            const emit = (parts) => {
+              for (const part of parts)
+                controller.enqueue(part);
+            };
+            const decode = sseDecoder((event) => emit(reducer.feed(event)));
+            try {
+              for (;; ) {
+                const { done, value } = await reader.read();
+                if (done)
+                  break;
+                decode(decoder.decode(value, { stream: true }));
+              }
+              emit(reducer.close());
+              controller.close();
+            } catch (error) {
+              controller.enqueue({ type: "error", error });
+              controller.close();
+            }
+          }
+        });
+        return { stream, response: { headers: Object.fromEntries(response.headers) } };
+      },
+      async doGenerate(callOptions) {
+        const { stream } = await this.doStream(callOptions);
+        const reader = stream.getReader();
+        const content = [];
+        let finish = { unified: "stop", raw: "unknown" };
+        let usage = {
+          inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
+          outputTokens: { total: 0, text: 0, reasoning: 0 }
+        };
+        const textOf = {};
+        const toolsById = new Map;
+        for (;; ) {
+          const { done, value } = await reader.read();
+          if (done)
+            break;
+          const part = value;
+          if (part.type === "text-delta")
+            textOf[String(part.id)] = (textOf[String(part.id)] ?? "") + String(part.delta);
+          else if (part.type === "reasoning-delta") {
+            content.push({ type: "reasoning", text: String(part.delta) });
+          } else if (part.type === "tool-input-start") {
+            toolsById.set(String(part.id), { name: String(part.toolName), input: "" });
+          } else if (part.type === "tool-input-delta") {
+            const buffer = toolsById.get(String(part.id));
+            if (buffer)
+              buffer.input += String(part.delta);
+          } else if (part.type === "tool-call") {
+            content.push({
+              type: "tool-call",
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              input: part.input
+            });
+          } else if (part.type === "finish") {
+            finish = part;
+            usage = part.usage;
+          }
+        }
+        for (const [id, value] of Object.entries(textOf))
+          content.push({ type: "text", text: value, id });
+        return {
+          content,
+          finishReason: finish.finishReason,
+          usage,
+          warnings: []
+        };
+      }
+    };
+  }
+  return { languageModel: model };
+}
+
 // src/v2.ts
-import { Plugin } from "@opencode/plugin";
 var PLUGIN_ID = "command-code";
 var PROVIDER_BASE = "https://api.commandcode.ai/provider/v1";
 var INTEGRATION_ID = "command-code";
@@ -560,16 +3717,22 @@ var LANES = [
   }
 ];
 var TOOL_DESCRIPTION = "Fetch live Command Code plan/usage: plan name, monthly credits, 5-hour & weekly windows, billing-period summary. Pass arg='plans' for the plan comparison table only, or extra cmduse flags (e.g. '--tz +05:30 daily').";
+function costEntry(id) {
+  const cost = modelCost(id);
+  return cost ? [{ input: cost.input, output: cost.output, cache: { read: cost.cacheRead, write: cost.cacheWrite } }] : [];
+}
 function toV2Model(m, lane) {
+  const efforts = reasoningVariants(m.id);
+  const variants = efforts ? Object.entries(efforts).map(([id, settings]) => ({ id, settings })) : [];
   const info = {
     id: m.id,
     modelID: m.id,
     providerID: lane.id,
     name: m.name,
-    capabilities: { tools: true, input: ["text"], output: ["text"] },
-    variants: [],
+    capabilities: { tools: true, input: [...inputModalities(m.id)], output: ["text"] },
+    variants,
     time: { released: 0 },
-    cost: [],
+    cost: costEntry(m.id),
     status: "active",
     enabled: true,
     limit: { context: m.contextLength || 128000, output: 32000 },
@@ -605,7 +3768,7 @@ async function credentialKey(ctx) {
     return;
   }
 }
-var commandCodeV2 = Plugin.define({
+var commandCodeV2 = {
   id: PLUGIN_ID,
   async setup(ctx) {
     let localKey;
@@ -634,6 +3797,17 @@ var commandCodeV2 = Plugin.define({
         method: { type: "key", label: "Command Code API key" }
       });
     });
+    const images = (modelId) => inputModalities(modelId).includes("image");
+    for (const lane of LANES) {
+      await ctx.aisdk.hook("sdk", (event) => {
+        const options = event.options ?? {};
+        event.sdk = createCommandCode({
+          apiKey: typeof options.apiKey === "string" ? options.apiKey : undefined,
+          baseURL: typeof options.baseURL === "string" ? options.baseURL : PROVIDER_BASE,
+          headers: options.headers
+        }, images);
+      }, { providerID: lane.id });
+    }
     const seed = staticSeedModels();
     await ctx.provider.transform((editor) => {
       for (const lane of LANES) {
@@ -705,9 +3879,62 @@ var commandCodeV2 = Plugin.define({
       clearInterval(timer);
     };
   }
-});
+};
+// package.json
+var package_default = {
+  name: "@jeffreyjyz/opencode-command-code",
+  version: "0.3.0",
+  description: "Command Code provider + usage dashboard for opencode: two providers (Anthropic wire for Claude, OpenAI wire for everything else) against api.commandcode.ai, live model list, plan gating, /cmd-usage. Requires the cmduse CLI for usage rendering.",
+  type: "module",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": "./dist/index.js",
+    "./tui": "./dist/tui.js"
+  },
+  scripts: {
+    build: "rm -rf dist && bun build src/index.ts --outdir dist --target bun --external @opencode-ai/plugin --external @opencode/plugin --external @opencode/plugin/tui && bun scripts/build-tui.ts && tsc -p tsconfig.build.json",
+    test: "bun test",
+    typecheck: "tsc --noEmit",
+    "build:tui": "bun scripts/build-tui.ts",
+    "extract:catalog": "bun scripts/extract-catalog.ts"
+  },
+  dependencies: {
+    "@opentui/core": "^0.5.4",
+    "@opentui/solid": "^0.5.4",
+    "solid-js": "1.9.12",
+    zod: "4.1.8"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    typescript: "^5",
+    "@opencode-ai/plugin": "*",
+    "@opencode/plugin": "^2.0.11",
+    "@ai-sdk/provider": "3.0.8"
+  },
+  files: [
+    "dist",
+    "tui.js",
+    "LICENSE"
+  ],
+  keywords: [
+    "opencode",
+    "command-code",
+    "plugin",
+    "provider",
+    "ai-sdk"
+  ],
+  license: "MIT",
+  publishConfig: {
+    access: "public"
+  }
+};
 
 // src/index.ts
+var PROVIDER_NPM = `${package_default.name}@${package_default.version}`;
+function tool(input) {
+  return input;
+}
 var MODEL_CAPABILITIES = {
   temperature: true,
   reasoning: true,
@@ -716,6 +3943,14 @@ var MODEL_CAPABILITIES = {
   input: { text: true, audio: false, image: false, video: false, pdf: false },
   output: { text: true, audio: false, image: false, video: false, pdf: false }
 };
+function costFor(id) {
+  const cost = modelCost(id);
+  return {
+    input: cost?.input ?? 0,
+    output: cost?.output ?? 0,
+    cache: { read: cost?.cacheRead ?? 0, write: cost?.cacheWrite ?? 0 }
+  };
+}
 function toModelDefs(models, providerID, npm, interleaved = false) {
   return Object.fromEntries(models.map((m) => [
     m.id,
@@ -724,8 +3959,12 @@ function toModelDefs(models, providerID, npm, interleaved = false) {
       providerID,
       api: { id: m.id, url: PROVIDER_BASE, npm },
       name: m.name,
-      capabilities: { ...MODEL_CAPABILITIES, interleaved },
-      cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+      capabilities: {
+        ...MODEL_CAPABILITIES,
+        interleaved,
+        ...supportsImage(m.id) ? { attachment: true, input: { ...MODEL_CAPABILITIES.input, image: true } } : {}
+      },
+      cost: costFor(m.id),
       limit: { context: m.contextLength || 128000, output: 32000 },
       status: "active",
       options: {},
@@ -788,18 +4027,18 @@ var CommandCodePlugin = async (_input) => {
           console.warn("[command-code] model list unavailable:", e);
         }
       }
-      const claudeDefs = split ? toModelDefs(split.claude, "command-code-anthropic", "@ai-sdk/anthropic") : {};
-      const openDefs = split ? toModelDefs(split.open, "command-code-openai", "@ai-sdk/openai-compatible", { field: "reasoning_content" }) : {};
+      const claudeDefs = split ? toModelDefs(split.claude, "command-code-anthropic", PROVIDER_NPM) : {};
+      const openDefs = split ? toModelDefs(split.open, "command-code-openai", PROVIDER_NPM, { field: "reasoning_content" }) : {};
       const userAnthropic = existing("command-code-anthropic");
       cfg.provider["command-code-anthropic"] = {
-        npm: userAnthropic.npm ?? "@ai-sdk/anthropic",
+        npm: userAnthropic.npm ?? PROVIDER_NPM,
         name: userAnthropic.name ?? "Command Code (Anthropic)",
         options: { baseURL: PROVIDER_BASE, ...userAnthropic.options },
         models: { ...claudeDefs, ...userAnthropic.models }
       };
       const userOpenai = existing("command-code-openai");
       cfg.provider["command-code-openai"] = {
-        npm: userOpenai.npm ?? "@ai-sdk/openai-compatible",
+        npm: userOpenai.npm ?? PROVIDER_NPM,
         name: userOpenai.name ?? "Command Code (OpenAI)",
         options: {
           baseURL: PROVIDER_BASE,
@@ -822,14 +4061,14 @@ var CommandCodePlugin = async (_input) => {
           return a?.type === "api" && a.key ? { key: a.key } : undefined;
         });
         const split = await loadModels(key);
-        return toModelDefs(split.claude, "command-code-anthropic", "@ai-sdk/anthropic");
+        return toModelDefs(split.claude, "command-code-anthropic", PROVIDER_NPM);
       }
     },
     tool: {
       cmd_usage: tool({
-        description: "Fetch live Command Code plan/usage: plan name, monthly credits, 5-hour & weekly windows, billing-period summary. Pass arg=plans for the plan comparison table only.",
+        description: TOOL_DESCRIPTION,
         args: {
-          arg: tool.schema.string().optional().describe("Optional: 'plans' for the plan table only, or extra cmduse flags")
+          arg: string2().optional().describe("Optional: 'plans' for the plan table only, or extra cmduse flags")
         },
         async execute(args) {
           const key = await resolveKey();
@@ -845,5 +4084,6 @@ var src_default = {
 };
 export {
   CommandCodePlugin,
+  createCommandCode,
   src_default as default
 };