@suveren/gateway 0.38.0 → 0.40.0

package/node_modules/zod/src/v4/locales/vi.ts

@@ -8,36 +8,14 @@ const error: () => errors.$ZodErrorMap = () => {
     file: { unit: "byte", verb: "có" },
     array: { unit: "phần tử", verb: "có" },
     set: { unit: "phần tử", verb: "có" },
+    map: { unit: "phần tử", verb: "có" },
   };
 
   function getSizing(origin: string): { unit: string; verb: string } | null {
     return Sizable[origin] ?? null;
   }
 
-  const parsedType = (data: any): string => {
-    const t = typeof data;
-
-    switch (t) {
-      case "number": {
-        return Number.isNaN(data) ? "NaN" : "số";
-      }
-      case "object": {
-        if (Array.isArray(data)) {
-          return "mảng";
-        }
-        if (data === null) {
-          return "null";
-        }
-
-        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-          return data.constructor.name;
-        }
-      }
-    }
-    return t;
-  };
-
-  const Nouns: {
+  const FormatDictionary: {
     [k in $ZodStringFormats | (string & {})]?: string;
   } = {
     regex: "đầu vào",
@@ -60,20 +38,39 @@ const error: () => errors.$ZodErrorMap = () => {
     duration: "khoảng thời gian ISO",
     ipv4: "địa chỉ IPv4",
     ipv6: "địa chỉ IPv6",
+    mac: "địa chỉ MAC",
     cidrv4: "dải IPv4",
     cidrv6: "dải IPv6",
     base64: "chuỗi mã hóa base64",
     base64url: "chuỗi mã hóa base64url",
     json_string: "chuỗi JSON",
     e164: "số E.164",
+    credit_card: "số thẻ tín dụng",
+    currency_code: "mã tiền tệ",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "đầu vào",
   };
 
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+    number: "số",
+    array: "mảng",
+  };
+
   return (issue) => {
     switch (issue.code) {
-      case "invalid_type":
-        return `Đầu vào không hợp lệ: mong đợi ${issue.expected}, nhận được ${parsedType(issue.input)}`;
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `Đầu vào không hợp lệ: mong đợi instanceof ${issue.expected}, nhận được ${received}`;
+        }
+        return `Đầu vào không hợp lệ: mong đợi ${expected}, nhận được ${received}`;
+      }
       case "invalid_value":
         if (issue.values.length === 1)
           return `Đầu vào không hợp lệ: mong đợi ${util.stringifyPrimitive(issue.values[0])}`;
@@ -100,7 +97,7 @@ const error: () => errors.$ZodErrorMap = () => {
         if (_issue.format === "ends_with") return `Chuỗi không hợp lệ: phải kết thúc bằng "${_issue.suffix}"`;
         if (_issue.format === "includes") return `Chuỗi không hợp lệ: phải bao gồm "${_issue.includes}"`;
         if (_issue.format === "regex") return `Chuỗi không hợp lệ: phải khớp với mẫu ${_issue.pattern}`;
-        return `${Nouns[_issue.format] ?? issue.format} không hợp lệ`;
+        return `${FormatDictionary[_issue.format] ?? issue.format} không hợp lệ`;
       }
       case "not_multiple_of":
         return `Số không hợp lệ: phải là bội số của ${issue.divisor}`;

package/node_modules/zod/src/v4/locales/yo.ts

@@ -0,0 +1,129 @@
+import type { $ZodStringFormats } from "../core/checks.js";
+import type * as errors from "../core/errors.js";
+import * as util from "../core/util.js";
+
+const error: () => errors.$ZodErrorMap = () => {
+  const Sizable: Record<string, { unit: string; verb: string }> = {
+    string: { unit: "àmi", verb: "ní" },
+    file: { unit: "bytes", verb: "ní" },
+    array: { unit: "nkan", verb: "ní" },
+    set: { unit: "nkan", verb: "ní" },
+    map: { unit: "nkan", verb: "ní" },
+  };
+
+  function getSizing(origin: string): { unit: string; verb: string } | null {
+    return Sizable[origin] ?? null;
+  }
+
+  const FormatDictionary: {
+    [k in $ZodStringFormats | (string & {})]?: string;
+  } = {
+    regex: "ẹ̀rọ ìbáwọlé",
+    email: "àdírẹ́sì ìmẹ́lì",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "àkókò ISO",
+    date: "ọjọ́ ISO",
+    time: "àkókò ISO",
+    duration: "àkókò tó pé ISO",
+    ipv4: "àdírẹ́sì IPv4",
+    ipv6: "àdírẹ́sì IPv6",
+    mac: "àdírẹ́sì MAC",
+    cidrv4: "àgbègbè IPv4",
+    cidrv6: "àgbègbè IPv6",
+    base64: "ọ̀rọ̀ tí a kọ́ ní base64",
+    base64url: "ọ̀rọ̀ base64url",
+    json_string: "ọ̀rọ̀ JSON",
+    e164: "nọ́mbà E.164",
+    credit_card: "nọmba kaadi gbese",
+    currency_code: "koodu owó",
+    iban: "IBAN",
+    jwt: "JWT",
+    template_literal: "ẹ̀rọ ìbáwọlé",
+  };
+
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+    number: "nọ́mbà",
+    array: "akopọ",
+  };
+
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `Ìbáwọlé aṣìṣe: a ní láti fi instanceof ${issue.expected}, àmọ̀ a rí ${received}`;
+        }
+        return `Ìbáwọlé aṣìṣe: a ní láti fi ${expected}, àmọ̀ a rí ${received}`;
+      }
+
+      case "invalid_value":
+        if (issue.values.length === 1) return `Ìbáwọlé aṣìṣe: a ní láti fi ${util.stringifyPrimitive(issue.values[0])}`;
+        return `Àṣàyàn aṣìṣe: yan ọ̀kan lára ${util.joinValues(issue.values, "|")}`;
+
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Tó pọ̀ jù: a ní láti jẹ́ pé ${issue.origin ?? "iye"} ${sizing.verb} ${adj}${issue.maximum} ${sizing.unit}`;
+        return `Tó pọ̀ jù: a ní láti jẹ́ ${adj}${issue.maximum}`;
+      }
+
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Kéré ju: a ní láti jẹ́ pé ${issue.origin} ${sizing.verb} ${adj}${issue.minimum} ${sizing.unit}`;
+        return `Kéré ju: a ní láti jẹ́ ${adj}${issue.minimum}`;
+      }
+
+      case "invalid_format": {
+        const _issue = issue as errors.$ZodStringFormatIssues;
+        if (_issue.format === "starts_with") return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ bẹ̀rẹ̀ pẹ̀lú "${_issue.prefix}"`;
+        if (_issue.format === "ends_with") return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ parí pẹ̀lú "${_issue.suffix}"`;
+        if (_issue.format === "includes") return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ ní "${_issue.includes}"`;
+        if (_issue.format === "regex") return `Ọ̀rọ̀ aṣìṣe: gbọ́dọ̀ bá àpẹẹrẹ mu ${_issue.pattern}`;
+        return `Aṣìṣe: ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+
+      case "not_multiple_of":
+        return `Nọ́mbà aṣìṣe: gbọ́dọ̀ jẹ́ èyà pípín ti ${issue.divisor}`;
+
+      case "unrecognized_keys":
+        return `Bọtìnì àìmọ̀: ${util.joinValues(issue.keys, ", ")}`;
+
+      case "invalid_key":
+        return `Bọtìnì aṣìṣe nínú ${issue.origin}`;
+
+      case "invalid_union":
+        return "Ìbáwọlé aṣìṣe";
+
+      case "invalid_element":
+        return `Iye aṣìṣe nínú ${issue.origin}`;
+
+      default:
+        return "Ìbáwọlé aṣìṣe";
+    }
+  };
+};
+
+export default function (): { localeError: errors.$ZodErrorMap } {
+  return {
+    localeError: error(),
+  };
+}

package/node_modules/zod/src/v4/locales/zh-CN.ts

@@ -8,36 +8,14 @@ const error: () => errors.$ZodErrorMap = () => {
     file: { unit: "字节", verb: "包含" },
     array: { unit: "项", verb: "包含" },
     set: { unit: "项", verb: "包含" },
+    map: { unit: "项", verb: "包含" },
   };
 
   function getSizing(origin: string): { unit: string; verb: string } | null {
     return Sizable[origin] ?? null;
   }
 
-  const parsedType = (data: any): string => {
-    const t = typeof data;
-
-    switch (t) {
-      case "number": {
-        return Number.isNaN(data) ? "非数字(NaN)" : "数字";
-      }
-      case "object": {
-        if (Array.isArray(data)) {
-          return "数组";
-        }
-        if (data === null) {
-          return "空值(null)";
-        }
-
-        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-          return data.constructor.name;
-        }
-      }
-    }
-    return t;
-  };
-
-  const Nouns: {
+  const FormatDictionary: {
     [k in $ZodStringFormats | (string & {})]?: string;
   } = {
     regex: "输入",
@@ -60,20 +38,40 @@ const error: () => errors.$ZodErrorMap = () => {
     duration: "ISO时长",
     ipv4: "IPv4地址",
     ipv6: "IPv6地址",
+    mac: "MAC地址",
     cidrv4: "IPv4网段",
     cidrv6: "IPv6网段",
     base64: "base64编码字符串",
     base64url: "base64url编码字符串",
     json_string: "JSON字符串",
     e164: "E.164号码",
+    credit_card: "信用卡号",
+    currency_code: "货币代码",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "输入",
   };
 
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+    number: "数字",
+    array: "数组",
+    null: "空值(null)",
+  };
+
   return (issue) => {
     switch (issue.code) {
-      case "invalid_type":
-        return `无效输入：期望 ${issue.expected}，实际接收 ${parsedType(issue.input)}`;
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `无效输入：期望 instanceof ${issue.expected}，实际接收 ${received}`;
+        }
+        return `无效输入：期望 ${expected}，实际接收 ${received}`;
+      }
       case "invalid_value":
         if (issue.values.length === 1) return `无效输入：期望 ${util.stringifyPrimitive(issue.values[0])}`;
         return `无效选项：期望以下之一 ${util.joinValues(issue.values, "|")}`;
@@ -98,7 +96,7 @@ const error: () => errors.$ZodErrorMap = () => {
         if (_issue.format === "ends_with") return `无效字符串：必须以 "${_issue.suffix}" 结尾`;
         if (_issue.format === "includes") return `无效字符串：必须包含 "${_issue.includes}"`;
         if (_issue.format === "regex") return `无效字符串：必须满足正则表达式 ${_issue.pattern}`;
-        return `无效${Nouns[_issue.format] ?? issue.format}`;
+        return `无效${FormatDictionary[_issue.format] ?? issue.format}`;
       }
       case "not_multiple_of":
         return `无效数字：必须是 ${issue.divisor} 的倍数`;

package/node_modules/zod/src/v4/locales/zh-TW.ts

@@ -8,36 +8,14 @@ const error: () => errors.$ZodErrorMap = () => {
     file: { unit: "位元組", verb: "擁有" },
     array: { unit: "項目", verb: "擁有" },
     set: { unit: "項目", verb: "擁有" },
+    map: { unit: "項目", verb: "擁有" },
   };
 
   function getSizing(origin: string): { unit: string; verb: string } | null {
     return Sizable[origin] ?? null;
   }
 
-  const parsedType = (data: any): string => {
-    const t = typeof data;
-
-    switch (t) {
-      case "number": {
-        return Number.isNaN(data) ? "NaN" : "number";
-      }
-      case "object": {
-        if (Array.isArray(data)) {
-          return "array";
-        }
-        if (data === null) {
-          return "null";
-        }
-
-        if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
-          return data.constructor.name;
-        }
-      }
-    }
-    return t;
-  };
-
-  const Nouns: {
+  const FormatDictionary: {
     [k in $ZodStringFormats | (string & {})]?: string;
   } = {
     regex: "輸入",
@@ -60,20 +38,37 @@ const error: () => errors.$ZodErrorMap = () => {
     duration: "ISO 期間",
     ipv4: "IPv4 位址",
     ipv6: "IPv6 位址",
+    mac: "MAC 位址",
     cidrv4: "IPv4 範圍",
     cidrv6: "IPv6 範圍",
     base64: "base64 編碼字串",
     base64url: "base64url 編碼字串",
     json_string: "JSON 字串",
     e164: "E.164 數值",
+    credit_card: "信用卡號",
+    currency_code: "貨幣代碼",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "輸入",
   };
 
+  const TypeDictionary: {
+    [k in errors.$ZodInvalidTypeExpected | (string & {})]?: string;
+  } = {
+    nan: "NaN",
+  };
+
   return (issue) => {
     switch (issue.code) {
-      case "invalid_type":
-        return `無效的輸入值：預期為 ${issue.expected}，但收到 ${parsedType(issue.input)}`;
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = util.parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        if (/^[A-Z]/.test(issue.expected)) {
+          return `無效的輸入值：預期為 instanceof ${issue.expected}，但收到 ${received}`;
+        }
+        return `無效的輸入值：預期為 ${expected}，但收到 ${received}`;
+      }
       case "invalid_value":
         if (issue.values.length === 1) return `無效的輸入值：預期為 ${util.stringifyPrimitive(issue.values[0])}`;
         return `無效的選項：預期為以下其中之一 ${util.joinValues(issue.values, "|")}`;
@@ -100,7 +95,7 @@ const error: () => errors.$ZodErrorMap = () => {
         if (_issue.format === "ends_with") return `無效的字串：必須以 "${_issue.suffix}" 結尾`;
         if (_issue.format === "includes") return `無效的字串：必須包含 "${_issue.includes}"`;
         if (_issue.format === "regex") return `無效的字串：必須符合格式 ${_issue.pattern}`;
-        return `無效的 ${Nouns[_issue.format] ?? issue.format}`;
+        return `無效的 ${FormatDictionary[_issue.format] ?? issue.format}`;
       }
       case "not_multiple_of":
         return `無效的數字：必須為 ${issue.divisor} 的倍數`;

package/node_modules/zod/src/v4/mini/checks.ts

@@ -23,6 +23,7 @@ export {
   _startsWith as startsWith,
   _endsWith as endsWith,
   _property as property,
+  _properties as properties,
   _mime as mime,
   _overwrite as overwrite,
   _normalize as normalize,

package/node_modules/zod/src/v4/mini/coerce.ts

@@ -1,22 +1,27 @@
 import * as core from "../core/index.js";
 import * as schemas from "./schemas.js";
 
+// @__NO_SIDE_EFFECTS__
 export function string<T = unknown>(params?: string | core.$ZodStringParams): schemas.ZodMiniString<T> {
   return core._coercedString(schemas.ZodMiniString, params) as schemas.ZodMiniString<T>;
 }
 
+// @__NO_SIDE_EFFECTS__
 export function number<T = unknown>(params?: string | core.$ZodNumberParams): schemas.ZodMiniNumber<T> {
   return core._coercedNumber(schemas.ZodMiniNumber, params) as schemas.ZodMiniNumber<T>;
 }
 
+// @__NO_SIDE_EFFECTS__
 export function boolean<T = unknown>(params?: string | core.$ZodBooleanParams): schemas.ZodMiniBoolean<T> {
   return core._coercedBoolean(schemas.ZodMiniBoolean, params) as schemas.ZodMiniBoolean<T>;
 }
 
+// @__NO_SIDE_EFFECTS__
 export function bigint<T = unknown>(params?: string | core.$ZodBigIntParams): schemas.ZodMiniBigInt<T> {
   return core._coercedBigint(schemas.ZodMiniBigInt, params) as schemas.ZodMiniBigInt<T>;
 }
 
+// @__NO_SIDE_EFFECTS__
 export function date<T = unknown>(params?: string | core.$ZodDateParams): schemas.ZodMiniDate<T> {
   return core._coercedDate(schemas.ZodMiniDate, params) as schemas.ZodMiniDate<T>;
 }

package/node_modules/zod/src/v4/mini/deep-partial.ts

@@ -0,0 +1,73 @@
+import type * as core from "../core/index.js";
+import { visit } from "../core/visit.js";
+import * as schemas from "./schemas.js";
+
+/** Mini counterpart of `classic/deep-partial.ts`'s `DeepPartial`. */
+// biome-ignore format: preserve vertical layout for readability.
+export type DeepPartial<T extends core.SomeType> =
+  T extends schemas.ZodMiniObject<infer Shape, infer Config>
+    ? schemas.ZodMiniObject<
+        { -readonly [K in keyof Shape]: schemas.ZodMiniOptional<DeepPartial<Shape[K]>> },
+        Config
+      >
+  : T extends schemas.ZodMiniDiscriminatedUnion<infer Options, any>
+    ? schemas.ZodMiniUnion<
+        { -readonly [I in keyof Options]: Options[I] extends core.SomeType ? DeepPartial<Options[I]> : Options[I] }
+      >
+  : T extends schemas.ZodMiniUnion<infer Options>
+    ? schemas.ZodMiniUnion<
+        { -readonly [I in keyof Options]: Options[I] extends core.SomeType ? DeepPartial<Options[I]> : Options[I] }
+      >
+  : T extends schemas.ZodMiniArray<infer El>
+    ? schemas.ZodMiniArray<DeepPartial<El>>
+  : T extends schemas.ZodMiniTuple<infer Items, infer Rest>
+    ? schemas.ZodMiniTuple<
+        { -readonly [K in keyof Items]: Items[K] extends core.SomeType ? DeepPartial<Items[K]> : Items[K] },
+        Rest extends core.SomeType ? DeepPartial<Rest> : Rest
+      >
+  : T extends schemas.ZodMiniIntersection<infer A, infer B>
+    ? schemas.ZodMiniIntersection<DeepPartial<A>, DeepPartial<B>>
+  : T extends schemas.ZodMiniRecord<infer K, infer V>
+    ? schemas.ZodMiniRecord<K, DeepPartial<V>>
+  : T extends schemas.ZodMiniMap<infer K, infer V>
+    ? schemas.ZodMiniMap<K, DeepPartial<V>>
+  : T extends schemas.ZodMiniSet<infer El>
+    ? schemas.ZodMiniSet<DeepPartial<El>>
+  : T extends schemas.ZodMiniOptional<infer Inner>
+    ? schemas.ZodMiniOptional<DeepPartial<Inner>>
+  : T extends schemas.ZodMiniNullable<infer Inner>
+    ? schemas.ZodMiniNullable<DeepPartial<Inner>>
+  : T extends schemas.ZodMiniDefault<infer Inner>
+    ? schemas.ZodMiniDefault<DeepPartial<Inner>>
+  : T extends schemas.ZodMiniPrefault<infer Inner>
+    ? schemas.ZodMiniPrefault<DeepPartial<Inner>>
+  : T extends schemas.ZodMiniNonOptional<infer Inner>
+    ? schemas.ZodMiniNonOptional<DeepPartial<Inner>>
+  : T extends schemas.ZodMiniCatch<infer Inner>
+    ? schemas.ZodMiniCatch<DeepPartial<Inner>>
+  : T extends schemas.ZodMiniReadonly<infer Inner>
+    ? schemas.ZodMiniReadonly<DeepPartial<Inner>>
+  : T extends schemas.ZodMiniSuccess<infer Inner>
+    ? schemas.ZodMiniSuccess<DeepPartial<Inner>>
+  : T extends schemas.ZodMiniPromise<infer Inner>
+    ? schemas.ZodMiniPromise<DeepPartial<Inner>>
+  // Must precede ZodMiniPipe, which it extends structurally.
+  : T extends schemas.ZodMiniCodec<infer A, infer B>
+    ? schemas.ZodMiniCodec<DeepPartial<A>, DeepPartial<B>>
+  : T extends schemas.ZodMiniPipe<infer A, infer B>
+    ? schemas.ZodMiniPipe<DeepPartial<A>, DeepPartial<B>>
+  : T extends schemas.ZodMiniLazy<infer Inner>
+    ? schemas.ZodMiniLazy<DeepPartial<Inner>>
+  : T;
+
+/** See `classic/deep-partial.ts`. Mini variant uses `mini.partial(...)`. */
+export function deepPartial<T extends core.SomeType>(schema: T): DeepPartial<T> {
+  return visit(schema, {
+    object: (s) => schemas.partial(s as schemas.ZodMiniObject),
+    // See `classic/deep-partial.ts`.
+    union: (s) => {
+      const def = s._zod.def as core.$ZodDiscriminatedUnionDef;
+      return def.discriminator === undefined ? s : schemas.union(def.options as schemas.ZodMiniType[]);
+    },
+  }) as unknown as DeepPartial<T>;
+}

package/node_modules/zod/src/v4/mini/external.ts

@@ -2,26 +2,38 @@ export * as core from "../core/index.js";
 export * from "./parse.js";
 export * from "./schemas.js";
 export * from "./checks.js";
+export { deepPartial } from "./deep-partial.js";
+export { input, output } from "./in-out.js";
 
-export type { infer, output, input } from "../core/index.js";
+export type { infer } from "../core/index.js";
+export type { JSONType } from "../core/util.js";
+export type { CompileOptions } from "../core/index.js";
 export {
   globalRegistry,
   registry,
   config,
+  memoizer,
   $output,
   $input,
   $brand,
-  function,
   clone,
   regexes,
   treeifyError,
   prettifyError,
   formatError,
   flattenError,
-  toJSONSchema,
   TimePrecision,
+  util,
   NEVER,
+  INVALID,
+  toZod,
+  compile,
+  withParser,
+  ZodCompileAsyncError,
+  ZodCompileUnsupportedError,
+  getDiscriminatedOption,
 } from "../core/index.js";
+export { toJSONSchema } from "../core/json-schema-processors.js";
 
 export * as locales from "../locales/index.js";
 /** A special constant with type `never` */

package/node_modules/zod/src/v4/mini/in-out.ts

@@ -0,0 +1,45 @@
+import type * as core from "../core/index.js";
+import { clone, mergeDefs } from "../core/util.js";
+import { visit } from "../core/visit.js";
+import * as schemas from "./schemas.js";
+
+// See `classic/in-out.ts` for why these aliases exist.
+export type input<T> = core.input<T>;
+export type output<T> = core.output<T>;
+
+/** See `classic/in-out.ts`. */
+function withChecks(side: core.$ZodType, checks: core.$ZodTypeDef["checks"]): core.$ZodType {
+  if (!checks?.length) return side;
+  const def = side._zod.def;
+  return clone(side, mergeDefs(def, { checks: [...(def.checks ?? []), ...checks] }), { parent: true });
+}
+
+/** See `classic/in-out.ts`. */
+function outSide(def: core.$ZodPipeDef): core.$ZodType {
+  return withChecks(def.out, def.checks);
+}
+
+/** See `classic/in-out.ts`. */
+function inSide(def: core.$ZodPipeDef): core.$ZodType {
+  return def.in._zod.traits.has("$ZodTransform") ? outSide(def) : def.in;
+}
+
+/** See `classic/in-out.ts`. */
+export function input<T extends core.$ZodType>(schema: T): schemas.ZodMiniType<core.input<T>, core.input<T>> {
+  return visit(schema, {
+    pipe: (s) => inSide(s._zod.def),
+    // A default value belongs to the output side, so a rewritten inner type leaves it stranded. `.default()` widens the declared input type with `undefined`, and `optional` is what carries that across.
+    default: (s, rewritten) => (rewritten ? schemas.optional(s._zod.def.innerType) : s),
+    // A catch value is output-side too, but `.catch()` leaves the declared input type alone, so the inner schema stands on its own.
+    catch: (s, rewritten) => (rewritten ? s._zod.def.innerType : s),
+  }) as schemas.ZodMiniType<core.input<T>, core.input<T>>;
+}
+
+/** See `classic/in-out.ts`. */
+export function output<T extends core.$ZodType>(schema: T): schemas.ZodMiniType<core.output<T>, core.output<T>> {
+  return visit(schema, {
+    pipe: (s) => outSide(s._zod.def),
+    // A prefault value is fed through the schema, which makes it input-side, so a rewritten inner type leaves it stranded.
+    prefault: (s, rewritten) => (rewritten ? s._zod.def.innerType : s),
+  }) as schemas.ZodMiniType<core.output<T>, core.output<T>>;
+}

package/node_modules/zod/src/v4/mini/iso.ts

@@ -6,12 +6,13 @@ export interface ZodMiniISODateTime extends schemas.ZodMiniStringFormat<"datetim
   _zod: core.$ZodISODateTimeInternals;
 }
 export const ZodMiniISODateTime: core.$constructor<ZodMiniISODateTime> = /*@__PURE__*/ core.$constructor(
-  "$ZodISODateTime",
+  "ZodMiniISODateTime",
   (inst, def) => {
     core.$ZodISODateTime.init(inst, def);
     schemas.ZodMiniStringFormat.init(inst, def);
   }
 );
+// @__NO_SIDE_EFFECTS__
 export function datetime(params?: string | core.$ZodISODateTimeParams): ZodMiniISODateTime {
   return core._isoDateTime(ZodMiniISODateTime, params);
 }
@@ -21,12 +22,13 @@ export interface ZodMiniISODate extends schemas.ZodMiniStringFormat<"date"> {
   _zod: core.$ZodISODateInternals;
 }
 export const ZodMiniISODate: core.$constructor<ZodMiniISODate> = /*@__PURE__*/ core.$constructor(
-  "$ZodISODate",
+  "ZodMiniISODate",
   (inst, def) => {
     core.$ZodISODate.init(inst, def);
     schemas.ZodMiniStringFormat.init(inst, def);
   }
 );
+// @__NO_SIDE_EFFECTS__
 export function date(params?: string | core.$ZodISODateParams): ZodMiniISODate {
   return core._isoDate(ZodMiniISODate, params);
 }
@@ -36,12 +38,13 @@ export interface ZodMiniISOTime extends schemas.ZodMiniStringFormat<"time"> {
   _zod: core.$ZodISOTimeInternals;
 }
 export const ZodMiniISOTime: core.$constructor<ZodMiniISOTime> = /*@__PURE__*/ core.$constructor(
-  "$ZodISOTime",
+  "ZodMiniISOTime",
   (inst, def) => {
     core.$ZodISOTime.init(inst, def);
     schemas.ZodMiniStringFormat.init(inst, def);
   }
 );
+// @__NO_SIDE_EFFECTS__
 export function time(params?: string | core.$ZodISOTimeParams): ZodMiniISOTime {
   return core._isoTime(ZodMiniISOTime, params);
 }
@@ -51,12 +54,13 @@ export interface ZodMiniISODuration extends schemas.ZodMiniStringFormat<"duratio
   _zod: core.$ZodISODurationInternals;
 }
 export const ZodMiniISODuration: core.$constructor<ZodMiniISODuration> = /*@__PURE__*/ core.$constructor(
-  "$ZodISODuration",
+  "ZodMiniISODuration",
   (inst, def) => {
     core.$ZodISODuration.init(inst, def);
     schemas.ZodMiniStringFormat.init(inst, def);
   }
 );
+// @__NO_SIDE_EFFECTS__
 export function duration(params?: string | core.$ZodISODurationParams): ZodMiniISODuration {
   return core._isoDuration(ZodMiniISODuration, params);
 }

package/node_modules/zod/src/v4/mini/parse.ts

@@ -1 +1,16 @@
-export { parse, safeParse, parseAsync, safeParseAsync } from "../core/index.js";
+export {
+  validate,
+  validateAsync,
+  parse,
+  safeParse,
+  parseAsync,
+  safeParseAsync,
+  encode,
+  decode,
+  encodeAsync,
+  decodeAsync,
+  safeEncode,
+  safeDecode,
+  safeEncodeAsync,
+  safeDecodeAsync,
+} from "../core/index.js";