zod 4.3.3 → 4.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.3.3",
+  "version": "4.3.5",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

package/src/v4/classic/from-json-schema.ts

@@ -597,7 +597,7 @@ function convertSchema(schema: JSONSchema.JSONSchema | boolean, ctx: ConversionC
     }
   }
 
-  // Content keywords that should be captured as metadata
+  // Content keywords - store as metadata
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
   for (const key of contentMetadataKeys) {
     if (key in schema) {

package/src/v4/classic/tests/from-json-schema.test.ts

@@ -711,3 +711,24 @@ test("$comment and $anchor are captured as metadata", () => {
   expect(meta?.$comment).toBe("This is a developer note");
   expect(meta?.$anchor).toBe("my-anchor");
 });
+
+test("contentEncoding and contentMediaType are stored as metadata", () => {
+  const customRegistry = z.registry<{ contentEncoding?: string; contentMediaType?: string }>();
+
+  const schema = fromJSONSchema(
+    {
+      type: "string",
+      contentEncoding: "base64",
+      contentMediaType: "image/png",
+    },
+    { registry: customRegistry }
+  );
+
+  // Should just be a string schema
+  expect(schema.parse("aGVsbG8gd29ybGQ=")).toBe("aGVsbG8gd29ybGQ=");
+
+  // Content keywords should be in metadata
+  const meta = customRegistry.get(schema);
+  expect(meta?.contentEncoding).toBe("base64");
+  expect(meta?.contentMediaType).toBe("image/png");
+});

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

@@ -524,6 +524,58 @@ test("intersection of loose records", () => {
   expect(() => schema.parse({ name: "John", N_count: "abc" })).toThrow(); // N_count should be number
 });
 
+test("object with looseRecord index signature", () => {
+  // Simulates TypeScript index signature: { label: string; [key: `label:${string}`]: string }
+  const schema = z.object({ label: z.string() }).and(z.looseRecord(z.string().regex(/^label:[a-z]{2}$/), z.string()));
+
+  type Schema = z.infer<typeof schema>;
+  expectTypeOf<Schema>().toEqualTypeOf<{ label: string } & Record<string, string>>();
+
+  // Valid: has required property and matching pattern keys
+  expect(schema.parse({ label: "Purple", "label:en": "Purple", "label:ru": "Пурпурный" })).toEqual({
+    label: "Purple",
+    "label:en": "Purple",
+    "label:ru": "Пурпурный",
+  });
+
+  // Valid: just required property
+  expect(schema.parse({ label: "Purple" })).toEqual({ label: "Purple" });
+
+  // Invalid: missing required property
+  expect(schema.safeParse({ "label:en": "Purple" })).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "label"
+        ],
+        "message": "Invalid input: expected string, received undefined"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+
+  // Invalid: pattern key with wrong value type
+  expect(schema.safeParse({ label: "Purple", "label:en": 123 })).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "label:en"
+        ],
+        "message": "Invalid input: expected string, received number"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
 test("numeric string keys", () => {
   const schema = z.record(z.number(), z.number());
 

package/src/v4/classic/tests/to-json-schema.test.ts

@@ -929,6 +929,117 @@ describe("toJSONSchema", () => {
     `);
   });
 
+  test("strict record with regex key uses propertyNames", () => {
+    const schema = z.record(z.string().regex(/^label:[a-z]{2}$/), z.string());
+
+    expect(z.toJSONSchema(schema)).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "additionalProperties": {
+          "type": "string",
+        },
+        "propertyNames": {
+          "pattern": "^label:[a-z]{2}$",
+          "type": "string",
+        },
+        "type": "object",
+      }
+    `);
+  });
+
+  test("looseRecord with regex key uses patternProperties", () => {
+    const schema = z.looseRecord(z.string().regex(/^label:[a-z]{2}$/), z.string());
+
+    expect(z.toJSONSchema(schema)).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "patternProperties": {
+          "^label:[a-z]{2}$": {
+            "type": "string",
+          },
+        },
+        "type": "object",
+      }
+    `);
+  });
+
+  test("looseRecord with multiple regex patterns uses patternProperties", () => {
+    const schema = z.looseRecord(
+      z
+        .string()
+        .regex(/^prefix_/)
+        .regex(/_suffix$/),
+      z.number()
+    );
+
+    expect(z.toJSONSchema(schema)).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "patternProperties": {
+          "^prefix_": {
+            "type": "number",
+          },
+          "_suffix$": {
+            "type": "number",
+          },
+        },
+        "type": "object",
+      }
+    `);
+  });
+
+  test("looseRecord without regex key uses propertyNames", () => {
+    // looseRecord with plain string key should still use propertyNames
+    const schema = z.looseRecord(z.string(), z.boolean());
+
+    expect(z.toJSONSchema(schema)).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "additionalProperties": {
+          "type": "boolean",
+        },
+        "propertyNames": {
+          "type": "string",
+        },
+        "type": "object",
+      }
+    `);
+  });
+
+  test("intersection of object with looseRecord uses patternProperties", () => {
+    const zLabeled = z.object({ label: z.string() });
+    const zLocalizedLabeled = z.looseRecord(z.string().regex(/^label:[a-z]{2}$/), z.string());
+    const schema = zLabeled.and(zLocalizedLabeled);
+
+    expect(z.toJSONSchema(schema)).toMatchInlineSnapshot(`
+      {
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "allOf": [
+          {
+            "additionalProperties": false,
+            "properties": {
+              "label": {
+                "type": "string",
+              },
+            },
+            "required": [
+              "label",
+            ],
+            "type": "object",
+          },
+          {
+            "patternProperties": {
+              "^label:[a-z]{2}$": {
+                "type": "string",
+              },
+            },
+            "type": "object",
+          },
+        ],
+      }
+    `);
+  });
+
   test("tuple", () => {
     const schema = z.tuple([z.string(), z.number()]);
     expect(z.toJSONSchema(schema)).toMatchInlineSnapshot(`

package/src/v4/core/json-schema-processors.ts

@@ -431,26 +431,47 @@ export const recordProcessor: Processor<schemas.$ZodRecord> = (schema, ctx, _jso
   const json = _json as JSONSchema.ObjectSchema;
   const def = schema._zod.def as schemas.$ZodRecordDef;
   json.type = "object";
-  if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-    json.propertyNames = process(def.keyType, ctx as any, {
+
+  // For looseRecord with regex patterns, use patternProperties
+  // This correctly represents "only validate keys matching the pattern" semantics
+  // and composes well with allOf (intersections)
+  const keyType = def.keyType as schemas.$ZodTypes;
+  const keyBag = keyType._zod.bag as schemas.$ZodStringInternals<unknown>["bag"] | undefined;
+  const patterns = keyBag?.patterns;
+
+  if (def.mode === "loose" && patterns && patterns.size > 0) {
+    // Use patternProperties for looseRecord with regex patterns
+    const valueSchema = process(def.valueType, ctx as any, {
       ...params,
-      path: [...params.path, "propertyNames"],
+      path: [...params.path, "patternProperties", "*"],
+    });
+    json.patternProperties = {};
+    for (const pattern of patterns) {
+      json.patternProperties[pattern.source] = valueSchema;
+    }
+  } else {
+    // Default behavior: use propertyNames + additionalProperties
+    if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
+      json.propertyNames = process(def.keyType, ctx as any, {
+        ...params,
+        path: [...params.path, "propertyNames"],
+      });
+    }
+    json.additionalProperties = process(def.valueType, ctx as any, {
+      ...params,
+      path: [...params.path, "additionalProperties"],
     });
   }
-  json.additionalProperties = process(def.valueType, ctx as any, {
-    ...params,
-    path: [...params.path, "additionalProperties"],
-  });
 
-  const keyDef = (def.keyType as schemas.$ZodTypes)._zod.def;
-  if (keyDef.type === "enum") {
-    const enumValues = getEnumValues(keyDef.entries);
-    const validEnumValues = enumValues.filter(
+  // Add required for keys with discrete values (enum, literal, etc.)
+  const keyValues = keyType._zod.values;
+  if (keyValues) {
+    const validKeyValues = [...keyValues].filter(
       (v): v is string | number => typeof v === "string" || typeof v === "number"
     );
 
-    if (validEnumValues.length > 0) {
-      json.required = validEnumValues as string[];
+    if (validKeyValues.length > 0) {
+      json.required = validKeyValues as string[];
     }
   }
 };

package/src/v4/core/versions.ts

@@ -1,5 +1,5 @@
 export const version = {
   major: 4,
   minor: 3,
-  patch: 3 as number,
+  patch: 5 as number,
 } as const;

package/src/v4/mini/schemas.ts

@@ -1,5 +1,5 @@
 import * as core from "../core/index.js";
-import { util } from "../core/index.js";
+import * as util from "../core/util.js";
 import * as parse from "./parse.js";
 
 type SomeType = core.SomeType;
@@ -12,10 +12,6 @@ export interface ZodMiniType<
   type: Internals["def"]["type"];
   check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
   with(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
-  refine<Ch extends (arg: core.output<this>) => unknown | Promise<unknown>>(
-    check: Ch,
-    params?: string | core.$ZodCustomParams
-  ): Ch extends (arg: any) => arg is infer R ? core.$ZodNarrow<this, R> : this;
   clone(def?: Internals["def"], params?: { parent: boolean }): this;
   register<R extends core.$ZodRegistry>(
     registry: R,
@@ -72,7 +68,6 @@ export const ZodMiniType: core.$constructor<ZodMiniType> = /*@__PURE__*/ core.$c
       );
     };
     inst.with = inst.check;
-    inst.refine = (check, params) => inst.check(refine(check, params)) as never;
     inst.clone = (_def, params) => core.clone(inst, _def, params);
     inst.brand = () => inst as any;
     inst.register = ((reg: any, meta: any) => {

package/v4/classic/from-json-schema.cjs

@@ -571,7 +571,7 @@ function convertSchema(schema, ctx) {
             extraMeta[key] = schema[key];
         }
     }
-    // Content keywords that should be captured as metadata
+    // Content keywords - store as metadata
     const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
     for (const key of contentMetadataKeys) {
         if (key in schema) {

package/v4/classic/from-json-schema.js

@@ -545,7 +545,7 @@ function convertSchema(schema, ctx) {
             extraMeta[key] = schema[key];
         }
     }
-    // Content keywords that should be captured as metadata
+    // Content keywords - store as metadata
     const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
     for (const key of contentMetadataKeys) {
         if (key in schema) {

package/v4/core/json-schema-processors.cjs

@@ -436,22 +436,42 @@ const recordProcessor = (schema, ctx, _json, params) => {
     const json = _json;
     const def = schema._zod.def;
     json.type = "object";
-    if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-        json.propertyNames = (0, to_json_schema_js_1.process)(def.keyType, ctx, {
+    // For looseRecord with regex patterns, use patternProperties
+    // This correctly represents "only validate keys matching the pattern" semantics
+    // and composes well with allOf (intersections)
+    const keyType = def.keyType;
+    const keyBag = keyType._zod.bag;
+    const patterns = keyBag?.patterns;
+    if (def.mode === "loose" && patterns && patterns.size > 0) {
+        // Use patternProperties for looseRecord with regex patterns
+        const valueSchema = (0, to_json_schema_js_1.process)(def.valueType, ctx, {
             ...params,
-            path: [...params.path, "propertyNames"],
+            path: [...params.path, "patternProperties", "*"],
         });
+        json.patternProperties = {};
+        for (const pattern of patterns) {
+            json.patternProperties[pattern.source] = valueSchema;
+        }
     }
-    json.additionalProperties = (0, to_json_schema_js_1.process)(def.valueType, ctx, {
-        ...params,
-        path: [...params.path, "additionalProperties"],
-    });
-    const keyDef = def.keyType._zod.def;
-    if (keyDef.type === "enum") {
-        const enumValues = (0, util_js_1.getEnumValues)(keyDef.entries);
-        const validEnumValues = enumValues.filter((v) => typeof v === "string" || typeof v === "number");
-        if (validEnumValues.length > 0) {
-            json.required = validEnumValues;
+    else {
+        // Default behavior: use propertyNames + additionalProperties
+        if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
+            json.propertyNames = (0, to_json_schema_js_1.process)(def.keyType, ctx, {
+                ...params,
+                path: [...params.path, "propertyNames"],
+            });
+        }
+        json.additionalProperties = (0, to_json_schema_js_1.process)(def.valueType, ctx, {
+            ...params,
+            path: [...params.path, "additionalProperties"],
+        });
+    }
+    // Add required for keys with discrete values (enum, literal, etc.)
+    const keyValues = keyType._zod.values;
+    if (keyValues) {
+        const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+        if (validKeyValues.length > 0) {
+            json.required = validKeyValues;
         }
     }
 };

package/v4/core/json-schema-processors.js

@@ -404,22 +404,42 @@ export const recordProcessor = (schema, ctx, _json, params) => {
     const json = _json;
     const def = schema._zod.def;
     json.type = "object";
-    if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-        json.propertyNames = process(def.keyType, ctx, {
+    // For looseRecord with regex patterns, use patternProperties
+    // This correctly represents "only validate keys matching the pattern" semantics
+    // and composes well with allOf (intersections)
+    const keyType = def.keyType;
+    const keyBag = keyType._zod.bag;
+    const patterns = keyBag?.patterns;
+    if (def.mode === "loose" && patterns && patterns.size > 0) {
+        // Use patternProperties for looseRecord with regex patterns
+        const valueSchema = process(def.valueType, ctx, {
             ...params,
-            path: [...params.path, "propertyNames"],
+            path: [...params.path, "patternProperties", "*"],
         });
+        json.patternProperties = {};
+        for (const pattern of patterns) {
+            json.patternProperties[pattern.source] = valueSchema;
+        }
     }
-    json.additionalProperties = process(def.valueType, ctx, {
-        ...params,
-        path: [...params.path, "additionalProperties"],
-    });
-    const keyDef = def.keyType._zod.def;
-    if (keyDef.type === "enum") {
-        const enumValues = getEnumValues(keyDef.entries);
-        const validEnumValues = enumValues.filter((v) => typeof v === "string" || typeof v === "number");
-        if (validEnumValues.length > 0) {
-            json.required = validEnumValues;
+    else {
+        // Default behavior: use propertyNames + additionalProperties
+        if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
+            json.propertyNames = process(def.keyType, ctx, {
+                ...params,
+                path: [...params.path, "propertyNames"],
+            });
+        }
+        json.additionalProperties = process(def.valueType, ctx, {
+            ...params,
+            path: [...params.path, "additionalProperties"],
+        });
+    }
+    // Add required for keys with discrete values (enum, literal, etc.)
+    const keyValues = keyType._zod.values;
+    if (keyValues) {
+        const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
+        if (validKeyValues.length > 0) {
+            json.required = validKeyValues;
         }
     }
 };

package/v4/core/versions.cjs

@@ -4,5 +4,5 @@ exports.version = void 0;
 exports.version = {
     major: 4,
     minor: 3,
-    patch: 3,
+    patch: 5,
 };

package/v4/core/versions.js

@@ -1,5 +1,5 @@
 export const version = {
     major: 4,
     minor: 3,
-    patch: 3,
+    patch: 5,
 };

package/v4/mini/schemas.cjs

@@ -127,7 +127,7 @@ exports.function = _function;
 exports._function = _function;
 exports.function = _function;
 const core = __importStar(require("../core/index.cjs"));
-const index_js_1 = require("../core/index.cjs");
+const util = __importStar(require("../core/util.cjs"));
 const parse = __importStar(require("./parse.cjs"));
 exports.ZodMiniType = core.$constructor("ZodMiniType", (inst, def) => {
     if (!inst._zod)
@@ -149,7 +149,6 @@ exports.ZodMiniType = core.$constructor("ZodMiniType", (inst, def) => {
         }, { parent: true });
     };
     inst.with = inst.check;
-    inst.refine = (check, params) => inst.check(refine(check, params));
     inst.clone = (_def, params) => core.clone(inst, _def, params);
     inst.brand = () => inst;
     inst.register = ((reg, meta) => {
@@ -221,7 +220,7 @@ function httpUrl(params) {
     return core._url(exports.ZodMiniURL, {
         protocol: /^https?$/,
         hostname: core.regexes.domain,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 exports.ZodMiniEmoji = core.$constructor("ZodMiniEmoji", (inst, def) => {
@@ -518,7 +517,7 @@ function array(element, params) {
     return new exports.ZodMiniArray({
         type: "array",
         element: element,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 // .keyof
@@ -530,14 +529,14 @@ function keyof(schema) {
 exports.ZodMiniObject = core.$constructor("ZodMiniObject", (inst, def) => {
     core.$ZodObject.init(inst, def);
     exports.ZodMiniType.init(inst, def);
-    index_js_1.util.defineLazy(inst, "shape", () => def.shape);
+    util.defineLazy(inst, "shape", () => def.shape);
 });
 // @__NO_SIDE_EFFECTS__
 function object(shape, params) {
     const def = {
         type: "object",
         shape: shape ?? {},
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     };
     return new exports.ZodMiniObject(def);
 }
@@ -548,7 +547,7 @@ function strictObject(shape, params) {
         type: "object",
         shape,
         catchall: never(),
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 // looseObject
@@ -558,38 +557,38 @@ function looseObject(shape, params) {
         type: "object",
         shape,
         catchall: unknown(),
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 // object methods
 // @__NO_SIDE_EFFECTS__
 function extend(schema, shape) {
-    return index_js_1.util.extend(schema, shape);
+    return util.extend(schema, shape);
 }
 // @__NO_SIDE_EFFECTS__
 function safeExtend(schema, shape) {
-    return index_js_1.util.safeExtend(schema, shape);
+    return util.safeExtend(schema, shape);
 }
 // @__NO_SIDE_EFFECTS__
 function merge(schema, shape) {
-    return index_js_1.util.extend(schema, shape);
+    return util.extend(schema, shape);
 }
 // @__NO_SIDE_EFFECTS__
 function pick(schema, mask) {
-    return index_js_1.util.pick(schema, mask);
+    return util.pick(schema, mask);
 }
 // .omit
 // @__NO_SIDE_EFFECTS__
 function omit(schema, mask) {
-    return index_js_1.util.omit(schema, mask);
+    return util.omit(schema, mask);
 }
 // @__NO_SIDE_EFFECTS__
 function partial(schema, mask) {
-    return index_js_1.util.partial(exports.ZodMiniOptional, schema, mask);
+    return util.partial(exports.ZodMiniOptional, schema, mask);
 }
 // @__NO_SIDE_EFFECTS__
 function required(schema, mask) {
-    return index_js_1.util.required(exports.ZodMiniNonOptional, schema, mask);
+    return util.required(exports.ZodMiniNonOptional, schema, mask);
 }
 // @__NO_SIDE_EFFECTS__
 function catchall(inst, catchall) {
@@ -604,7 +603,7 @@ function union(options, params) {
     return new exports.ZodMiniUnion({
         type: "union",
         options: options,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 exports.ZodMiniXor = core.$constructor("ZodMiniXor", (inst, def) => {
@@ -619,7 +618,7 @@ function xor(options, params) {
         type: "union",
         options: options,
         inclusive: false,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 exports.ZodMiniDiscriminatedUnion = core.$constructor("ZodMiniDiscriminatedUnion", (inst, def) => {
@@ -632,7 +631,7 @@ function discriminatedUnion(discriminator, options, params) {
         type: "union",
         options,
         discriminator,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 exports.ZodMiniIntersection = core.$constructor("ZodMiniIntersection", (inst, def) => {
@@ -660,7 +659,7 @@ function tuple(items, _paramsOrRest, _params) {
         type: "tuple",
         items: items,
         rest,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 exports.ZodMiniRecord = core.$constructor("ZodMiniRecord", (inst, def) => {
@@ -673,7 +672,7 @@ function record(keyType, valueType, params) {
         type: "record",
         keyType,
         valueType: valueType,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 // @__NO_SIDE_EFFECTS__
@@ -684,7 +683,7 @@ function partialRecord(keyType, valueType, params) {
         type: "record",
         keyType: k,
         valueType: valueType,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 function looseRecord(keyType, valueType, params) {
@@ -693,7 +692,7 @@ function looseRecord(keyType, valueType, params) {
         keyType,
         valueType: valueType,
         mode: "loose",
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 exports.ZodMiniMap = core.$constructor("ZodMiniMap", (inst, def) => {
@@ -706,7 +705,7 @@ function map(keyType, valueType, params) {
         type: "map",
         keyType: keyType,
         valueType: valueType,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 exports.ZodMiniSet = core.$constructor("ZodMiniSet", (inst, def) => {
@@ -718,7 +717,7 @@ function set(valueType, params) {
     return new exports.ZodMiniSet({
         type: "set",
         valueType: valueType,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 exports.ZodMiniEnum = core.$constructor("ZodMiniEnum", (inst, def) => {
@@ -732,7 +731,7 @@ function _enum(values, params) {
     return new exports.ZodMiniEnum({
         type: "enum",
         entries,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 // @__NO_SIDE_EFFECTS__
@@ -747,7 +746,7 @@ function nativeEnum(entries, params) {
     return new exports.ZodMiniEnum({
         type: "enum",
         entries,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 exports.ZodMiniLiteral = core.$constructor("ZodMiniLiteral", (inst, def) => {
@@ -759,7 +758,7 @@ function literal(value, params) {
     return new exports.ZodMiniLiteral({
         type: "literal",
         values: Array.isArray(value) ? value : [value],
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 exports.ZodMiniFile = core.$constructor("ZodMiniFile", (inst, def) => {
@@ -829,7 +828,7 @@ function _default(innerType, defaultValue) {
         type: "default",
         innerType: innerType,
         get defaultValue() {
-            return typeof defaultValue === "function" ? defaultValue() : index_js_1.util.shallowClone(defaultValue);
+            return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
         },
     });
 }
@@ -843,7 +842,7 @@ function prefault(innerType, defaultValue) {
         type: "prefault",
         innerType: innerType,
         get defaultValue() {
-            return typeof defaultValue === "function" ? defaultValue() : index_js_1.util.shallowClone(defaultValue);
+            return typeof defaultValue === "function" ? defaultValue() : util.shallowClone(defaultValue);
         },
     });
 }
@@ -856,7 +855,7 @@ function nonoptional(innerType, params) {
     return new exports.ZodMiniNonOptional({
         type: "nonoptional",
         innerType: innerType,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 exports.ZodMiniSuccess = core.$constructor("ZodMiniSuccess", (inst, def) => {
@@ -936,7 +935,7 @@ function templateLiteral(parts, params) {
     return new exports.ZodMiniTemplateLiteral({
         type: "template_literal",
         parts,
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
 }
 exports.ZodMiniLazy = core.$constructor("ZodMiniLazy", (inst, def) => {
@@ -973,7 +972,7 @@ exports.ZodMiniCustom = core.$constructor("ZodMiniCustom", (inst, def) => {
 function check(fn, params) {
     const ch = new core.$ZodCheck({
         check: "custom",
-        ...index_js_1.util.normalizeParams(params),
+        ...util.normalizeParams(params),
     });
     ch._zod.check = fn;
     return ch;

package/v4/mini/schemas.d.cts

@@ -1,11 +1,10 @@
 import * as core from "../core/index.cjs";
-import { util } from "../core/index.cjs";
+import * as util from "../core/util.cjs";
 type SomeType = core.SomeType;
 export interface ZodMiniType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
     type: Internals["def"]["type"];
     check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
     with(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
-    refine<Ch extends (arg: core.output<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | core.$ZodCustomParams): Ch extends (arg: any) => arg is infer R ? core.$ZodNarrow<this, R> : this;
     clone(def?: Internals["def"], params?: {
         parent: boolean;
     }): this;

package/v4/mini/schemas.d.ts

@@ -1,11 +1,10 @@
 import * as core from "../core/index.js";
-import { util } from "../core/index.js";
+import * as util from "../core/util.js";
 type SomeType = core.SomeType;
 export interface ZodMiniType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
     type: Internals["def"]["type"];
     check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
     with(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
-    refine<Ch extends (arg: core.output<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | core.$ZodCustomParams): Ch extends (arg: any) => arg is infer R ? core.$ZodNarrow<this, R> : this;
     clone(def?: Internals["def"], params?: {
         parent: boolean;
     }): this;

package/v4/mini/schemas.js

@@ -1,5 +1,5 @@
 import * as core from "../core/index.js";
-import { util } from "../core/index.js";
+import * as util from "../core/util.js";
 import * as parse from "./parse.js";
 export const ZodMiniType = /*@__PURE__*/ core.$constructor("ZodMiniType", (inst, def) => {
     if (!inst._zod)
@@ -21,7 +21,6 @@ export const ZodMiniType = /*@__PURE__*/ core.$constructor("ZodMiniType", (inst,
         }, { parent: true });
     };
     inst.with = inst.check;
-    inst.refine = (check, params) => inst.check(refine(check, params));
     inst.clone = (_def, params) => core.clone(inst, _def, params);
     inst.brand = () => inst;
     inst.register = ((reg, meta) => {

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

@@ -1,19 +0,0 @@
-import { describe, expectTypeOf, test } from "vitest";
-import type * as core from "../../core/index.js";
-import * as z from "../index.js";
-
-describe("type refinement with type guards", () => {
-  test("type guard narrows output type", () => {
-    const schema = z.string().refine((s): s is "a" => s === "a");
-
-    expectTypeOf<core.input<typeof schema>>().toEqualTypeOf<string>();
-    expectTypeOf<core.output<typeof schema>>().toEqualTypeOf<"a">();
-  });
-
-  test("non-type-guard refine does not narrow", () => {
-    const schema = z.string().refine((s) => s.length > 0);
-
-    expectTypeOf<core.input<typeof schema>>().toEqualTypeOf<string>();
-    expectTypeOf<core.output<typeof schema>>().toEqualTypeOf<string>();
-  });
-});