cross-seed 7.0.0-21 → 7.0.0-23

package/node_modules/zod/src/v3/tests/partials.test.ts

@@ -21,7 +21,7 @@ test("shallow inference", () => {
     name?: string | undefined;
     age?: number | undefined;
     outer?: { inner: string } | undefined;
-    array?: { asdf: string }[];
+    array?: { asdf: string }[] | undefined;
   };
   util.assertEqual<shallow, correct>(true);
 });
@@ -41,7 +41,7 @@ test("deep partial inference", () => {
   asdf.parse("asdf");
   type deep = z.infer<typeof deep>;
   type correct = {
-    array?: { asdf?: string }[];
+    array?: { asdf?: string | undefined }[] | undefined;
     name?: string | undefined;
     age?: number | undefined;
     outer?: { inner?: string | undefined } | undefined;
@@ -118,7 +118,7 @@ test("deep partial inference", () => {
           asdf?: string | undefined;
         }[]
       | undefined;
-    tuple?: [{ value?: string }] | undefined;
+    tuple?: [{ value?: string | undefined }] | undefined;
   };
   util.assertEqual<expected, partialed>(true);
 });

package/node_modules/zod/src/v3/tests/readonly.test.ts

@@ -61,86 +61,6 @@ test("flat inference", () => {
   util.assertEqual<z.infer<(typeof schemas)[20]>, Promise<string>>(true);
 });
 
-// test("deep inference", () => {
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[0]>, string>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[1]>, number>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[2]>, number>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[3]>, bigint>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[4]>, boolean>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[5]>, Date>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[6]>, undefined>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[7]>, null>(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[8]>, any>(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[9]>,
-//     Readonly<unknown>
-//   >(true);
-//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[10]>, void>(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[11]>,
-//     (args_0: string, args_1: number, ...args_2: unknown[]) => unknown
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[12]>,
-//     readonly string[]
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[13]>,
-//     readonly [string, number]
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[14]>,
-//     ReadonlyMap<string, Date>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[15]>,
-//     ReadonlySet<Promise<string>>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[16]>,
-//     Readonly<Record<string, string>>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[17]>,
-//     Readonly<Record<string, number>>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[18]>,
-//     { readonly a: string; readonly 1: number }
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[19]>,
-//     Readonly<testEnum>
-//   >(true);
-//   util.assertEqual<
-//     z.infer<(typeof deepReadonlySchemas_0)[20]>,
-//     Promise<string>
-//   >(true);
-
-//   util.assertEqual<
-//     z.infer<typeof crazyDeepReadonlySchema>,
-//     ReadonlyMap<
-//       ReadonlySet<readonly [string, number]>,
-//       {
-//         readonly a: {
-//           readonly [x: string]: readonly any[];
-//         };
-//         readonly b: {
-//           readonly c: {
-//             readonly d: {
-//               readonly e: {
-//                 readonly f: {
-//                   readonly g?: {};
-//                 };
-//               };
-//             };
-//           };
-//         };
-//       }
-//     >
-//   >(true);
-// });
-
 test("object freezing", () => {
   expect(Object.isFrozen(z.array(z.string()).readonly().parse(["a"]))).toBe(true);
   expect(Object.isFrozen(z.tuple([z.string(), z.number()]).readonly().parse(["a", 1]))).toBe(true);

package/node_modules/zod/src/v3/tests/string.test.ts

@@ -323,6 +323,7 @@ test("url error overrides", () => {
 test("emoji validations", () => {
   const emoji = z.string().emoji();
 
+  emoji.parse("🦰🦱🦲🦳"); // both Extended_Pictographic and Emoji_Component
   emoji.parse("👋👋👋👋");
   emoji.parse("🍺👩‍🚀🫡");
   emoji.parse("💚💙💜💛❤️");
@@ -335,6 +336,11 @@ test("emoji validations", () => {
   expect(() => emoji.parse("😀 is an emoji")).toThrow();
   expect(() => emoji.parse("😀stuff")).toThrow();
   expect(() => emoji.parse("stuff😀")).toThrow();
+
+  // a failing match over the overlapping code points used to backtrack exponentially
+  const start = performance.now();
+  expect(emoji.safeParse(`${"🦰".repeat(26)} `).success).toBe(false);
+  expect(performance.now() - start).toBeLessThan(100);
 });
 
 test("uuid", () => {

package/node_modules/zod/src/v3/types.ts

@@ -619,7 +619,7 @@ const emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z
 //   /^[a-z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-z0-9-]+(?:\.[a-z0-9\-]+)*$/i;
 
 // from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression
-const _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+const _emojiRegex = `^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`;
 let emojiRegex: RegExp;
 
 // faster, simpler, safer
@@ -3249,7 +3249,9 @@ function mergeValues(a: any, b: any): { valid: true; data: any } | { valid: fals
     const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
 
     const newObj: any = { ...a, ...b };
+    if (Object.prototype.hasOwnProperty.call(newObj, "__proto__")) delete newObj.__proto__;
     for (const key of sharedKeys) {
+      if (key === "__proto__") continue;
       const sharedValue = mergeValues(a[key], b[key]);
       if (!sharedValue.valid) {
         return { valid: false };
@@ -3862,8 +3864,7 @@ export class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTyp
     const fn = ctx.data;
 
     if (this._def.returns instanceof ZodPromise) {
-      // Would love a way to avoid disabling this rule, but we need
-      // an alias (using an arrow function was what caused 2651).
+      // Would love a way to avoid disabling this rule, but we need an alias (using an arrow function was what caused 2651).
       // eslint-disable-next-line @typescript-eslint/no-this-alias
       const me = this;
       return OK(async function (this: any, ...args: any[]) {
@@ -3882,8 +3883,7 @@ export class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTyp
         return parsedReturns;
       });
     } else {
-      // Would love a way to avoid disabling this rule, but we need
-      // an alias (using an arrow function was what caused 2651).
+      // Would love a way to avoid disabling this rule, but we need an alias (using an arrow function was what caused 2651).
       // eslint-disable-next-line @typescript-eslint/no-this-alias
       const me = this;
       return OK(function (this: any, ...args: any[]) {

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

@@ -21,6 +21,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/classic/compat.ts

@@ -3,14 +3,12 @@
 import * as core from "../core/index.js";
 import type { ZodType } from "./schemas.js";
 
-export type {
-  /** @deprecated Use `z.output<T>` instead. */
-  output as TypeOf,
-  /** @deprecated Use `z.output<T>` instead. */
-  output as Infer,
-  /** @deprecated Use `z.core.$$ZodFirstPartyTypes` instead */
-  $ZodTypes as ZodFirstPartySchemaTypes,
-} from "../core/index.js";
+/** @deprecated Use `z.output<T>` instead. */
+export type TypeOf<T> = core.output<T>;
+/** @deprecated Use `z.output<T>` instead. */
+export type Infer<T> = core.output<T>;
+/** @deprecated Use `z.core.$ZodTypes` instead */
+export type ZodFirstPartySchemaTypes = core.$ZodTypes;
 
 /** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
 export const ZodIssueCode = {
@@ -27,10 +25,10 @@ export const ZodIssueCode = {
   custom: "custom",
 } as const;
 
-/** @deprecated Use `z.$ZodFlattenedError` */
+/** @deprecated Use `z.core.$ZodFlattenedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
 export type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;
 
-/** @deprecated Use `z.$ZodFormattedError` */
+/** @deprecated Use `z.core.$ZodFormattedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
 export type inferFormattedError<T extends core.$ZodType<any, any>, U = string> = core.$ZodFormattedError<
   core.output<T>,
   U
@@ -54,14 +52,24 @@ export function getErrorMap(): core.$ZodErrorMap<core.$ZodIssue> | undefined {
   return core.config().customError;
 }
 
-export type {
-  /** @deprecated Use z.ZodType (without generics) instead. */
-  ZodType as ZodTypeAny,
-  /** @deprecated Use `z.ZodType` */
-  ZodType as ZodSchema,
-  /** @deprecated Use `z.ZodType` */
-  ZodType as Schema,
-};
+/** @deprecated Use z.ZodType (without generics) instead. */
+export type ZodTypeAny<
+  Output = unknown,
+  Input = unknown,
+  Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>,
+> = ZodType<Output, Input, Internals>;
+/** @deprecated Use `z.ZodType` */
+export type ZodSchema<
+  Output = unknown,
+  Input = unknown,
+  Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>,
+> = ZodType<Output, Input, Internals>;
+/** @deprecated Use `z.ZodType` */
+export type Schema<
+  Output = unknown,
+  Input = unknown,
+  Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>,
+> = ZodType<Output, Input, Internals>;
 
 /** Included for Zod 3 compatibility */
 export type ZodRawShape = core.$ZodShape;

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

@@ -0,0 +1,76 @@
+import type * as core from "../core/index.js";
+import { visit } from "../core/visit.js";
+import * as schemas from "./schemas.js";
+
+/** Distributes `.partial()` through every object in a schema type, preserving the wrappers around them. */
+// biome-ignore format: preserve vertical layout for readability.
+export type DeepPartial<T extends core.SomeType> =
+  T extends schemas.ZodObject<infer Shape, infer Config>
+    ? schemas.ZodObject<
+        { -readonly [K in keyof Shape]: schemas.ZodOptional<DeepPartial<Shape[K]>> },
+        Config
+      >
+  // Must precede ZodUnion; degrades to it, matching the runtime.
+  : T extends schemas.ZodDiscriminatedUnion<infer Options, any>
+    ? schemas.ZodUnion<
+        { -readonly [I in keyof Options]: Options[I] extends core.SomeType ? DeepPartial<Options[I]> : Options[I] }
+      >
+  : T extends schemas.ZodUnion<infer Options>
+    ? schemas.ZodUnion<
+        { -readonly [I in keyof Options]: Options[I] extends core.SomeType ? DeepPartial<Options[I]> : Options[I] }
+      >
+  : T extends schemas.ZodArray<infer El>
+    ? schemas.ZodArray<DeepPartial<El>>
+  : T extends schemas.ZodTuple<infer Items, infer Rest>
+    ? schemas.ZodTuple<
+        { -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.ZodIntersection<infer A, infer B>
+    ? schemas.ZodIntersection<DeepPartial<A>, DeepPartial<B>>
+  : T extends schemas.ZodRecord<infer K, infer V>
+    ? schemas.ZodRecord<K, DeepPartial<V>>
+  : T extends schemas.ZodMap<infer K, infer V>
+    ? schemas.ZodMap<K, DeepPartial<V>>
+  : T extends schemas.ZodSet<infer El>
+    ? schemas.ZodSet<DeepPartial<El>>
+  : T extends schemas.ZodOptional<infer Inner>
+    ? schemas.ZodOptional<DeepPartial<Inner>>
+  : T extends schemas.ZodNullable<infer Inner>
+    ? schemas.ZodNullable<DeepPartial<Inner>>
+  : T extends schemas.ZodDefault<infer Inner>
+    ? schemas.ZodDefault<DeepPartial<Inner>>
+  : T extends schemas.ZodPrefault<infer Inner>
+    ? schemas.ZodPrefault<DeepPartial<Inner>>
+  : T extends schemas.ZodNonOptional<infer Inner>
+    ? schemas.ZodNonOptional<DeepPartial<Inner>>
+  : T extends schemas.ZodCatch<infer Inner>
+    ? schemas.ZodCatch<DeepPartial<Inner>>
+  : T extends schemas.ZodReadonly<infer Inner>
+    ? schemas.ZodReadonly<DeepPartial<Inner>>
+  : T extends schemas.ZodSuccess<infer Inner>
+    ? schemas.ZodSuccess<DeepPartial<Inner>>
+  : T extends schemas.ZodPromise<infer Inner>
+    ? schemas.ZodPromise<DeepPartial<Inner>>
+  // Must precede ZodPipe, which both extend structurally, or the subtype is lost.
+  : T extends schemas.ZodCodec<infer A, infer B>
+    ? schemas.ZodCodec<DeepPartial<A>, DeepPartial<B>>
+  : T extends schemas.ZodPreprocess<infer B>
+    ? schemas.ZodPreprocess<DeepPartial<B>>
+  : T extends schemas.ZodPipe<infer A, infer B>
+    ? schemas.ZodPipe<DeepPartial<A>, DeepPartial<B>>
+  : T extends schemas.ZodLazy<infer Inner>
+    ? schemas.ZodLazy<DeepPartial<Inner>>
+  : T;
+
+/** Returns a copy of the schema with every nested object's properties made optional. */
+export function deepPartial<T extends core.SomeType>(schema: T): DeepPartial<T> {
+  return visit(schema, {
+    object: (s) => (s as schemas.ZodObject).partial(),
+    // Every partialed option now admits `undefined`, which the constructor rejects as a duplicate.
+    union: (s) => {
+      const def = s._zod.def as core.$ZodDiscriminatedUnionDef;
+      return def.discriminator === undefined ? s : schemas.union(def.options as schemas.ZodType[]);
+    },
+  }) as unknown as DeepPartial<T>;
+}

package/node_modules/zod/src/v4/classic/errors.ts

@@ -22,58 +22,73 @@ export interface ZodError<T = unknown> extends $ZodError<T> {
   isEmpty: boolean;
 }
 
+/* Prototypes that already carry the lazy helper methods. Seeded with the
+ * intrinsics so that `init` on a foreign object — it accepts any object —
+ * can never install an accessor onto a prototype we do not own. */
+const _installedErrorProtos = /* @__PURE__ */ new WeakSet<object>([Object.prototype, Error.prototype]);
+
+/* Helper methods live as non-enumerable lazy getters on the shared
+ * prototype instead of own properties on every instance. On first
+ * access the getter allocates the per-instance closure and caches it
+ * as a non-enumerable own property, so detached usage still works and
+ * the allocation only happens for methods actually touched. */
+function _lazyMethod(proto: object, key: string, make: (self: ZodError) => unknown): void {
+  Object.defineProperty(proto, key, {
+    configurable: true,
+    enumerable: false,
+    get(this: ZodError) {
+      const value = make(this);
+      Object.defineProperty(this, key, { value, configurable: true, writable: true });
+      return value;
+    },
+    set(this: ZodError, value: unknown) {
+      Object.defineProperty(this, key, { value, configurable: true, writable: true });
+    },
+  });
+}
+
 const initializer = (inst: ZodError, issues: core.$ZodIssue[]) => {
   $ZodError.init(inst, issues);
   inst.name = "ZodError";
-  Object.defineProperties(inst, {
-    format: {
-      value: (mapper: any) => core.formatError(inst, mapper),
-      // enumerable: false,
-    },
-    flatten: {
-      value: (mapper: any) => core.flattenError(inst, mapper),
-      // enumerable: false,
-    },
-    addIssue: {
-      value: (issue: any) => {
-        inst.issues.push(issue);
-        inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);
-      },
-      // enumerable: false,
-    },
-    addIssues: {
-      value: (issues: any) => {
-        inst.issues.push(...issues);
-        inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);
-      },
-      // enumerable: false,
-    },
-    isEmpty: {
-      get() {
-        return inst.issues.length === 0;
-      },
-      // enumerable: false,
+
+  const proto = Object.getPrototypeOf(inst);
+  if (_installedErrorProtos.has(proto)) return;
+  _installedErrorProtos.add(proto);
+
+  _lazyMethod(proto, "format", (self) => (mapper: any) => core.formatError(self, mapper));
+  _lazyMethod(proto, "flatten", (self) => (mapper: any) => core.flattenError(self, mapper));
+  _lazyMethod(proto, "addIssue", (self) => (issue: any) => {
+    self.issues.push(issue);
+    self.message = JSON.stringify(self.issues, util.jsonStringifyReplacer, 2);
+  });
+  _lazyMethod(proto, "addIssues", (self) => (issues: any) => {
+    self.issues.push(...issues);
+    self.message = JSON.stringify(self.issues, util.jsonStringifyReplacer, 2);
+  });
+  Object.defineProperty(proto, "isEmpty", {
+    configurable: true,
+    enumerable: false,
+    get(this: ZodError) {
+      return this.issues.length === 0;
     },
   });
-  // Object.defineProperty(inst, "isEmpty", {
-  //   get() {
-  //     return inst.issues.length === 0;
-  //   },
-  // });
 };
-export const ZodError: core.$constructor<ZodError> = core.$constructor("ZodError", initializer);
-export const ZodRealError: core.$constructor<ZodError> = core.$constructor("ZodError", initializer, {
-  Parent: Error,
-});
+export const ZodError: core.$constructor<ZodError> = /*@__PURE__*/ core.$constructor("ZodError", initializer);
+export const ZodRealError: core.$constructor<ZodError> = /*@__PURE__*/ core.$constructor(
+  "ZodError",
+  initializer,
+  undefined,
+  {
+    Parent: Error,
+  }
+);
 
-export type {
-  /** @deprecated Use `z.core.$ZodFlattenedError` instead. */
-  $ZodFlattenedError as ZodFlattenedError,
-  /** @deprecated Use `z.core.$ZodFormattedError` instead. */
-  $ZodFormattedError as ZodFormattedError,
-  /** @deprecated Use `z.core.$ZodErrorMap` instead. */
-  $ZodErrorMap as ZodErrorMap,
-} from "../core/index.js";
+/** @deprecated Use `z.core.$ZodFlattenedError` instead. */
+export type ZodFlattenedError<T, U = string> = core.$ZodFlattenedError<T, U>;
+/** @deprecated Use `z.core.$ZodFormattedError` instead. */
+export type ZodFormattedError<T, U = string> = core.$ZodFormattedError<T, U>;
+/** @deprecated Use `z.core.$ZodErrorMap` instead. */
+export type ZodErrorMap<T extends core.$ZodIssueBase = core.$ZodIssue> = core.$ZodErrorMap<T>;
 
 /** @deprecated Use `z.core.$ZodRawIssue` instead. */
 export type IssueData = core.$ZodRawIssue;

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

@@ -5,17 +5,15 @@ export * from "./errors.js";
 export * from "./parse.js";
 export * from "./compat.js";
 
-// zod-specified
-import { config } from "../core/index.js";
-import en from "../locales/en.js";
-config(en());
-
-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,
   type GlobalMeta,
   registry,
   config,
+  memoizer,
   $output,
   $input,
   $brand,
@@ -28,15 +26,23 @@ export {
   TimePrecision,
   util,
   NEVER,
+  INVALID,
+  toZod,
+  compile,
+  withParser,
+  ZodCompileAsyncError,
+  ZodCompileUnsupportedError,
+  getDiscriminatedOption,
 } from "../core/index.js";
 export { toJSONSchema } from "../core/json-schema-processors.js";
 export { fromJSONSchema } from "./from-json-schema.js";
+export { deepPartial } from "./deep-partial.js";
+// Types and values both, from one module — re-exporting the types from core would collide.
+export { input, output } from "./in-out.js";
 
 export * as locales from "../locales/index.js";
 
-// iso
-// must be exported from top-level
-// https://github.com/colinhacks/zod/issues/4491
+// iso must be exported from top-level https://github.com/colinhacks/zod/issues/4491
 export { ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration } from "./iso.js";
 export * as iso from "./iso.js";