zod 3.25.48 → 3.25.49

package/dist/cjs/v4/classic/schemas.js

@@ -1042,7 +1042,7 @@ function custom(fn, _params) {
     return core._custom(exports.ZodCustom, fn ?? (() => true), _params);
 }
 function refine(fn, _params = {}) {
-    return core._custom(exports.ZodCustom, fn, _params);
+    return core._refine(exports.ZodCustom, fn, _params);
 }
 // superRefine
 function superRefine(fn, params) {

package/dist/cjs/v4/core/api.js

@@ -928,16 +928,32 @@ function _promise(Class, innerType) {
     });
 }
 function _custom(Class, fn, _params) {
+    const norm = util.normalizeParams(_params);
+    norm.abort ?? (norm.abort = true); // default to abort:false
     const schema = new Class({
         type: "custom",
         check: "custom",
         fn: fn,
-        ...util.normalizeParams(_params),
+        ...norm,
     });
     return schema;
 }
-function _refine(Class, fn, _params = {}) {
-    return _custom(Class, fn, _params);
+// export function _refine<T>(
+//   Class: util.SchemaClass<schemas.$ZodCustom>,
+//   fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>,
+//   _params: string | $ZodCustomParams = {}
+// ): checks.$ZodCheck<T> {
+//   return _custom(Class, fn, _params);
+// }
+// same as _custom but deafults to abort:false
+function _refine(Class, fn, _params) {
+    const schema = new Class({
+        type: "custom",
+        check: "custom",
+        fn: fn,
+        ...util.normalizeParams(_params),
+    });
+    return schema;
 }
 function _stringbool(Classes, _params) {
     const { case: _case, error, truthy, falsy } = util.normalizeParams(_params);

package/dist/cjs/v4/core/checks.js

@@ -463,7 +463,8 @@ exports.$ZodCheckUpperCase = core.$constructor("$ZodCheckUpperCase", (inst, def)
 });
 exports.$ZodCheckIncludes = core.$constructor("$ZodCheckIncludes", (inst, def) => {
     exports.$ZodCheck.init(inst, def);
-    const pattern = new RegExp(util.escapeRegex(def.includes));
+    const escapedRegex = util.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;

package/dist/cjs/v4/core/doc.js

@@ -33,7 +33,6 @@ class Doc {
         const content = this?.content ?? [``];
         const lines = [...content.map((x) => `  ${x}`)];
         // console.log(lines.join("\n"));
-        // console.dir("COMPILE", {depth: null});
         return new F(...args, lines.join("\n"));
     }
 }

package/dist/cjs/v4/core/to-json-schema.js

@@ -361,9 +361,18 @@ class JSONSchemaGenerator {
                     }
                     else if (vals.length === 1) {
                         const val = vals[0];
+                        json.type = val === null ? "null" : typeof val;
                         json.const = val;
                     }
                     else {
+                        if (vals.every((v) => typeof v === "number"))
+                            json.type = "number";
+                        if (vals.every((v) => typeof v === "string"))
+                            json.type = "string";
+                        if (vals.every((v) => typeof v === "boolean"))
+                            json.type = "string";
+                        if (vals.every((v) => v === null))
+                            json.type = "null";
                         json.enum = vals;
                     }
                     break;

package/dist/cjs/v4/mini/schemas.js

@@ -105,8 +105,8 @@ exports.templateLiteral = templateLiteral;
 exports.lazy = _lazy;
 exports.promise = promise;
 exports.check = check;
-exports.refine = refine;
 exports.custom = custom;
+exports.refine = refine;
 exports.instanceof = _instanceof;
 exports.json = json;
 const core = __importStar(require("zod/v4/core"));
@@ -797,23 +797,13 @@ function check(fn, params) {
     return ch;
 }
 // ZodCustom
-function _custom(fn, _params, Class) {
-    const params = core_1.util.normalizeParams(_params);
-    const schema = new Class({
-        type: "custom",
-        check: "custom",
-        fn: fn,
-        ...params,
-    });
-    return schema;
+// custom schema
+function custom(fn, _params) {
+    return core._custom(exports.ZodMiniCustom, fn ?? (() => true), _params);
 }
 // refine
 function refine(fn, _params = {}) {
-    return _custom(fn, _params, exports.ZodMiniCustom);
-}
-// custom schema
-function custom(fn, _params) {
-    return _custom(fn ?? (() => true), _params, exports.ZodMiniCustom);
+    return core._refine(exports.ZodMiniCustom, fn, _params);
 }
 // instanceof
 class Class {

package/dist/esm/v4/classic/schemas.js

@@ -940,7 +940,7 @@ export function custom(fn, _params) {
     return core._custom(ZodCustom, fn ?? (() => true), _params);
 }
 export function refine(fn, _params = {}) {
-    return core._custom(ZodCustom, fn, _params);
+    return core._refine(ZodCustom, fn, _params);
 }
 // superRefine
 export function superRefine(fn, params) {

package/dist/esm/v4/core/api.js

@@ -797,16 +797,32 @@ export function _promise(Class, innerType) {
     });
 }
 export function _custom(Class, fn, _params) {
+    const norm = util.normalizeParams(_params);
+    norm.abort ?? (norm.abort = true); // default to abort:false
     const schema = new Class({
         type: "custom",
         check: "custom",
         fn: fn,
-        ...util.normalizeParams(_params),
+        ...norm,
     });
     return schema;
 }
-export function _refine(Class, fn, _params = {}) {
-    return _custom(Class, fn, _params);
+// export function _refine<T>(
+//   Class: util.SchemaClass<schemas.$ZodCustom>,
+//   fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>,
+//   _params: string | $ZodCustomParams = {}
+// ): checks.$ZodCheck<T> {
+//   return _custom(Class, fn, _params);
+// }
+// same as _custom but deafults to abort:false
+export function _refine(Class, fn, _params) {
+    const schema = new Class({
+        type: "custom",
+        check: "custom",
+        fn: fn,
+        ...util.normalizeParams(_params),
+    });
+    return schema;
 }
 export function _stringbool(Classes, _params) {
     const { case: _case, error, truthy, falsy } = util.normalizeParams(_params);

package/dist/esm/v4/core/checks.js

@@ -437,7 +437,8 @@ export const $ZodCheckUpperCase = /*@__PURE__*/ core.$constructor("$ZodCheckUppe
 });
 export const $ZodCheckIncludes = /*@__PURE__*/ core.$constructor("$ZodCheckIncludes", (inst, def) => {
     $ZodCheck.init(inst, def);
-    const pattern = new RegExp(util.escapeRegex(def.includes));
+    const escapedRegex = util.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;

package/dist/esm/v4/core/doc.js

@@ -30,7 +30,6 @@ export class Doc {
         const content = this?.content ?? [``];
         const lines = [...content.map((x) => `  ${x}`)];
         // console.log(lines.join("\n"));
-        // console.dir("COMPILE", {depth: null});
         return new F(...args, lines.join("\n"));
     }
 }

package/dist/esm/v4/core/to-json-schema.js

@@ -357,9 +357,18 @@ export class JSONSchemaGenerator {
                     }
                     else if (vals.length === 1) {
                         const val = vals[0];
+                        json.type = val === null ? "null" : typeof val;
                         json.const = val;
                     }
                     else {
+                        if (vals.every((v) => typeof v === "number"))
+                            json.type = "number";
+                        if (vals.every((v) => typeof v === "string"))
+                            json.type = "string";
+                        if (vals.every((v) => typeof v === "boolean"))
+                            json.type = "string";
+                        if (vals.every((v) => v === null))
+                            json.type = "null";
                         json.enum = vals;
                     }
                     break;

package/dist/esm/v4/mini/schemas.js

@@ -692,23 +692,13 @@ export function check(fn, params) {
     return ch;
 }
 // ZodCustom
-function _custom(fn, _params, Class) {
-    const params = util.normalizeParams(_params);
-    const schema = new Class({
-        type: "custom",
-        check: "custom",
-        fn: fn,
-        ...params,
-    });
-    return schema;
+// custom schema
+export function custom(fn, _params) {
+    return core._custom(ZodMiniCustom, fn ?? (() => true), _params);
 }
 // refine
 export function refine(fn, _params = {}) {
-    return _custom(fn, _params, ZodMiniCustom);
-}
-// custom schema
-export function custom(fn, _params) {
-    return _custom(fn ?? (() => true), _params, ZodMiniCustom);
+    return core._refine(ZodMiniCustom, fn, _params);
 }
 // instanceof
 class Class {

package/dist/types/v4/core/api.d.ts

@@ -255,7 +255,7 @@ export type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, "innerType">;
 export declare function _promise<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodPromise>, innerType: T): schemas.$ZodPromise<T>;
 export type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, "fn">;
 export declare function _custom<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
-export declare function _refine<T>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | $ZodCustomParams): checks.$ZodCheck<T>;
+export declare function _refine<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;
 export interface $ZodStringBoolParams extends TypeParams {
     truthy?: string[];
     falsy?: string[];

package/dist/types/v4/mini/schemas.d.ts

@@ -375,8 +375,8 @@ export interface ZodMiniCustom<O = unknown, I = unknown> extends ZodMiniType {
 }
 export declare const ZodMiniCustom: core.$constructor<ZodMiniCustom>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$ZodCustomParams): core.$ZodCheck<O>;
-export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
 export declare function custom<O = unknown, I = O>(fn?: (data: O) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodMiniCustom<O, I>;
+export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
 declare abstract class Class {
     constructor(..._args: any[]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.25.48",
+  "version": "3.25.49",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",