zod 4.2.0-canary.20251213T203150 → 4.2.0

package/src/v4/core/schemas.ts

@@ -2012,6 +2012,7 @@ export type $InferUnionInput<T extends SomeType> = T extends any ? core.input<T>
 export interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
   type: "union";
   options: Options;
+  inclusive?: boolean;
 }
 
 type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
@@ -2119,6 +2120,85 @@ export const $ZodUnion: core.$constructor<$ZodUnion> = /*@__PURE__*/ core.$const
   };
 });
 
+function handleExclusiveUnionResults(
+  results: ParsePayload[],
+  final: ParsePayload,
+  inst: $ZodUnion,
+  ctx?: ParseContext
+) {
+  const successes = results.filter((r) => r.issues.length === 0);
+
+  if (successes.length === 1) {
+    final.value = successes[0].value;
+    return final;
+  }
+
+  if (successes.length === 0) {
+    // No matches - same as regular union
+    final.issues.push({
+      code: "invalid_union",
+      input: final.value,
+      inst,
+      errors: results.map((result) => result.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config()))),
+    });
+  } else {
+    // Multiple matches - exclusive union failure
+    final.issues.push({
+      code: "invalid_union",
+      input: final.value,
+      inst,
+      errors: [],
+      inclusive: false,
+    });
+  }
+
+  return final;
+}
+
+export interface $ZodXorInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionInternals<T> {}
+
+export interface $ZodXor<T extends readonly SomeType[] = readonly $ZodType[]>
+  extends $ZodType<any, any, $ZodXorInternals<T>> {
+  _zod: $ZodXorInternals<T>;
+}
+
+export const $ZodXor: core.$constructor<$ZodXor> = /*@__PURE__*/ core.$constructor("$ZodXor", (inst, def) => {
+  $ZodUnion.init(inst, def);
+  def.inclusive = false;
+
+  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: util.MaybeAsync<ParsePayload>[] = [];
+    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 {
+        results.push(result);
+      }
+    }
+
+    if (!async) return handleExclusiveUnionResults(results as ParsePayload[], payload, inst, ctx);
+    return Promise.all(results).then((results) => {
+      return handleExclusiveUnionResults(results as ParsePayload[], payload, inst, ctx);
+    });
+  };
+});
+
 //////////////////////////////////////////////////////
 //////////////////////////////////////////////////////
 //////////                                  //////////
@@ -2153,6 +2233,8 @@ export interface $ZodDiscriminatedUnion<
 export const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion> =
   /*@__PURE__*/
   core.$constructor("$ZodDiscriminatedUnion", (inst, def) => {
+    def.inclusive = false;
+
     $ZodUnion.init(inst, def);
 
     const _super = inst._zod.parse;
@@ -2525,6 +2607,8 @@ export interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value
   type: "record";
   keyType: Key;
   valueType: Value;
+  /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
+  mode?: "strict" | "loose";
 }
 
 // export type $InferZodRecordOutput<
@@ -2652,16 +2736,21 @@ export const $ZodRecord: core.$constructor<$ZodRecord> = /*@__PURE__*/ core.$con
         }
 
         if (keyResult.issues.length) {
-          payload.issues.push({
-            code: "invalid_key",
-
-            origin: "record",
-            issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
-            input: key,
-            path: [key],
-            inst,
-          });
-          payload.value[keyResult.value as PropertyKey] = keyResult.value;
+          if (def.mode === "loose") {
+            // Pass through unchanged
+            payload.value[key] = input[key];
+          } else {
+            // Default "strict" behavior: error on invalid key
+            payload.issues.push({
+              code: "invalid_key",
+
+              origin: "record",
+              issues: keyResult.issues.map((iss) => util.finalizeIssue(iss, ctx, core.config())),
+              input: key,
+              path: [key],
+              inst,
+            });
+          }
           continue;
         }
 

package/src/v4/core/versions.ts

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

package/src/v4/mini/external.ts

@@ -17,11 +17,11 @@ export {
   prettifyError,
   formatError,
   flattenError,
-  toJSONSchema,
   TimePrecision,
   util,
   NEVER,
 } 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/src/v4/mini/schemas.ts

@@ -951,6 +951,31 @@ export function union<const T extends readonly SomeType[]>(
   }) as any;
 }
 
+// ZodMiniXor
+export interface ZodMiniXor<T extends readonly SomeType[] = readonly core.$ZodType[]>
+  extends _ZodMiniType<core.$ZodXorInternals<T>> {
+  // _zod: core.$ZodXorInternals<T>;
+}
+export const ZodMiniXor: core.$constructor<ZodMiniXor> = /*@__PURE__*/ core.$constructor("ZodMiniXor", (inst, def) => {
+  ZodMiniUnion.init(inst, def);
+  core.$ZodXor.init(inst, def);
+});
+
+/** Creates an exclusive union (XOR) where exactly one option must match.
+ * Unlike regular unions that succeed when any option matches, xor fails if
+ * zero or more than one option matches the input. */
+export function xor<const T extends readonly SomeType[]>(
+  options: T,
+  params?: string | core.$ZodXorParams
+): ZodMiniXor<T> {
+  return new ZodMiniXor({
+    type: "union",
+    options: options as any as core.$ZodType[],
+    inclusive: false,
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
 // ZodMiniDiscriminatedUnion
 export interface ZodMiniDiscriminatedUnion<
   Options extends readonly SomeType[] = readonly core.$ZodType[],
@@ -1086,6 +1111,20 @@ export function partialRecord<Key extends core.$ZodRecordKey, Value extends Some
   }) as any;
 }
 
+export function looseRecord<Key extends core.$ZodRecordKey, Value extends SomeType>(
+  keyType: Key,
+  valueType: Value,
+  params?: string | core.$ZodRecordParams
+): ZodMiniRecord<Key, Value> {
+  return new ZodMiniRecord({
+    type: "record",
+    keyType,
+    valueType: valueType as any as core.$ZodType,
+    mode: "loose",
+    ...util.normalizeParams(params),
+  }) as any;
+}
+
 // ZodMiniMap
 export interface ZodMiniMap<Key extends SomeType = core.$ZodType, Value extends SomeType = core.$ZodType>
   extends _ZodMiniType<core.$ZodMapInternals<Key, Value>> {

package/v4/classic/external.cjs

@@ -29,7 +29,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.coerce = exports.iso = exports.ZodISODuration = exports.ZodISOTime = exports.ZodISODate = exports.ZodISODateTime = exports.locales = exports.NEVER = exports.util = exports.TimePrecision = exports.toJSONSchema = exports.flattenError = exports.formatError = exports.prettifyError = exports.treeifyError = exports.regexes = exports.clone = exports.$brand = exports.$input = exports.$output = exports.config = exports.registry = exports.globalRegistry = exports.core = void 0;
+exports.coerce = exports.iso = exports.ZodISODuration = exports.ZodISOTime = exports.ZodISODate = exports.ZodISODateTime = exports.locales = exports.fromJSONSchema = exports.toJSONSchema = exports.NEVER = exports.util = exports.TimePrecision = exports.flattenError = exports.formatError = exports.prettifyError = exports.treeifyError = exports.regexes = exports.clone = exports.$brand = exports.$input = exports.$output = exports.config = exports.registry = exports.globalRegistry = exports.core = void 0;
 exports.core = __importStar(require("../core/index.cjs"));
 __exportStar(require("./schemas.cjs"), exports);
 __exportStar(require("./checks.cjs"), exports);
@@ -53,10 +53,13 @@ Object.defineProperty(exports, "treeifyError", { enumerable: true, get: function
 Object.defineProperty(exports, "prettifyError", { enumerable: true, get: function () { return index_js_2.prettifyError; } });
 Object.defineProperty(exports, "formatError", { enumerable: true, get: function () { return index_js_2.formatError; } });
 Object.defineProperty(exports, "flattenError", { enumerable: true, get: function () { return index_js_2.flattenError; } });
-Object.defineProperty(exports, "toJSONSchema", { enumerable: true, get: function () { return index_js_2.toJSONSchema; } });
 Object.defineProperty(exports, "TimePrecision", { enumerable: true, get: function () { return index_js_2.TimePrecision; } });
 Object.defineProperty(exports, "util", { enumerable: true, get: function () { return index_js_2.util; } });
 Object.defineProperty(exports, "NEVER", { enumerable: true, get: function () { return index_js_2.NEVER; } });
+var json_schema_processors_js_1 = require("../core/json-schema-processors.cjs");
+Object.defineProperty(exports, "toJSONSchema", { enumerable: true, get: function () { return json_schema_processors_js_1.toJSONSchema; } });
+var from_json_schema_js_1 = require("./from-json-schema.cjs");
+Object.defineProperty(exports, "fromJSONSchema", { enumerable: true, get: function () { return from_json_schema_js_1.fromJSONSchema; } });
 exports.locales = __importStar(require("../locales/index.cjs"));
 // iso
 // must be exported from top-level

package/v4/classic/external.d.cts

@@ -5,7 +5,9 @@ export * from "./errors.cjs";
 export * from "./parse.cjs";
 export * from "./compat.cjs";
 export type { infer, output, input } from "../core/index.cjs";
-export { globalRegistry, type GlobalMeta, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, toJSONSchema, TimePrecision, util, NEVER, } from "../core/index.cjs";
+export { globalRegistry, type GlobalMeta, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, } from "../core/index.cjs";
+export { toJSONSchema } from "../core/json-schema-processors.cjs";
+export { fromJSONSchema } from "./from-json-schema.cjs";
 export * as locales from "../locales/index.cjs";
 export { ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration } from "./iso.cjs";
 export * as iso from "./iso.cjs";

package/v4/classic/external.d.ts

@@ -5,7 +5,9 @@ export * from "./errors.js";
 export * from "./parse.js";
 export * from "./compat.js";
 export type { infer, output, input } from "../core/index.js";
-export { globalRegistry, type GlobalMeta, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, toJSONSchema, TimePrecision, util, NEVER, } from "../core/index.js";
+export { globalRegistry, type GlobalMeta, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, } from "../core/index.js";
+export { toJSONSchema } from "../core/json-schema-processors.js";
+export { fromJSONSchema } from "./from-json-schema.js";
 export * as locales from "../locales/index.js";
 export { ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration } from "./iso.js";
 export * as iso from "./iso.js";

package/v4/classic/external.js

@@ -8,7 +8,9 @@ export * from "./compat.js";
 import { config } from "../core/index.js";
 import en from "../locales/en.js";
 config(en());
-export { globalRegistry, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, toJSONSchema, TimePrecision, util, NEVER, } from "../core/index.js";
+export { globalRegistry, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, } from "../core/index.js";
+export { toJSONSchema } from "../core/json-schema-processors.js";
+export { fromJSONSchema } from "./from-json-schema.js";
 export * as locales from "../locales/index.js";
 // iso
 // must be exported from top-level