zod 4.2.0-canary.20251015T161525 → 4.2.0-canary.20251017T221623

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.2.0-canary.20251015T161525",
+  "version": "4.2.0-canary.20251017T221623",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/src/v4/classic/schemas.ts

@@ -792,6 +792,7 @@ export interface ZodNumber extends _ZodNumber<core.$ZodNumberInternals<number>>
 
 export const ZodNumber: core.$constructor<ZodNumber> = /*@__PURE__*/ core.$constructor("ZodNumber", (inst, def) => {
   core.$ZodNumber.init(inst, def);
+
   ZodType.init(inst, def);
 
   inst.gt = (value, params) => inst.check(checks.gt(value, params));

package/src/v4/classic/tests/index.test.ts

@@ -749,7 +749,7 @@ test("z.json", () => {
 test("z.promise", async () => {
   const a = z.promise(z.string());
   type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string>();
+  expectTypeOf<a>().toEqualTypeOf<Promise<string>>();
 
   expect(await z.safeParseAsync(a, Promise.resolve("hello"))).toMatchObject({
     success: true,

package/src/v4/classic/tests/promise.test.ts

@@ -10,7 +10,7 @@ const promSchema = z.promise(
 
 test("promise inference", () => {
   type promSchemaType = z.infer<typeof promSchema>;
-  expectTypeOf<promSchemaType>().toEqualTypeOf<{ name: string; age: number }>();
+  expectTypeOf<promSchemaType>().toEqualTypeOf<Promise<{ name: string; age: number }>>();
 });
 
 test("promise parsing success", async () => {

package/src/v4/classic/tests/readonly.test.ts

@@ -47,7 +47,7 @@ test("flat inference", () => {
   expectTypeOf<typeof readonlyNumberRecord._output>().toEqualTypeOf<Readonly<Record<string, number>>>();
   expectTypeOf<typeof readonlyObject._output>().toEqualTypeOf<{ readonly a: string; readonly 1: number }>();
   expectTypeOf<typeof readonlyEnum._output>().toEqualTypeOf<Readonly<testEnum>>();
-  expectTypeOf<typeof readonlyPromise._output>().toEqualTypeOf<string>();
+  expectTypeOf<typeof readonlyPromise._output>().toEqualTypeOf<Promise<string>>();
 });
 
 // test("deep inference", () => {

package/src/v4/core/core.ts

@@ -20,21 +20,34 @@ export /*@__NO_SIDE_EFFECTS__*/ function $constructor<T extends ZodTrait, D = T[
   params?: { Parent?: typeof Class }
 ): $constructor<T, D> {
   function init(inst: T, def: D) {
-    Object.defineProperty(inst, "_zod", {
-      value: inst._zod ?? {},
-      enumerable: false,
-    });
+    if (!inst._zod) {
+      Object.defineProperty(inst, "_zod", {
+        value: {
+          def,
+          constr: _,
+          traits: new Set(),
+        },
+        enumerable: false,
+      });
+    }
 
-    inst._zod.traits ??= new Set();
+    if (inst._zod.traits.has(name)) {
+      return;
+    }
 
     inst._zod.traits.add(name);
+
     initializer(inst, def);
+
     // support prototype modifications
-    for (const k in _.prototype) {
-      if (!(k in inst)) Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+    const proto = _.prototype;
+    const keys = Object.keys(proto);
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i]!;
+      if (!(k in inst)) {
+        (inst as any)[k] = proto[k].bind(inst);
+      }
     }
-    inst._zod.constr = _;
-    inst._zod.def = def;
   }
 
   // doesn't work if Parent has a constructor with arguments

package/src/v4/core/schemas.ts

@@ -741,10 +741,8 @@ export interface $ZodIPv4 extends $ZodType {
 export const $ZodIPv4: core.$constructor<$ZodIPv4> = /*@__PURE__*/ core.$constructor("$ZodIPv4", (inst, def): void => {
   def.pattern ??= regexes.ipv4;
   $ZodStringFormat.init(inst, def);
-  inst._zod.onattach.push((inst) => {
-    const bag = inst._zod.bag as $ZodStringInternals<unknown>["bag"];
-    bag.format = `ipv4`;
-  });
+
+  inst._zod.bag.format = `ipv4`;
 });
 
 //////////////////////////////   ZodIPv6   //////////////////////////////
@@ -765,10 +763,7 @@ export const $ZodIPv6: core.$constructor<$ZodIPv6> = /*@__PURE__*/ core.$constru
   def.pattern ??= regexes.ipv6;
   $ZodStringFormat.init(inst, def);
 
-  inst._zod.onattach.push((inst) => {
-    const bag = inst._zod.bag as $ZodStringInternals<unknown>["bag"];
-    bag.format = `ipv6`;
-  });
+  inst._zod.bag.format = `ipv6`;
 
   inst._zod.check = (payload) => {
     try {
@@ -879,9 +874,7 @@ export const $ZodBase64: core.$constructor<$ZodBase64> = /*@__PURE__*/ core.$con
     def.pattern ??= regexes.base64;
     $ZodStringFormat.init(inst, def);
 
-    inst._zod.onattach.push((inst) => {
-      inst._zod.bag.contentEncoding = "base64";
-    });
+    inst._zod.bag.contentEncoding = "base64";
 
     inst._zod.check = (payload) => {
       if (isValidBase64(payload.value)) return;
@@ -918,9 +911,7 @@ export const $ZodBase64URL: core.$constructor<$ZodBase64URL> = /*@__PURE__*/ cor
     def.pattern ??= regexes.base64url;
     $ZodStringFormat.init(inst, def);
 
-    inst._zod.onattach.push((inst) => {
-      inst._zod.bag.contentEncoding = "base64url";
-    });
+    inst._zod.bag.contentEncoding = "base64url";
 
     inst._zod.check = (payload) => {
       if (isValidBase64URL(payload.value)) return;
@@ -1065,8 +1056,8 @@ export interface $ZodNumber<Input = unknown> extends $ZodType {
 
 export const $ZodNumber: core.$constructor<$ZodNumber> = /*@__PURE__*/ core.$constructor("$ZodNumber", (inst, def) => {
   $ZodType.init(inst, def);
-  inst._zod.pattern = inst._zod.bag.pattern ?? regexes.number;
 
+  inst._zod.pattern = inst._zod.bag.pattern ?? regexes.number;
   inst._zod.parse = (payload, _ctx) => {
     if (def.coerce)
       try {
@@ -1113,10 +1104,10 @@ export interface $ZodNumberFormat extends $ZodType {
 }
 
 export const $ZodNumberFormat: core.$constructor<$ZodNumberFormat> = /*@__PURE__*/ core.$constructor(
-  "$ZodNumber",
+  "$ZodNumberFormat",
   (inst, def) => {
     checks.$ZodCheckNumberFormat.init(inst, def);
-    $ZodNumber.init(inst, def); // no format checksp
+    $ZodNumber.init(inst, def); // no format checks
   }
 );
 
@@ -1237,7 +1228,7 @@ export interface $ZodBigIntFormat extends $ZodType {
 }
 
 export const $ZodBigIntFormat: core.$constructor<$ZodBigIntFormat> = /*@__PURE__*/ core.$constructor(
-  "$ZodBigInt",
+  "$ZodBigIntFormat",
   (inst, def) => {
     checks.$ZodCheckBigIntFormat.init(inst, def);
     $ZodBigInt.init(inst, def); // no format checks
@@ -4112,7 +4103,7 @@ export interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeD
 }
 
 export interface $ZodPromiseInternals<T extends SomeType = $ZodType>
-  extends $ZodTypeInternals<core.output<T>, util.MaybeAsync<core.input<T>>> {
+  extends $ZodTypeInternals<Promise<core.output<T>>, util.MaybeAsync<core.input<T>>> {
   def: $ZodPromiseDef<T>;
   isst: never;
 }

package/src/v4/mini/iso.ts

@@ -6,7 +6,7 @@ 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);
@@ -21,7 +21,7 @@ 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);
@@ -36,7 +36,7 @@ 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);
@@ -51,7 +51,7 @@ 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);

package/src/v4/mini/tests/functions.test.ts

@@ -1,43 +1,5 @@
 import { expect, test } from "vitest";
-// import * as z from "zod/v4/core";
 
 test("z.function", () => {
   expect(true).toEqual(true);
 });
-
-// test("z.function", () => {
-//   const a = z.function({
-//     args: z.tuple([z.string()]),
-//     returns: z.string(),
-//   });
-
-//   const myFunc = a.implement((name: string | number) => `Hello, ${name}!`);
-
-//   expect(myFunc("world")).toEqual("Hello, world!");
-//   expect(() => myFunc(123 as any)).toThrow();
-
-//   // this won't run
-//   () => {
-//     // @ts-expect-error
-//     const r = myFunc(123);
-//     expectTypeOf(r).toEqualTypeOf<string>();
-//   };
-// });
-
-// test("z.function async", async () => {
-//   const b = z.function({
-//     args: z.tuple([z.string()]).$check(async (_) => {}),
-//     returns: z.string().$check(async (_) => {}),
-//   });
-//   const myFuncAsync = b.implementAsync(async (name) => `Hello, ${name}!`);
-
-//   expect(await myFuncAsync("world")).toEqual("Hello, world!");
-//   expect(myFuncAsync(123 as any)).rejects.toThrow();
-
-//   // this won't run
-//   () => {
-//     // @ts-expect-error
-//     const r = myFuncAsync(123);
-//     expectTypeOf(r).toEqualTypeOf<Promise<string>>();
-//   };
-// });

package/src/v4/mini/tests/index.test.ts

@@ -789,7 +789,7 @@ test("z.stringbool", () => {
 test("z.promise", async () => {
   const a = z.promise(z.string());
   type a = z.output<typeof a>;
-  expectTypeOf<a>().toEqualTypeOf<string>();
+  expectTypeOf<a>().toEqualTypeOf<Promise<string>>();
 
   expect(await z.safeParseAsync(a, Promise.resolve("hello"))).toMatchObject({
     success: true,

package/v4/core/core.cjs

@@ -9,21 +9,30 @@ exports.NEVER = Object.freeze({
 });
 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());
+        if (!inst._zod) {
+            Object.defineProperty(inst, "_zod", {
+                value: {
+                    def,
+                    constr: _,
+                    traits: new Set(),
+                },
+                enumerable: false,
+            });
+        }
+        if (inst._zod.traits.has(name)) {
+            return;
+        }
         inst._zod.traits.add(name);
         initializer(inst, def);
         // support prototype modifications
-        for (const k in _.prototype) {
-            if (!(k in inst))
-                Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+        const proto = _.prototype;
+        const keys = Object.keys(proto);
+        for (let i = 0; i < keys.length; i++) {
+            const k = keys[i];
+            if (!(k in inst)) {
+                inst[k] = proto[k].bind(inst);
+            }
         }
-        inst._zod.constr = _;
-        inst._zod.def = def;
     }
     // doesn't work if Parent has a constructor with arguments
     const Parent = params?.Parent ?? Object;

package/v4/core/core.js

@@ -4,21 +4,30 @@ export const NEVER = Object.freeze({
 });
 export /*@__NO_SIDE_EFFECTS__*/ 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());
+        if (!inst._zod) {
+            Object.defineProperty(inst, "_zod", {
+                value: {
+                    def,
+                    constr: _,
+                    traits: new Set(),
+                },
+                enumerable: false,
+            });
+        }
+        if (inst._zod.traits.has(name)) {
+            return;
+        }
         inst._zod.traits.add(name);
         initializer(inst, def);
         // support prototype modifications
-        for (const k in _.prototype) {
-            if (!(k in inst))
-                Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+        const proto = _.prototype;
+        const keys = Object.keys(proto);
+        for (let i = 0; i < keys.length; i++) {
+            const k = keys[i];
+            if (!(k in inst)) {
+                inst[k] = proto[k].bind(inst);
+            }
         }
-        inst._zod.constr = _;
-        inst._zod.def = def;
     }
     // doesn't work if Parent has a constructor with arguments
     const Parent = params?.Parent ?? Object;

package/v4/core/schemas.cjs

@@ -327,18 +327,12 @@ exports.$ZodISODuration = core.$constructor("$ZodISODuration", (inst, def) => {
 exports.$ZodIPv4 = core.$constructor("$ZodIPv4", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.ipv4);
     exports.$ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        const bag = inst._zod.bag;
-        bag.format = `ipv4`;
-    });
+    inst._zod.bag.format = `ipv4`;
 });
 exports.$ZodIPv6 = core.$constructor("$ZodIPv6", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.ipv6);
     exports.$ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        const bag = inst._zod.bag;
-        bag.format = `ipv6`;
-    });
+    inst._zod.bag.format = `ipv6`;
     inst._zod.check = (payload) => {
         try {
             // @ts-ignore
@@ -408,9 +402,7 @@ function isValidBase64(data) {
 exports.$ZodBase64 = core.$constructor("$ZodBase64", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.base64);
     exports.$ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        inst._zod.bag.contentEncoding = "base64";
-    });
+    inst._zod.bag.contentEncoding = "base64";
     inst._zod.check = (payload) => {
         if (isValidBase64(payload.value))
             return;
@@ -434,9 +426,7 @@ function isValidBase64URL(data) {
 exports.$ZodBase64URL = core.$constructor("$ZodBase64URL", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.base64url);
     exports.$ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        inst._zod.bag.contentEncoding = "base64url";
-    });
+    inst._zod.bag.contentEncoding = "base64url";
     inst._zod.check = (payload) => {
         if (isValidBase64URL(payload.value))
             return;
@@ -534,9 +524,9 @@ exports.$ZodNumber = core.$constructor("$ZodNumber", (inst, def) => {
         return payload;
     };
 });
-exports.$ZodNumberFormat = core.$constructor("$ZodNumber", (inst, def) => {
+exports.$ZodNumberFormat = core.$constructor("$ZodNumberFormat", (inst, def) => {
     checks.$ZodCheckNumberFormat.init(inst, def);
-    exports.$ZodNumber.init(inst, def); // no format checksp
+    exports.$ZodNumber.init(inst, def); // no format checks
 });
 exports.$ZodBoolean = core.$constructor("$ZodBoolean", (inst, def) => {
     exports.$ZodType.init(inst, def);
@@ -579,7 +569,7 @@ exports.$ZodBigInt = core.$constructor("$ZodBigInt", (inst, def) => {
         return payload;
     };
 });
-exports.$ZodBigIntFormat = core.$constructor("$ZodBigInt", (inst, def) => {
+exports.$ZodBigIntFormat = core.$constructor("$ZodBigIntFormat", (inst, def) => {
     checks.$ZodCheckBigIntFormat.init(inst, def);
     exports.$ZodBigInt.init(inst, def); // no format checks
 });

package/v4/core/schemas.d.cts

@@ -1063,7 +1063,7 @@ export interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeD
     type: "promise";
     innerType: T;
 }
-export interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, util.MaybeAsync<core.input<T>>> {
+export interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<core.output<T>>, util.MaybeAsync<core.input<T>>> {
     def: $ZodPromiseDef<T>;
     isst: never;
 }

package/v4/core/schemas.d.ts

@@ -1063,7 +1063,7 @@ export interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeD
     type: "promise";
     innerType: T;
 }
-export interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, util.MaybeAsync<core.input<T>>> {
+export interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<core.output<T>>, util.MaybeAsync<core.input<T>>> {
     def: $ZodPromiseDef<T>;
     isst: never;
 }

package/v4/core/schemas.js

@@ -296,18 +296,12 @@ export const $ZodISODuration = /*@__PURE__*/ core.$constructor("$ZodISODuration"
 export const $ZodIPv4 = /*@__PURE__*/ core.$constructor("$ZodIPv4", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.ipv4);
     $ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        const bag = inst._zod.bag;
-        bag.format = `ipv4`;
-    });
+    inst._zod.bag.format = `ipv4`;
 });
 export const $ZodIPv6 = /*@__PURE__*/ core.$constructor("$ZodIPv6", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.ipv6);
     $ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        const bag = inst._zod.bag;
-        bag.format = `ipv6`;
-    });
+    inst._zod.bag.format = `ipv6`;
     inst._zod.check = (payload) => {
         try {
             // @ts-ignore
@@ -377,9 +371,7 @@ export function isValidBase64(data) {
 export const $ZodBase64 = /*@__PURE__*/ core.$constructor("$ZodBase64", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.base64);
     $ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        inst._zod.bag.contentEncoding = "base64";
-    });
+    inst._zod.bag.contentEncoding = "base64";
     inst._zod.check = (payload) => {
         if (isValidBase64(payload.value))
             return;
@@ -403,9 +395,7 @@ export function isValidBase64URL(data) {
 export const $ZodBase64URL = /*@__PURE__*/ core.$constructor("$ZodBase64URL", (inst, def) => {
     def.pattern ?? (def.pattern = regexes.base64url);
     $ZodStringFormat.init(inst, def);
-    inst._zod.onattach.push((inst) => {
-        inst._zod.bag.contentEncoding = "base64url";
-    });
+    inst._zod.bag.contentEncoding = "base64url";
     inst._zod.check = (payload) => {
         if (isValidBase64URL(payload.value))
             return;
@@ -503,9 +493,9 @@ export const $ZodNumber = /*@__PURE__*/ core.$constructor("$ZodNumber", (inst, d
         return payload;
     };
 });
-export const $ZodNumberFormat = /*@__PURE__*/ core.$constructor("$ZodNumber", (inst, def) => {
+export const $ZodNumberFormat = /*@__PURE__*/ core.$constructor("$ZodNumberFormat", (inst, def) => {
     checks.$ZodCheckNumberFormat.init(inst, def);
-    $ZodNumber.init(inst, def); // no format checksp
+    $ZodNumber.init(inst, def); // no format checks
 });
 export const $ZodBoolean = /*@__PURE__*/ core.$constructor("$ZodBoolean", (inst, def) => {
     $ZodType.init(inst, def);
@@ -548,7 +538,7 @@ export const $ZodBigInt = /*@__PURE__*/ core.$constructor("$ZodBigInt", (inst, d
         return payload;
     };
 });
-export const $ZodBigIntFormat = /*@__PURE__*/ core.$constructor("$ZodBigInt", (inst, def) => {
+export const $ZodBigIntFormat = /*@__PURE__*/ core.$constructor("$ZodBigIntFormat", (inst, def) => {
     checks.$ZodCheckBigIntFormat.init(inst, def);
     $ZodBigInt.init(inst, def); // no format checks
 });

package/v4/mini/iso.cjs

@@ -30,28 +30,28 @@ exports.time = time;
 exports.duration = duration;
 const core = __importStar(require("../core/index.cjs"));
 const schemas = __importStar(require("./schemas.cjs"));
-exports.ZodMiniISODateTime = core.$constructor("$ZodISODateTime", (inst, def) => {
+exports.ZodMiniISODateTime = core.$constructor("ZodMiniISODateTime", (inst, def) => {
     core.$ZodISODateTime.init(inst, def);
     schemas.ZodMiniStringFormat.init(inst, def);
 });
 function datetime(params) {
     return core._isoDateTime(exports.ZodMiniISODateTime, params);
 }
-exports.ZodMiniISODate = core.$constructor("$ZodISODate", (inst, def) => {
+exports.ZodMiniISODate = core.$constructor("ZodMiniISODate", (inst, def) => {
     core.$ZodISODate.init(inst, def);
     schemas.ZodMiniStringFormat.init(inst, def);
 });
 function date(params) {
     return core._isoDate(exports.ZodMiniISODate, params);
 }
-exports.ZodMiniISOTime = core.$constructor("$ZodISOTime", (inst, def) => {
+exports.ZodMiniISOTime = core.$constructor("ZodMiniISOTime", (inst, def) => {
     core.$ZodISOTime.init(inst, def);
     schemas.ZodMiniStringFormat.init(inst, def);
 });
 function time(params) {
     return core._isoTime(exports.ZodMiniISOTime, params);
 }
-exports.ZodMiniISODuration = core.$constructor("$ZodISODuration", (inst, def) => {
+exports.ZodMiniISODuration = core.$constructor("ZodMiniISODuration", (inst, def) => {
     core.$ZodISODuration.init(inst, def);
     schemas.ZodMiniStringFormat.init(inst, def);
 });

package/v4/mini/iso.js

@@ -1,27 +1,27 @@
 import * as core from "../core/index.js";
 import * as schemas from "./schemas.js";
-export const ZodMiniISODateTime = /*@__PURE__*/ core.$constructor("$ZodISODateTime", (inst, def) => {
+export const ZodMiniISODateTime = /*@__PURE__*/ core.$constructor("ZodMiniISODateTime", (inst, def) => {
     core.$ZodISODateTime.init(inst, def);
     schemas.ZodMiniStringFormat.init(inst, def);
 });
 export function datetime(params) {
     return core._isoDateTime(ZodMiniISODateTime, params);
 }
-export const ZodMiniISODate = /*@__PURE__*/ core.$constructor("$ZodISODate", (inst, def) => {
+export const ZodMiniISODate = /*@__PURE__*/ core.$constructor("ZodMiniISODate", (inst, def) => {
     core.$ZodISODate.init(inst, def);
     schemas.ZodMiniStringFormat.init(inst, def);
 });
 export function date(params) {
     return core._isoDate(ZodMiniISODate, params);
 }
-export const ZodMiniISOTime = /*@__PURE__*/ core.$constructor("$ZodISOTime", (inst, def) => {
+export const ZodMiniISOTime = /*@__PURE__*/ core.$constructor("ZodMiniISOTime", (inst, def) => {
     core.$ZodISOTime.init(inst, def);
     schemas.ZodMiniStringFormat.init(inst, def);
 });
 export function time(params) {
     return core._isoTime(ZodMiniISOTime, params);
 }
-export const ZodMiniISODuration = /*@__PURE__*/ core.$constructor("$ZodISODuration", (inst, def) => {
+export const ZodMiniISODuration = /*@__PURE__*/ core.$constructor("ZodMiniISODuration", (inst, def) => {
     core.$ZodISODuration.init(inst, def);
     schemas.ZodMiniStringFormat.init(inst, def);
 });