zod-compare 2.0.0 → 2.0.1

package/dist/index.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./is-compatible-type-BA3YzVJ3.cjs"),s=require("./is-compatible-type-CN9ljc9s.cjs"),i=e=>!!(o.isLegacyZodFunction(e)||"_zod"in e),t=e=>!i(e),n=(e,r)=>!!(t(e)&&t(r)||i(e)&&i(r)),p=(e,r)=>{if(i(e)&&i(r))return o.isSameType(e,r);if(t(e)&&t(r))return s.isSameType(e,r);throw new Error("Failed to compare types: different Zod versions")},a=(e,r)=>{if(i(e)&&i(r))return o.isCompatibleType(e,r);if(t(e)&&t(r))return s.isCompatibleType(e,r);throw new Error("Failed to compare types: different Zod versions")};exports.haveSameZodMajor=n;exports.isCompatibleType=a;exports.isSameType=p;exports.isZod3Schema=t;exports.isZod4Schema=i;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./is-compatible-type-BA3YzVJ3.cjs"),n=require("./is-compatible-type-CN9ljc9s.cjs"),i=e=>!!(o.isLegacyZodFunction(e)||"_zod"in e),t=e=>!i(e),p=(e,r)=>!!(t(e)&&t(r)||i(e)&&i(r)),a=(e,r,s)=>{if(i(e)&&i(r))return o.isSameType(e,r,s);if(t(e)&&t(r))return n.isSameType(e,r,s);throw new Error("Failed to compare types: different Zod versions")},u=(e,r)=>{if(i(e)&&i(r))return o.isCompatibleType(e,r);if(t(e)&&t(r))return n.isCompatibleType(e,r);throw new Error("Failed to compare types: different Zod versions")};exports.haveSameZodMajor=p;exports.isCompatibleType=u;exports.isSameType=a;exports.isZod3Schema=t;exports.isZod4Schema=i;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":["../src/utils.ts","../src/index.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport { isLegacyZodFunction, type LegacyZodFunction } from \"./zod4/compat.ts\";\n\n/**\n * See https://zod.dev/library-authors?id=how-to-support-zod-3-and-zod-4-simultaneously\n */\nexport const isZod4Schema = (\n  schema: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): schema is z4.$ZodType => {\n  if (isLegacyZodFunction(schema)) {\n    // version >= v4.0 && <4.1\n    return true;\n  }\n  if (\"_zod\" in schema) {\n    // This is a Zod 4 schema\n    // You can access the schema definition using `schema._zod.def`\n    return true;\n  } else {\n    // This is a Zod 3 schema\n    // You can access the schema definition using `schema._def`\n    return false;\n  }\n};\n\nexport const isZod3Schema = (\n  schema: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): schema is z3.ZodTypeAny => !isZod4Schema(schema);\n\nexport const haveSameZodMajor = (\n  schemaA: z3.ZodTypeAny | z4.$ZodType,\n  schemaB: z3.ZodTypeAny | z4.$ZodType,\n): boolean => {\n  if (isZod3Schema(schemaA) && isZod3Schema(schemaB)) {\n    return true; // Both are Zod 3 schemas\n  }\n  if (isZod4Schema(schemaA) && isZod4Schema(schemaB)) {\n    return true; // Both are Zod 4 schemas\n  }\n  return false; // One is Zod 3 and the other is Zod 4\n};\n","import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport { haveSameZodMajor, isZod3Schema, isZod4Schema } from \"./utils.ts\";\nimport {\n  isCompatibleType as isCompatibleZod3Type,\n  isSameType as isSameZod3Type,\n} from \"./zod3/index.ts\";\nimport type { LegacyZodFunction } from \"./zod4/compat.ts\";\nimport {\n  isCompatibleType as isCompatibleZod4Type,\n  isSameType as isSameZod4Type,\n} from \"./zod4/index.ts\";\n\n// Export versions checking utilities\nexport { haveSameZodMajor, isZod3Schema, isZod4Schema };\n\n/**\n * isSameType is a function that checks if two ZodTypes are the same.\n *\n * Caveats:\n * - The function does not validate specific criteria such as min or max values, length, email, etc.\n * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().\n *\n * @param a - The first ZodType to compare.\n * @param b - The second ZodType to compare.\n * @returns A boolean indicating whether the two types are the same.\n *\n * @throws Will throw an error if it encounters an unknown type.\n *\n * @example\n * ```ts\n * isSameType(z.string(), z.string()); // true\n * isSameType(z.string(), z.number()); // false\n * ```\n */\nexport const isSameType = (\n  a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n  b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): boolean => {\n  if (isZod4Schema(a) && isZod4Schema(b)) {\n    return isSameZod4Type(a, b);\n  }\n  if (isZod3Schema(a) && isZod3Schema(b)) {\n    return isSameZod3Type(a, b);\n  }\n  throw new Error(\"Failed to compare types: different Zod versions\");\n};\n\n/**\n * Check if a the higherType matches the lowerType\n *\n * @deprecated This a unstable API and still in development\n *\n * @param higherType The looser type\n * @param lowerType The stricter type\n *\n * @example\n * ```ts\n * isCompatibleType(z.string(), z.string()); // true\n *\n * isCompatibleType(\n *   z.object({ name: z.string(), other: z.number() }),\n *   z.object({ name: z.string() })\n * );\n * // true\n * ```\n */\nexport const isCompatibleType = (\n  a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n  b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): boolean => {\n  if (isZod4Schema(a) && isZod4Schema(b)) {\n    return isCompatibleZod4Type(a, b);\n  }\n  if (isZod3Schema(a) && isZod3Schema(b)) {\n    return isCompatibleZod3Type(a, b);\n  }\n  throw new Error(\"Failed to compare types: different Zod versions\");\n};\n"],"names":["isZod4Schema","schema","isLegacyZodFunction","isZod3Schema","haveSameZodMajor","schemaA","schemaB","isSameType","a","b","isSameZod4Type","isSameZod3Type","isCompatibleType","isCompatibleZod4Type","isCompatibleZod3Type"],"mappings":"oLAOaA,EACXC,GAEIC,GAAAA,EAAAA,oBAAoBD,CAAM,GAI1B,SAAUA,GAWHE,EACXF,GAC4B,CAACD,EAAaC,CAAM,EAErCG,EAAmB,CAC9BC,EACAC,IAEI,GAAAH,EAAaE,CAAO,GAAKF,EAAaG,CAAO,GAG7CN,EAAaK,CAAO,GAAKL,EAAaM,CAAO,GCDtCC,EAAa,CACxBC,EACAC,IACY,CACZ,GAAIT,EAAaQ,CAAC,GAAKR,EAAaS,CAAC,EACnC,OAAOC,EAAAA,WAAeF,EAAGC,CAAC,EAE5B,GAAIN,EAAaK,CAAC,GAAKL,EAAaM,CAAC,EACnC,OAAOE,EAAAA,WAAeH,EAAGC,CAAC,EAE5B,MAAM,IAAI,MAAM,iDAAiD,CACnE,EAqBaG,EAAmB,CAC9BJ,EACAC,IACY,CACZ,GAAIT,EAAaQ,CAAC,GAAKR,EAAaS,CAAC,EACnC,OAAOI,EAAAA,iBAAqBL,EAAGC,CAAC,EAElC,GAAIN,EAAaK,CAAC,GAAKL,EAAaM,CAAC,EACnC,OAAOK,EAAAA,iBAAqBN,EAAGC,CAAC,EAElC,MAAM,IAAI,MAAM,iDAAiD,CACnE"}
+{"version":3,"file":"index.cjs","sources":["../src/utils.ts","../src/index.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport { isLegacyZodFunction, type LegacyZodFunction } from \"./zod4/compat.ts\";\n\n/**\n * See https://zod.dev/library-authors?id=how-to-support-zod-3-and-zod-4-simultaneously\n */\nexport const isZod4Schema = (\n  schema: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): schema is z4.$ZodType => {\n  if (isLegacyZodFunction(schema)) {\n    // version >= v4.0 && <4.1\n    return true;\n  }\n  if (\"_zod\" in schema) {\n    // This is a Zod 4 schema\n    // You can access the schema definition using `schema._zod.def`\n    return true;\n  } else {\n    // This is a Zod 3 schema\n    // You can access the schema definition using `schema._def`\n    return false;\n  }\n};\n\nexport const isZod3Schema = (\n  schema: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): schema is z3.ZodTypeAny => !isZod4Schema(schema);\n\nexport const haveSameZodMajor = (\n  schemaA: z3.ZodTypeAny | z4.$ZodType,\n  schemaB: z3.ZodTypeAny | z4.$ZodType,\n): boolean => {\n  if (isZod3Schema(schemaA) && isZod3Schema(schemaB)) {\n    return true; // Both are Zod 3 schemas\n  }\n  if (isZod4Schema(schemaA) && isZod4Schema(schemaB)) {\n    return true; // Both are Zod 4 schemas\n  }\n  return false; // One is Zod 3 and the other is Zod 4\n};\n","import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport { haveSameZodMajor, isZod3Schema, isZod4Schema } from \"./utils.ts\";\nimport {\n  isCompatibleType as isCompatibleZod3Type,\n  isSameType as isSameZod3Type,\n  type CompareContext as CompareContext3,\n} from \"./zod3/index.ts\";\nimport type { LegacyZodFunction } from \"./zod4/compat.ts\";\nimport {\n  isCompatibleType as isCompatibleZod4Type,\n  isSameType as isSameZod4Type,\n  type CompareContext as CompareContext4,\n} from \"./zod4/index.ts\";\n\n// Export versions checking utilities\nexport { haveSameZodMajor, isZod3Schema, isZod4Schema };\n\n/**\n * isSameType is a function that checks if two ZodTypes are the same.\n *\n * Caveats:\n * - The function does not validate specific criteria such as min or max values, length, email, etc.\n * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().\n *\n * @param a - The first ZodType to compare.\n * @param b - The second ZodType to compare.\n * @returns A boolean indicating whether the two types are the same.\n *\n * @throws Will throw an error if it encounters an unknown type.\n *\n * @example\n * ```ts\n * isSameType(z.string(), z.string()); // true\n * isSameType(z.string(), z.number()); // false\n * ```\n */\nexport const isSameType = (\n  a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n  b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n  context?: CompareContext3 & CompareContext4,\n): boolean => {\n  if (isZod4Schema(a) && isZod4Schema(b)) {\n    return isSameZod4Type(a, b, context as CompareContext4);\n  }\n  if (isZod3Schema(a) && isZod3Schema(b)) {\n    return isSameZod3Type(a, b, context as CompareContext3);\n  }\n  throw new Error(\"Failed to compare types: different Zod versions\");\n};\n\n/**\n * Check if a the higherType matches the lowerType\n *\n * @deprecated This a unstable API and still in development\n *\n * @param higherType The looser type\n * @param lowerType The stricter type\n *\n * @example\n * ```ts\n * isCompatibleType(z.string(), z.string()); // true\n *\n * isCompatibleType(\n *   z.object({ name: z.string(), other: z.number() }),\n *   z.object({ name: z.string() })\n * );\n * // true\n * ```\n */\nexport const isCompatibleType = (\n  a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n  b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): boolean => {\n  if (isZod4Schema(a) && isZod4Schema(b)) {\n    return isCompatibleZod4Type(a, b);\n  }\n  if (isZod3Schema(a) && isZod3Schema(b)) {\n    return isCompatibleZod3Type(a, b);\n  }\n  throw new Error(\"Failed to compare types: different Zod versions\");\n};\n"],"names":["isZod4Schema","schema","isLegacyZodFunction","isZod3Schema","haveSameZodMajor","schemaA","schemaB","isSameType","a","b","context","isSameZod4Type","isSameZod3Type","isCompatibleType","isCompatibleZod4Type","isCompatibleZod3Type"],"mappings":"oLAOaA,EACXC,GAEIC,GAAAA,EAAAA,oBAAoBD,CAAM,GAI1B,SAAUA,GAWHE,EACXF,GAC4B,CAACD,EAAaC,CAAM,EAErCG,EAAmB,CAC9BC,EACAC,IAEI,GAAAH,EAAaE,CAAO,GAAKF,EAAaG,CAAO,GAG7CN,EAAaK,CAAO,GAAKL,EAAaM,CAAO,GCCtCC,EAAa,CACxBC,EACAC,EACAC,IACY,CACZ,GAAIV,EAAaQ,CAAC,GAAKR,EAAaS,CAAC,EACnC,OAAOE,aAAeH,EAAGC,EAAGC,CAA0B,EAExD,GAAIP,EAAaK,CAAC,GAAKL,EAAaM,CAAC,EACnC,OAAOG,aAAeJ,EAAGC,EAAGC,CAA0B,EAExD,MAAM,IAAI,MAAM,iDAAiD,CACnE,EAqBaG,EAAmB,CAC9BL,EACAC,IACY,CACZ,GAAIT,EAAaQ,CAAC,GAAKR,EAAaS,CAAC,EACnC,OAAOK,EAAAA,iBAAqBN,EAAGC,CAAC,EAElC,GAAIN,EAAaK,CAAC,GAAKL,EAAaM,CAAC,EACnC,OAAOM,EAAAA,iBAAqBP,EAAGC,CAAC,EAElC,MAAM,IAAI,MAAM,iDAAiD,CACnE"}

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 import { haveSameZodMajor, isZod3Schema, isZod4Schema } from './utils.ts';
+import { CompareContext as CompareContext3 } from './zod3/index.ts';
 import { LegacyZodFunction } from './zod4/compat.ts';
+import { CompareContext as CompareContext4 } from './zod4/index.ts';
 import type * as z3 from "zod/v3";
 import type * as z4 from "zod/v4/core";
 export { haveSameZodMajor, isZod3Schema, isZod4Schema };
@@ -22,7 +24,7 @@ export { haveSameZodMajor, isZod3Schema, isZod4Schema };
  * isSameType(z.string(), z.number()); // false
  * ```
  */
-export declare const isSameType: (a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction, b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction) => boolean;
+export declare const isSameType: (a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction, b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction, context?: CompareContext3 & CompareContext4) => boolean;
 /**
  * Check if a the higherType matches the lowerType
  *

package/dist/index.js

@@ -1,23 +1,23 @@
-import { i as o, a as s, b as n } from "./is-compatible-type-DEERQsQI.js";
-import { i as a, a as f } from "./is-compatible-type-CA7-IozU.js";
-const t = (e) => !!(o(e) || "_zod" in e), i = (e) => !t(e), m = (e, r) => !!(i(e) && i(r) || t(e) && t(r)), d = (e, r) => {
+import { i as s, a as n, b as a } from "./is-compatible-type-DEERQsQI.js";
+import { i as f, a as p } from "./is-compatible-type-CA7-IozU.js";
+const i = (e) => !!(s(e) || "_zod" in e), t = (e) => !i(e), d = (e, r) => !!(t(e) && t(r) || i(e) && i(r)), y = (e, r, o) => {
+  if (i(e) && i(r))
+    return n(e, r, o);
   if (t(e) && t(r))
-    return s(e, r);
+    return f(e, r, o);
+  throw new Error("Failed to compare types: different Zod versions");
+}, l = (e, r) => {
   if (i(e) && i(r))
     return a(e, r);
-  throw new Error("Failed to compare types: different Zod versions");
-}, y = (e, r) => {
   if (t(e) && t(r))
-    return n(e, r);
-  if (i(e) && i(r))
-    return f(e, r);
+    return p(e, r);
   throw new Error("Failed to compare types: different Zod versions");
 };
 export {
-  m as haveSameZodMajor,
-  y as isCompatibleType,
-  d as isSameType,
-  i as isZod3Schema,
-  t as isZod4Schema
+  d as haveSameZodMajor,
+  l as isCompatibleType,
+  y as isSameType,
+  t as isZod3Schema,
+  i as isZod4Schema
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/utils.ts","../src/index.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport { isLegacyZodFunction, type LegacyZodFunction } from \"./zod4/compat.ts\";\n\n/**\n * See https://zod.dev/library-authors?id=how-to-support-zod-3-and-zod-4-simultaneously\n */\nexport const isZod4Schema = (\n  schema: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): schema is z4.$ZodType => {\n  if (isLegacyZodFunction(schema)) {\n    // version >= v4.0 && <4.1\n    return true;\n  }\n  if (\"_zod\" in schema) {\n    // This is a Zod 4 schema\n    // You can access the schema definition using `schema._zod.def`\n    return true;\n  } else {\n    // This is a Zod 3 schema\n    // You can access the schema definition using `schema._def`\n    return false;\n  }\n};\n\nexport const isZod3Schema = (\n  schema: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): schema is z3.ZodTypeAny => !isZod4Schema(schema);\n\nexport const haveSameZodMajor = (\n  schemaA: z3.ZodTypeAny | z4.$ZodType,\n  schemaB: z3.ZodTypeAny | z4.$ZodType,\n): boolean => {\n  if (isZod3Schema(schemaA) && isZod3Schema(schemaB)) {\n    return true; // Both are Zod 3 schemas\n  }\n  if (isZod4Schema(schemaA) && isZod4Schema(schemaB)) {\n    return true; // Both are Zod 4 schemas\n  }\n  return false; // One is Zod 3 and the other is Zod 4\n};\n","import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport { haveSameZodMajor, isZod3Schema, isZod4Schema } from \"./utils.ts\";\nimport {\n  isCompatibleType as isCompatibleZod3Type,\n  isSameType as isSameZod3Type,\n} from \"./zod3/index.ts\";\nimport type { LegacyZodFunction } from \"./zod4/compat.ts\";\nimport {\n  isCompatibleType as isCompatibleZod4Type,\n  isSameType as isSameZod4Type,\n} from \"./zod4/index.ts\";\n\n// Export versions checking utilities\nexport { haveSameZodMajor, isZod3Schema, isZod4Schema };\n\n/**\n * isSameType is a function that checks if two ZodTypes are the same.\n *\n * Caveats:\n * - The function does not validate specific criteria such as min or max values, length, email, etc.\n * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().\n *\n * @param a - The first ZodType to compare.\n * @param b - The second ZodType to compare.\n * @returns A boolean indicating whether the two types are the same.\n *\n * @throws Will throw an error if it encounters an unknown type.\n *\n * @example\n * ```ts\n * isSameType(z.string(), z.string()); // true\n * isSameType(z.string(), z.number()); // false\n * ```\n */\nexport const isSameType = (\n  a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n  b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): boolean => {\n  if (isZod4Schema(a) && isZod4Schema(b)) {\n    return isSameZod4Type(a, b);\n  }\n  if (isZod3Schema(a) && isZod3Schema(b)) {\n    return isSameZod3Type(a, b);\n  }\n  throw new Error(\"Failed to compare types: different Zod versions\");\n};\n\n/**\n * Check if a the higherType matches the lowerType\n *\n * @deprecated This a unstable API and still in development\n *\n * @param higherType The looser type\n * @param lowerType The stricter type\n *\n * @example\n * ```ts\n * isCompatibleType(z.string(), z.string()); // true\n *\n * isCompatibleType(\n *   z.object({ name: z.string(), other: z.number() }),\n *   z.object({ name: z.string() })\n * );\n * // true\n * ```\n */\nexport const isCompatibleType = (\n  a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n  b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): boolean => {\n  if (isZod4Schema(a) && isZod4Schema(b)) {\n    return isCompatibleZod4Type(a, b);\n  }\n  if (isZod3Schema(a) && isZod3Schema(b)) {\n    return isCompatibleZod3Type(a, b);\n  }\n  throw new Error(\"Failed to compare types: different Zod versions\");\n};\n"],"names":["isZod4Schema","schema","isLegacyZodFunction","isZod3Schema","haveSameZodMajor","schemaA","schemaB","isSameType","a","b","isSameZod4Type","isSameZod3Type","isCompatibleType","isCompatibleZod4Type","isCompatibleZod3Type"],"mappings":";;AAOO,MAAMA,IAAe,CAC1BC,MAEI,GAAAC,EAAoBD,CAAM,KAI1B,UAAUA,IAWHE,IAAe,CAC1BF,MAC4B,CAACD,EAAaC,CAAM,GAErCG,IAAmB,CAC9BC,GACAC,MAEI,GAAAH,EAAaE,CAAO,KAAKF,EAAaG,CAAO,KAG7CN,EAAaK,CAAO,KAAKL,EAAaM,CAAO,ICDtCC,IAAa,CACxBC,GACAC,MACY;AACZ,MAAIT,EAAaQ,CAAC,KAAKR,EAAaS,CAAC;AACnC,WAAOC,EAAeF,GAAGC,CAAC;AAE5B,MAAIN,EAAaK,CAAC,KAAKL,EAAaM,CAAC;AACnC,WAAOE,EAAeH,GAAGC,CAAC;AAE5B,QAAM,IAAI,MAAM,iDAAiD;AACnE,GAqBaG,IAAmB,CAC9BJ,GACAC,MACY;AACZ,MAAIT,EAAaQ,CAAC,KAAKR,EAAaS,CAAC;AACnC,WAAOI,EAAqBL,GAAGC,CAAC;AAElC,MAAIN,EAAaK,CAAC,KAAKL,EAAaM,CAAC;AACnC,WAAOK,EAAqBN,GAAGC,CAAC;AAElC,QAAM,IAAI,MAAM,iDAAiD;AACnE;"}
+{"version":3,"file":"index.js","sources":["../src/utils.ts","../src/index.ts"],"sourcesContent":["import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport { isLegacyZodFunction, type LegacyZodFunction } from \"./zod4/compat.ts\";\n\n/**\n * See https://zod.dev/library-authors?id=how-to-support-zod-3-and-zod-4-simultaneously\n */\nexport const isZod4Schema = (\n  schema: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): schema is z4.$ZodType => {\n  if (isLegacyZodFunction(schema)) {\n    // version >= v4.0 && <4.1\n    return true;\n  }\n  if (\"_zod\" in schema) {\n    // This is a Zod 4 schema\n    // You can access the schema definition using `schema._zod.def`\n    return true;\n  } else {\n    // This is a Zod 3 schema\n    // You can access the schema definition using `schema._def`\n    return false;\n  }\n};\n\nexport const isZod3Schema = (\n  schema: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): schema is z3.ZodTypeAny => !isZod4Schema(schema);\n\nexport const haveSameZodMajor = (\n  schemaA: z3.ZodTypeAny | z4.$ZodType,\n  schemaB: z3.ZodTypeAny | z4.$ZodType,\n): boolean => {\n  if (isZod3Schema(schemaA) && isZod3Schema(schemaB)) {\n    return true; // Both are Zod 3 schemas\n  }\n  if (isZod4Schema(schemaA) && isZod4Schema(schemaB)) {\n    return true; // Both are Zod 4 schemas\n  }\n  return false; // One is Zod 3 and the other is Zod 4\n};\n","import type * as z3 from \"zod/v3\";\nimport type * as z4 from \"zod/v4/core\";\nimport { haveSameZodMajor, isZod3Schema, isZod4Schema } from \"./utils.ts\";\nimport {\n  isCompatibleType as isCompatibleZod3Type,\n  isSameType as isSameZod3Type,\n  type CompareContext as CompareContext3,\n} from \"./zod3/index.ts\";\nimport type { LegacyZodFunction } from \"./zod4/compat.ts\";\nimport {\n  isCompatibleType as isCompatibleZod4Type,\n  isSameType as isSameZod4Type,\n  type CompareContext as CompareContext4,\n} from \"./zod4/index.ts\";\n\n// Export versions checking utilities\nexport { haveSameZodMajor, isZod3Schema, isZod4Schema };\n\n/**\n * isSameType is a function that checks if two ZodTypes are the same.\n *\n * Caveats:\n * - The function does not validate specific criteria such as min or max values, length, email, etc.\n * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().\n *\n * @param a - The first ZodType to compare.\n * @param b - The second ZodType to compare.\n * @returns A boolean indicating whether the two types are the same.\n *\n * @throws Will throw an error if it encounters an unknown type.\n *\n * @example\n * ```ts\n * isSameType(z.string(), z.string()); // true\n * isSameType(z.string(), z.number()); // false\n * ```\n */\nexport const isSameType = (\n  a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n  b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n  context?: CompareContext3 & CompareContext4,\n): boolean => {\n  if (isZod4Schema(a) && isZod4Schema(b)) {\n    return isSameZod4Type(a, b, context as CompareContext4);\n  }\n  if (isZod3Schema(a) && isZod3Schema(b)) {\n    return isSameZod3Type(a, b, context as CompareContext3);\n  }\n  throw new Error(\"Failed to compare types: different Zod versions\");\n};\n\n/**\n * Check if a the higherType matches the lowerType\n *\n * @deprecated This a unstable API and still in development\n *\n * @param higherType The looser type\n * @param lowerType The stricter type\n *\n * @example\n * ```ts\n * isCompatibleType(z.string(), z.string()); // true\n *\n * isCompatibleType(\n *   z.object({ name: z.string(), other: z.number() }),\n *   z.object({ name: z.string() })\n * );\n * // true\n * ```\n */\nexport const isCompatibleType = (\n  a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n  b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,\n): boolean => {\n  if (isZod4Schema(a) && isZod4Schema(b)) {\n    return isCompatibleZod4Type(a, b);\n  }\n  if (isZod3Schema(a) && isZod3Schema(b)) {\n    return isCompatibleZod3Type(a, b);\n  }\n  throw new Error(\"Failed to compare types: different Zod versions\");\n};\n"],"names":["isZod4Schema","schema","isLegacyZodFunction","isZod3Schema","haveSameZodMajor","schemaA","schemaB","isSameType","a","b","context","isSameZod4Type","isSameZod3Type","isCompatibleType","isCompatibleZod4Type","isCompatibleZod3Type"],"mappings":";;AAOO,MAAMA,IAAe,CAC1BC,MAEI,GAAAC,EAAoBD,CAAM,KAI1B,UAAUA,IAWHE,IAAe,CAC1BF,MAC4B,CAACD,EAAaC,CAAM,GAErCG,IAAmB,CAC9BC,GACAC,MAEI,GAAAH,EAAaE,CAAO,KAAKF,EAAaG,CAAO,KAG7CN,EAAaK,CAAO,KAAKL,EAAaM,CAAO,ICCtCC,IAAa,CACxBC,GACAC,GACAC,MACY;AACZ,MAAIV,EAAaQ,CAAC,KAAKR,EAAaS,CAAC;AACnC,WAAOE,EAAeH,GAAGC,GAAGC,CAA0B;AAExD,MAAIP,EAAaK,CAAC,KAAKL,EAAaM,CAAC;AACnC,WAAOG,EAAeJ,GAAGC,GAAGC,CAA0B;AAExD,QAAM,IAAI,MAAM,iDAAiD;AACnE,GAqBaG,IAAmB,CAC9BL,GACAC,MACY;AACZ,MAAIT,EAAaQ,CAAC,KAAKR,EAAaS,CAAC;AACnC,WAAOK,EAAqBN,GAAGC,CAAC;AAElC,MAAIN,EAAaK,CAAC,KAAKL,EAAaM,CAAC;AACnC,WAAOM,EAAqBP,GAAGC,CAAC;AAElC,QAAM,IAAI,MAAM,iDAAiD;AACnE;"}

package/dist/is-compatible-type-BA3YzVJ3.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-compatible-type-BA3YzVJ3.cjs","sources":["../src/zod4/compat.ts","../src/zod4/create-compare-fn.ts","../src/zod4/utils.ts","../src/zod4/is-same-type.ts","../src/zod4/is-compatible-type.ts"],"sourcesContent":["import type { $ZodFunction } from \"zod/v4/core\";\n\n/**\n * Before zod v4.1, the $ZodFunction was not a Zod schema.\n * Learn more: https://github.com/colinhacks/zod/pull/5121/\n *\n * @deprecated Remove this union when we bump the zod version to v4.1+\n */\nexport type LegacyZodFunction = $ZodFunction;\n\n/**\n * Checks if a schema is a legacy ZodFunction (pre-v4.1).\n *\n * Before zod v4.1, the $ZodFunction was not a Zod schema.\n * Learn more: https://github.com/colinhacks/zod/pull/5121/\n *\n * @deprecated Remove this function when we bump the zod version to v4.1+\n */\nexport const isLegacyZodFunction = (\n  maybeSchema: unknown,\n): maybeSchema is LegacyZodFunction => {\n  if (typeof maybeSchema !== \"object\" || maybeSchema === null) {\n    return false;\n  }\n  if (\"_zod\" in maybeSchema) {\n    return false;\n  }\n  if (\n    !(\"def\" in maybeSchema) ||\n    typeof maybeSchema[\"def\"] !== \"object\" ||\n    maybeSchema[\"def\"] === null\n  ) {\n    return false;\n  }\n  if (\n    !(\"type\" in maybeSchema.def) ||\n    typeof maybeSchema.def.type !== \"string\"\n  ) {\n    return false;\n  }\n  return (\n    maybeSchema.def.type === \"function\" &&\n    \"input\" in maybeSchema.def &&\n    \"output\" in maybeSchema.def\n  );\n};\n","import type { $ZodType, $ZodTypes } from \"zod/v4/core\";\n\nimport type { LegacyZodFunction } from \"./compat.ts\";\nimport { type CompareContext, type CompareRule } from \"./types.ts\";\n\nexport const createCompareFn = (rules: CompareRule[]) => {\n  const isSameTypeFn = (\n    left: Readonly<$ZodType | LegacyZodFunction>,\n    right: Readonly<$ZodType | LegacyZodFunction>,\n    context: CompareContext = {},\n  ): boolean => {\n    let prevIndex = -1;\n    const runner = (index: number): boolean => {\n      if (index === rules.length) {\n        console.error(\"Failed to compare type! \" + left + \" \" + right);\n        return false;\n      }\n      if (index === prevIndex) {\n        console.error(\"next() called multiple times\");\n        return false;\n      }\n      prevIndex = index;\n      const rule = rules[index];\n\n      // We check $ZodTypes in the first rule in the isSameType\n      const strictA = left as $ZodTypes;\n      const strictB = right as $ZodTypes;\n\n      const compareResult = rule.compare(\n        strictA,\n        strictB,\n        () => runner(index + 1),\n        (a, b) => isSameTypeFn(a, b, context),\n        context,\n      );\n\n      if (\"stacks\" in context && Array.isArray(context.stacks)) {\n        context.stacks.push({\n          name: rule.name,\n          target: [strictA, strictB],\n          result: compareResult,\n        });\n      }\n\n      return compareResult;\n    };\n\n    return runner(0);\n  };\n  return isSameTypeFn;\n};\n","import type {\n  $ZodAny,\n  $ZodBigInt,\n  $ZodBoolean,\n  $ZodDate,\n  $ZodNaN,\n  $ZodNever,\n  $ZodNull,\n  $ZodNumber,\n  $ZodString,\n  $ZodSymbol,\n  $ZodType,\n  $ZodTypes,\n  $ZodUndefined,\n  $ZodUnion,\n  $ZodUnknown,\n  $ZodVoid,\n  SomeType,\n} from \"zod/v4/core\";\n\nexport const isZodType = (maybeSchema: unknown): maybeSchema is $ZodType => {\n  if (typeof maybeSchema !== \"object\" || maybeSchema === null) {\n    return false;\n  }\n  if (\n    !(\"~standard\" in maybeSchema) ||\n    typeof maybeSchema[\"~standard\"] !== \"object\"\n  ) {\n    return false;\n  }\n  return (\n    (maybeSchema[\"~standard\"] as $ZodType[\"~standard\"])[\"vendor\"] === \"zod\"\n  );\n};\n\nconst typesSet: Set<string> = new Set([\n  \"string\",\n  \"number\",\n  \"boolean\",\n  \"bigint\",\n  \"symbol\",\n  \"null\",\n  \"undefined\",\n  \"void\",\n  \"never\",\n  \"any\",\n  \"unknown\",\n  \"date\",\n  \"object\",\n  \"record\",\n  \"file\",\n  \"array\",\n  \"tuple\",\n  \"union\",\n  \"intersection\",\n  \"map\",\n  \"set\",\n  \"enum\",\n  \"literal\",\n  \"nullable\",\n  \"optional\",\n  \"nonoptional\",\n  \"success\",\n  \"transform\",\n  \"default\",\n  \"prefault\",\n  \"catch\",\n  \"nan\",\n  \"pipe\",\n  \"readonly\",\n  \"template_literal\",\n  \"promise\",\n  \"lazy\",\n  \"custom\",\n  // @ts-expect-error -- $ZodTypes includes function after v4.1\n  \"function\",\n] satisfies $ZodTypes[\"_zod\"][\"def\"][\"type\"][]);\n\nexport const isZodTypes = (schema: $ZodType): schema is $ZodTypes => {\n  const type = schema._zod.def.type;\n  return typesSet.has(type);\n};\n\nexport const isSimpleType = (\n  a: $ZodTypes,\n): a is\n  | $ZodString\n  | $ZodNumber\n  | $ZodBoolean\n  | $ZodBigInt\n  | $ZodSymbol\n  | $ZodUndefined\n  | $ZodNull\n  | $ZodAny\n  | $ZodUnknown\n  | $ZodNever\n  | $ZodVoid\n  | $ZodDate\n  | $ZodNaN => {\n  const type = a._zod.def.type;\n  return (\n    type === \"string\" ||\n    type === \"number\" ||\n    type === \"boolean\" ||\n    type === \"bigint\" ||\n    type === \"symbol\" ||\n    type === \"undefined\" ||\n    type === \"null\" ||\n    type === \"any\" ||\n    type === \"unknown\" ||\n    type === \"never\" ||\n    type === \"void\" ||\n    type === \"date\" ||\n    type === \"nan\" ||\n    type === \"file\"\n  );\n};\n\nexport const flatUnwrapUnion = <\n  Options extends readonly SomeType[] = readonly $ZodType[],\n>(\n  unionType: $ZodUnion<Options>,\n): Options => {\n  return unionType._zod.def.options.flatMap((x) => {\n    if (\n      x._zod.def.type === \"union\" &&\n      Array.isArray((x as $ZodUnion)._zod.def.options)\n    ) {\n      return flatUnwrapUnion(x as $ZodUnion);\n    }\n    return x;\n  }) as unknown as Options;\n};\n\n/**\n * @deprecated Not used\n */\nexport const compareSchemas = (\n  a: $ZodTypes,\n  b: $ZodTypes,\n  compareZod: (a: $ZodTypes, b: $ZodTypes) => boolean,\n): boolean => {\n  const aDef = a._zod.def;\n  const bDef = b._zod.def;\n  for (const key in aDef) {\n    if (!(key in bDef)) return false;\n    const aValue = aDef[key as keyof typeof aDef];\n    const bValue = bDef[key as keyof typeof bDef];\n\n    if (typeof aValue !== typeof bValue) return false;\n    if (aValue === null && bValue !== null) return false;\n    if (\n      typeof aValue === \"string\" ||\n      typeof aValue === \"number\" ||\n      typeof aValue === \"boolean\" ||\n      typeof aValue === \"symbol\" ||\n      typeof aValue === \"bigint\" ||\n      typeof aValue === \"undefined\"\n    ) {\n      if (aValue !== bValue) return false;\n      continue;\n    }\n    if (isZodType(aValue)) {\n      if (!isZodType(bValue)) return false;\n      const isEqual = compareZod(\n        aValue as unknown as $ZodTypes,\n        bValue as unknown as $ZodTypes,\n      );\n      if (!isEqual) return false;\n      continue;\n    }\n    if (Array.isArray(aValue)) {\n      if (!Array.isArray(bValue)) return false;\n      if (aValue.length !== bValue.length) return false;\n      for (let i = 0; i < aValue.length; i++) {\n        const aItem = aValue[i];\n        const bItem = bValue[i];\n        if (isZodType(aItem)) {\n          if (!isZodType(bItem)) return false;\n          if (!compareZod(aItem as $ZodTypes, bItem as $ZodTypes)) return false;\n          continue;\n        }\n        if (aItem !== bItem) {\n          return false;\n        }\n      }\n      continue;\n    }\n    if (typeof aValue === \"object\") {\n      if (typeof bValue !== \"object\" || bValue === null) return false;\n      const bShape = bValue;\n      if (Object.keys(aValue).length !== Object.keys(bShape).length)\n        return false;\n      console.warn(\"Skipping object comparison\", key, aValue, bValue);\n      continue;\n    }\n    if (typeof aValue === \"function\") {\n      // skip function comparison\n      console.warn(\"Skipping function comparison\", key, aValue, bValue);\n      continue;\n    }\n  }\n  return true;\n};\n","import type { $ZodTypes, $ZodUnion } from \"zod/v4/core\";\nimport { isLegacyZodFunction } from \"./compat.ts\";\nimport { createCompareFn } from \"./create-compare-fn.ts\";\nimport type { CompareRule } from \"./types.ts\";\nimport {\n  flatUnwrapUnion,\n  isSimpleType,\n  isZodType,\n  isZodTypes,\n} from \"./utils.ts\";\n\nexport const isSameTypePresetRules = [\n  // Compatible pre-v4.1 ZodFunction\n  {\n    name: \"compare legacy ZodFunction\",\n    compare: (a, b, next, recheck) => {\n      if (isLegacyZodFunction(a) || isLegacyZodFunction(b)) {\n        if (!isLegacyZodFunction(a) || !isLegacyZodFunction(b)) {\n          return false;\n        }\n        return recheck(\n          {\n            ...a,\n            // @ts-expect-error -- make it look like a ZodType\n            _zod: { def: a.def },\n          },\n          {\n            ...b,\n            _zod: { def: b.def },\n          },\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"unstable warn\",\n    compare: (a, b, next) => {\n      const unstableTypes = new Set<string>([\n        \"transform\",\n        \"default\",\n        \"prefault\",\n        \"success\",\n        \"catch\",\n        \"pipe\",\n        \"lazy\",\n        \"custom\",\n      ] satisfies $ZodTypes[\"_zod\"][\"def\"][\"type\"][]);\n\n      if (\n        unstableTypes.has(a._zod.def.type) ||\n        unstableTypes.has(b._zod.def.type)\n      ) {\n        const aType = a._zod.def.type;\n        const bType = b._zod.def.type;\n        console.warn(\n          [\n            \"[zod-compare] Unstable comparison detected.\",\n            \"This library is designed to compare TypeScript-level types (shape/compatibility).\",\n            \"The involved Zod kinds are not standardized/are unstable and results may be approximate:\",\n            `left.type=\\\"${aType}\\\" right.type=\\\"${bType}\\\".`,\n            \"Consider avoiding these kinds or validating with runtime tests if strict equality is required.\",\n            \"Alternatively, compose your own comparator by defining rules and using createCompareFn to override behavior for these kinds.\",\n            a,\n            b,\n          ].join(\" \"),\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"strict ZodTypes check\",\n    compare: (a, b, next) => {\n      const isZodTypesA = isZodTypes(a);\n      const isZodTypesB = isZodTypes(b);\n      if (!isZodTypesA || !isZodTypesB) {\n        // If neither are Zod types, we can compare them directly\n        console.warn(\"Failed to compare type! \" + a + \" \" + b);\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"undefined check\",\n    compare: (a, b, next) => {\n      if (a === undefined || b === undefined) {\n        console.warn(\"Failed to compare type! \" + a + \" \" + b);\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare reference\",\n    compare: (a, b, next) => {\n      if (a === b) {\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare type\",\n    compare: (a, b, next) => {\n      const aTypeName = a._zod.def.type;\n      const bTypeName = b._zod.def.type;\n      if (aTypeName !== bTypeName) {\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"unwrap innerType\",\n    // ZodOptionalDef\n    // ZodNullableDef\n    // ZodDefaultDef\n    // ZodNonOptionalDef\n    // ZodSuccessDef\n    // ZodCatchDef\n    // ZodReadonlyDef\n    // ZodPromiseDef\n    compare: (a, b, next, recheck) => {\n      const defA = a._zod.def;\n      const defB = b._zod.def;\n      if (\"innerType\" in defA && typeof defA.innerType === \"object\") {\n        if (!(\"innerType\" in defB && typeof defB.innerType === \"object\")) {\n          return false;\n        }\n        if (defA.type !== defB.type) {\n          return false;\n        }\n        const innerA = defA.innerType;\n        const innerB = defB.innerType;\n        if (!isZodType(innerA) || !isZodType(innerB)) {\n          console.warn(\"Failed to compare inner types\", innerA, innerB);\n          return false;\n        }\n        // In ZodDefault/ZodPrefault, the defaultValue will be ignored\n        return recheck(innerA, innerB);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare simple type\",\n    compare: (a, b, next) => {\n      if (isSimpleType(a) || isSimpleType(b)) {\n        const aType = a._zod.def.type;\n        const bType = b._zod.def.type;\n        return aType === bType;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare array\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"array\" && bType === \"array\") {\n        return recheck(a._zod.def.element, b._zod.def.element);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare object\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"object\" && bType === \"object\") {\n        const aShape = a._zod.def.shape;\n        const bShape = b._zod.def.shape;\n        if (Object.keys(aShape).length !== Object.keys(bShape).length)\n          return false;\n        for (const key in aShape) {\n          if (!(key in bShape)) return false;\n          if (!recheck(aShape[key], bShape[key])) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare record\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"record\" && bType === \"record\") {\n        return (\n          recheck(a._zod.def.keyType, b._zod.def.keyType) &&\n          recheck(a._zod.def.valueType, b._zod.def.valueType)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare tuple\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"tuple\" && bType === \"tuple\") {\n        const aItems = a._zod.def.items;\n        const bItems = b._zod.def.items;\n        if (aItems.length !== bItems.length) return false;\n        for (let i = 0; i < aItems.length; i++) {\n          if (!recheck(aItems[i], bItems[i])) return false;\n        }\n        // Compare rest\n        if (a._zod.def.rest || b._zod.def.rest) {\n          // If one has rest, the other must have rest\n          if (!a._zod.def.rest || !b._zod.def.rest) return false;\n          return recheck(a._zod.def.rest, b._zod.def.rest);\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare map\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"map\" && bType === \"map\") {\n        return (\n          recheck(a._zod.def.keyType, b._zod.def.keyType) &&\n          recheck(a._zod.def.valueType, b._zod.def.valueType)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare set\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"set\" && bType === \"set\") {\n        return recheck(a._zod.def.valueType, b._zod.def.valueType);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare enum\",\n    compare: (a, b, next) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"enum\" && bType === \"enum\") {\n        const aEntries = a._zod.def.entries as Record<string, unknown>;\n        const bEntries = b._zod.def.entries as Record<string, unknown>;\n        const aKeys = Object.keys(aEntries);\n        const bKeys = Object.keys(bEntries);\n        if (aKeys.length !== bKeys.length) return false;\n        for (const key of aKeys) {\n          if (!(key in bEntries)) return false;\n          if (aEntries[key] !== bEntries[key]) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare literal\",\n    compare: (a, b, next) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"literal\" && bType === \"literal\") {\n        const aValues = a._zod.def.values as readonly unknown[];\n        const bValues = b._zod.def.values as readonly unknown[];\n        if (aValues.length !== bValues.length) return false;\n        // Treat as set equality of primitive literals\n        const bSet = new Set(bValues);\n        for (const v of aValues) {\n          if (!bSet.has(v)) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare function\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      // Upgrade zod to v4.1 to resolve it\n      // @ts-expect-error -- see https://github.com/colinhacks/zod/issues/4143\n      if (aType === \"function\" && bType === \"function\") {\n        // In Zod4, function def has `input` (tuple-like) and `output` (ZodType)\n        return (\n          // @ts-expect-error\n          recheck(a._zod.def.input, b._zod.def.input) &&\n          // @ts-expect-error\n          recheck(a._zod.def.output, b._zod.def.output)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare intersection\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"intersection\" && bType === \"intersection\") {\n        const aLeft = a._zod.def.left;\n        const aRight = a._zod.def.right;\n        const bLeft = b._zod.def.left;\n        const bRight = b._zod.def.right;\n        // Commutative: (L==L && R==R) OR (L==R && R==L)\n        const direct = recheck(aLeft, bLeft) && recheck(aRight, bRight);\n        if (direct) return true;\n        const swapped = recheck(aLeft, bRight) && recheck(aRight, bLeft);\n        return swapped;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare union\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"union\" && bType === \"union\") {\n        const aOpts = flatUnwrapUnion(a as $ZodUnion);\n        const bOpts = flatUnwrapUnion(b as $ZodUnion);\n        // Set-like equality (ignore duplicates): A ⊆ B and B ⊆ A\n        const allAInB = aOpts.every((aOpt) =>\n          bOpts.some((bOpt) => recheck(aOpt, bOpt)),\n        );\n        if (!allAInB) return false;\n        const allBInA = bOpts.every((bOpt) =>\n          aOpts.some((aOpt) => recheck(aOpt, bOpt)),\n        );\n        return allBInA;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare template_literal\",\n    compare: (a, b, next, recheck) => {\n      const defA = a._zod.def;\n      const defB = b._zod.def;\n      if (\n        defA.type === \"template_literal\" &&\n        defB.type === \"template_literal\"\n      ) {\n        const aParts = defA.parts;\n        const bParts = defB.parts;\n        if (!Array.isArray(aParts) || !Array.isArray(bParts)) return false;\n        if (aParts.length !== bParts.length) return false;\n        for (let i = 0; i < aParts.length; i++) {\n          const pa = aParts[i];\n          const pb = bParts[i];\n          const isSchemaA = isZodType(pa);\n          const isSchemaB = isZodType(pb);\n          if (isSchemaA || isSchemaB) {\n            if (!(isSchemaA && isSchemaB)) return false;\n            if (!recheck(pa, pb)) return false;\n          } else {\n            // Both should be primitive literal parts\n            if (pa !== pb) return false;\n          }\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare pipe\",\n    compare: (a, b, next, recheck) => {\n      const defA = a._zod.def;\n      const defB = b._zod.def;\n      if (defA.type === \"pipe\" && defB.type === \"pipe\") {\n        return recheck(defA.in, defB.in) && recheck(defA.out, defB.out);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare lazy\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"lazy\" && bType === \"lazy\") {\n        const aGetter = a._zod.def.getter;\n        const bGetter = b._zod.def.getter;\n        // Fast path: same getter function reference\n        if (aGetter === bGetter) return true;\n        const aInner = aGetter();\n        const bInner = bGetter();\n        if (!isZodType(aInner) || !isZodType(bInner)) return false;\n        return recheck(aInner, bInner);\n      }\n      return next();\n    },\n  },\n  // {\n  //   name: \"compare unknown schemas\",\n  //   compare: (a, b, _next, recheck) => {\n  //     return compareSchemas(a, b, recheck);\n  //   },\n  // },\n  {\n    name: \"final fallback\",\n    // ZodTransform\n    compare: () => {\n      return false;\n    },\n  },\n] satisfies CompareRule[];\n\n/**\n * isSameType is a function that checks if two ZodTypes are the same.\n *\n * Caveats:\n * - The function does not validate specific criteria such as min or max values, length, email, etc.\n * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().\n *\n * @param a - The first ZodType to compare.\n * @param b - The second ZodType to compare.\n * @returns A boolean indicating whether the two types are the same.\n *\n * @throws Will throw an error if it encounters an unknown type.\n *\n * @example\n * ```ts\n * isSameType(z.string(), z.string()); // true\n * isSameType(z.string(), z.number()); // false\n * ```\n */\nexport const isSameType = createCompareFn(isSameTypePresetRules);\n","import type { $ZodUnion } from \"zod/v4/core\";\nimport { createCompareFn } from \"./create-compare-fn.ts\";\nimport { isSameType } from \"./is-same-type.ts\";\nimport type { CompareRule } from \"./types.ts\";\nimport { flatUnwrapUnion, isZodType } from \"./utils.ts\";\n\nexport const isCompatibleTypePresetRules: CompareRule[] = [\n  {\n    name: \"is same type\",\n    compare: (higherType, lowerType, next) => {\n      if (isSameType(higherType, lowerType)) {\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check typeName\",\n    compare: (higherType, lowerType, next) => {\n      // In Zod4, type information is in _zod.def\n      if (\n        !(\"_zod\" in higherType) ||\n        !(\"def\" in higherType._zod) ||\n        !(\"_zod\" in lowerType) ||\n        !(\"def\" in lowerType._zod)\n      ) {\n        throw new Error(\n          \"Failed to compare type! \" + higherType + \" \" + lowerType,\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check optional/nullable on lower\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const lowerDef = lowerType._zod.def;\n      if (\n        (lowerDef.type === \"optional\" || lowerDef.type === \"nullable\") &&\n        \"innerType\" in lowerDef &&\n        typeof lowerDef.innerType === \"object\" &&\n        isZodType(lowerDef.innerType)\n      ) {\n        return recheck(higherType, lowerDef.innerType);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check union\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"union\" && bType === \"union\") {\n        const aOpts = flatUnwrapUnion(higherType as $ZodUnion);\n        const bOpts = flatUnwrapUnion(lowerType as $ZodUnion);\n        // Every option in higher must be accepted by at least one option in lower\n        return aOpts.every((optA) => bOpts.some((optB) => recheck(optA, optB)));\n      }\n      if (aType === \"union\") {\n        const aOpts = flatUnwrapUnion(higherType as $ZodUnion);\n        // All options from higher must be compatible with the (non-union) lower\n        return aOpts.every((opt) => recheck(opt, lowerType));\n      }\n      if (bType === \"union\") {\n        const bOpts = flatUnwrapUnion(lowerType as $ZodUnion);\n        // Higher must match at least one option in lower\n        return bOpts.some((opt) => recheck(higherType, opt));\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare type by kind\",\n    compare: (higherType, lowerType, next) => {\n      const aTypeName = higherType._zod.def.type;\n      const bTypeName = lowerType._zod.def.type;\n      if (aTypeName !== bTypeName) return false;\n      return next();\n    },\n  },\n  {\n    name: \"check object (structural subset)\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"object\" && bType === \"object\") {\n        const superShape = higherType._zod.def.shape;\n        const subShape = lowerType._zod.def.shape;\n        if (Object.keys(superShape).length < Object.keys(subShape).length)\n          return false;\n        for (const key in subShape) {\n          if (!(key in superShape)) return false;\n          if (!recheck(superShape[key], subShape[key])) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check array\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"array\" && bType === \"array\") {\n        return recheck(higherType._zod.def.element, lowerType._zod.def.element);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check tuple (length and rest)\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"tuple\" && bType === \"tuple\") {\n        const aItems = higherType._zod.def.items;\n        const bItems = lowerType._zod.def.items;\n        if (aItems.length < bItems.length) return false;\n        for (let i = 0; i < bItems.length; i++) {\n          if (!recheck(aItems[i], bItems[i])) return false;\n        }\n        // If lower has rest, higher must have rest and be compatible\n        const aRest = higherType._zod.def.rest;\n        const bRest = lowerType._zod.def.rest;\n        if (bRest) {\n          if (!aRest) return false;\n          return recheck(aRest, bRest);\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n];\n\n/**\n * Check if a the higherType matches the lowerType\n *\n * @deprecated This a unstable API and still in development\n *\n * @param higherType The looser type\n * @param lowerType The stricter type\n *\n * @example\n * ```ts\n * isCompatibleType(z.string(), z.string()); // true\n *\n * isCompatibleType(\n *   z.object({ name: z.string(), other: z.number() }),\n *   z.object({ name: z.string() })\n * );\n * // true\n * ```\n */\nexport const isCompatibleType = createCompareFn(isCompatibleTypePresetRules);\n"],"names":["isLegacyZodFunction","maybeSchema","createCompareFn","rules","isSameTypeFn","left","right","context","prevIndex","runner","index","rule","strictA","strictB","compareResult","a","b","isZodType","typesSet","isZodTypes","schema","type","isSimpleType","flatUnwrapUnion","unionType","x","isSameTypePresetRules","next","recheck","unstableTypes","aType","bType","isZodTypesA","isZodTypesB","aTypeName","bTypeName","defA","defB","innerA","innerB","aShape","bShape","key","aItems","bItems","i","aEntries","bEntries","aKeys","bKeys","aValues","bValues","bSet","v","aLeft","aRight","bLeft","bRight","aOpts","bOpts","aOpt","bOpt","aParts","bParts","pa","pb","isSchemaA","isSchemaB","aGetter","bGetter","aInner","bInner","isSameType","isCompatibleTypePresetRules","higherType","lowerType","lowerDef","optA","optB","opt","superShape","subShape","aRest","bRest","isCompatibleType"],"mappings":"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"}
+{"version":3,"file":"is-compatible-type-BA3YzVJ3.cjs","sources":["../src/zod4/compat.ts","../src/zod4/create-compare-fn.ts","../src/zod4/utils.ts","../src/zod4/is-same-type.ts","../src/zod4/is-compatible-type.ts"],"sourcesContent":["import type { $ZodFunction } from \"zod/v4/core\";\n\n/**\n * Before zod v4.1, the $ZodFunction was not a Zod schema.\n * Learn more: https://github.com/colinhacks/zod/pull/5121/\n *\n * @deprecated Remove this union when we bump the zod version to v4.1+\n */\nexport type LegacyZodFunction = $ZodFunction;\n\n/**\n * Checks if a schema is a legacy ZodFunction (pre-v4.1).\n *\n * Before zod v4.1, the $ZodFunction was not a Zod schema.\n * Learn more: https://github.com/colinhacks/zod/pull/5121/\n *\n * @deprecated Remove this function when we bump the zod version to v4.1+\n */\nexport const isLegacyZodFunction = (\n  maybeSchema: unknown,\n): maybeSchema is LegacyZodFunction => {\n  if (typeof maybeSchema !== \"object\" || maybeSchema === null) {\n    return false;\n  }\n  if (\"_zod\" in maybeSchema) {\n    return false;\n  }\n  if (\n    !(\"def\" in maybeSchema) ||\n    typeof maybeSchema[\"def\"] !== \"object\" ||\n    maybeSchema[\"def\"] === null\n  ) {\n    return false;\n  }\n  if (\n    !(\"type\" in maybeSchema.def) ||\n    typeof maybeSchema.def.type !== \"string\"\n  ) {\n    return false;\n  }\n  return (\n    maybeSchema.def.type === \"function\" &&\n    \"input\" in maybeSchema.def &&\n    \"output\" in maybeSchema.def\n  );\n};\n","import type { $ZodType, $ZodTypes } from \"zod/v4/core\";\n\nimport type { LegacyZodFunction } from \"./compat.ts\";\nimport { type CompareContext, type CompareRule } from \"./types.ts\";\n\nexport const createCompareFn = (rules: CompareRule[]) => {\n  const isSameTypeFn = (\n    left: Readonly<$ZodType | LegacyZodFunction>,\n    right: Readonly<$ZodType | LegacyZodFunction>,\n    context: CompareContext = {},\n  ): boolean => {\n    let prevIndex = -1;\n    const runner = (index: number): boolean => {\n      if (index === rules.length) {\n        console.error(\"Failed to compare type! \" + left + \" \" + right);\n        return false;\n      }\n      if (index === prevIndex) {\n        console.error(\"next() called multiple times\");\n        return false;\n      }\n      prevIndex = index;\n      const rule = rules[index];\n\n      // We check $ZodTypes in the first rule in the isSameType\n      const strictA = left as $ZodTypes;\n      const strictB = right as $ZodTypes;\n\n      const compareResult = rule.compare(\n        strictA,\n        strictB,\n        () => runner(index + 1),\n        (a, b) => isSameTypeFn(a, b, context),\n        context,\n      );\n\n      if (\"stacks\" in context && Array.isArray(context.stacks)) {\n        context.stacks.push({\n          name: rule.name,\n          target: [strictA, strictB],\n          result: compareResult,\n        });\n      }\n\n      return compareResult;\n    };\n\n    return runner(0);\n  };\n  return isSameTypeFn;\n};\n","import type {\n  $ZodAny,\n  $ZodBigInt,\n  $ZodBoolean,\n  $ZodDate,\n  $ZodNaN,\n  $ZodNever,\n  $ZodNull,\n  $ZodNumber,\n  $ZodString,\n  $ZodSymbol,\n  $ZodType,\n  $ZodTypes,\n  $ZodUndefined,\n  $ZodUnion,\n  $ZodUnknown,\n  $ZodVoid,\n  SomeType,\n} from \"zod/v4/core\";\n\nexport const isZodType = (maybeSchema: unknown): maybeSchema is $ZodType => {\n  if (typeof maybeSchema !== \"object\" || maybeSchema === null) {\n    return false;\n  }\n  if (\n    !(\"~standard\" in maybeSchema) ||\n    typeof maybeSchema[\"~standard\"] !== \"object\"\n  ) {\n    return false;\n  }\n  return (\n    (maybeSchema[\"~standard\"] as $ZodType[\"~standard\"])[\"vendor\"] === \"zod\"\n  );\n};\n\nconst typesSet: Set<string> = new Set([\n  \"string\",\n  \"number\",\n  \"boolean\",\n  \"bigint\",\n  \"symbol\",\n  \"null\",\n  \"undefined\",\n  \"void\",\n  \"never\",\n  \"any\",\n  \"unknown\",\n  \"date\",\n  \"object\",\n  \"record\",\n  \"file\",\n  \"array\",\n  \"tuple\",\n  \"union\",\n  \"intersection\",\n  \"map\",\n  \"set\",\n  \"enum\",\n  \"literal\",\n  \"nullable\",\n  \"optional\",\n  \"nonoptional\",\n  \"success\",\n  \"transform\",\n  \"default\",\n  \"prefault\",\n  \"catch\",\n  \"nan\",\n  \"pipe\",\n  \"readonly\",\n  \"template_literal\",\n  \"promise\",\n  \"lazy\",\n  \"custom\",\n  // @ts-expect-error -- $ZodTypes includes function after v4.1\n  \"function\",\n] satisfies $ZodTypes[\"_zod\"][\"def\"][\"type\"][]);\n\nexport const isZodTypes = (schema: $ZodType): schema is $ZodTypes => {\n  const type = schema._zod.def.type;\n  return typesSet.has(type);\n};\n\nexport const isSimpleType = (\n  a: $ZodTypes,\n): a is\n  | $ZodString\n  | $ZodNumber\n  | $ZodBoolean\n  | $ZodBigInt\n  | $ZodSymbol\n  | $ZodUndefined\n  | $ZodNull\n  | $ZodAny\n  | $ZodUnknown\n  | $ZodNever\n  | $ZodVoid\n  | $ZodDate\n  | $ZodNaN => {\n  const type = a._zod.def.type;\n  return (\n    type === \"string\" ||\n    type === \"number\" ||\n    type === \"boolean\" ||\n    type === \"bigint\" ||\n    type === \"symbol\" ||\n    type === \"undefined\" ||\n    type === \"null\" ||\n    type === \"any\" ||\n    type === \"unknown\" ||\n    type === \"never\" ||\n    type === \"void\" ||\n    type === \"date\" ||\n    type === \"nan\" ||\n    type === \"file\"\n  );\n};\n\nexport const flatUnwrapUnion = <\n  Options extends readonly SomeType[] = readonly $ZodType[],\n>(\n  unionType: $ZodUnion<Options>,\n): Options => {\n  return unionType._zod.def.options.flatMap((x) => {\n    if (\n      x._zod.def.type === \"union\" &&\n      Array.isArray((x as $ZodUnion)._zod.def.options)\n    ) {\n      return flatUnwrapUnion(x as $ZodUnion);\n    }\n    return x;\n  }) as unknown as Options;\n};\n\nexport const zodToString = (\n  schema: $ZodType,\n  options?: { format?: boolean },\n  indent = 0,\n): string => {\n  if (!isZodTypes(schema)) {\n    return \"z.unknown()\";\n  }\n  const def = schema._zod.def;\n  const type = def.type;\n  const format = options?.format ?? false;\n  const nextIndent = indent + 2;\n  const indentStr = format ? \"\\n\" + \" \".repeat(nextIndent) : \"\";\n  const endIndentStr = format ? \"\\n\" + \" \".repeat(indent) : \"\";\n\n  switch (type) {\n    case \"string\":\n    case \"number\":\n    case \"boolean\":\n    case \"bigint\":\n    case \"symbol\":\n    case \"undefined\":\n    case \"null\":\n    case \"any\":\n    case \"unknown\":\n    case \"never\":\n    case \"void\":\n    case \"date\":\n    case \"nan\":\n      return `z.${type}()`;\n    case \"literal\":\n      const values = def.values as unknown[];\n      return `z.literal(${JSON.stringify(values[0])})`;\n    case \"array\":\n      return `z.array(${zodToString(def.element, options, indent)})`;\n    case \"object\":\n      const shape = def.shape;\n      const shapeStrs = Object.entries(shape).map(\n        ([k, v]) =>\n          `${indentStr}${k}: ${zodToString(v as $ZodType, options, nextIndent)}`,\n      );\n      if (format) {\n        return `z.object({${shapeStrs.join(\",\")}${endIndentStr}})`;\n      }\n      return `z.object({ ${shapeStrs.join(\", \")} })`;\n    case \"tuple\":\n      const items = def.items as $ZodType[];\n      const itemStrs = items.map((i) => zodToString(i, options, nextIndent));\n      if (format && items.length > 0) {\n        return `z.tuple([${indentStr}${itemStrs.join(\",\" + indentStr)}${endIndentStr}])`;\n      }\n      return `z.tuple([${itemStrs.join(\", \")}])`;\n    case \"union\":\n      const optionsList = def.options as $ZodType[];\n      const optStrs = optionsList.map((o) =>\n        zodToString(o, options, nextIndent),\n      );\n      if (format && optionsList.length > 0) {\n        return `z.union([${indentStr}${optStrs.join(\",\" + indentStr)}${endIndentStr}])`;\n      }\n      return `z.union([${optStrs.join(\", \")}])`;\n    case \"intersection\":\n      return `z.intersection(${zodToString(def.left, options, indent)}, ${zodToString(\n        def.right,\n        options,\n        indent,\n      )})`;\n    case \"optional\":\n      return `${zodToString(def.innerType, options, indent)}.optional()`;\n    case \"nullable\":\n      return `${zodToString(def.innerType, options, indent)}.nullable()`;\n    default:\n      return `z.${type}(...)`;\n  }\n};\n","import type { $ZodTypes, $ZodUnion } from \"zod/v4/core\";\nimport { isLegacyZodFunction } from \"./compat.ts\";\nimport { createCompareFn } from \"./create-compare-fn.ts\";\nimport type { CompareRule } from \"./types.ts\";\nimport {\n  flatUnwrapUnion,\n  isSimpleType,\n  isZodType,\n  isZodTypes,\n} from \"./utils.ts\";\n\nexport const isSameTypePresetRules = [\n  // Compatible pre-v4.1 ZodFunction\n  {\n    name: \"compare legacy ZodFunction\",\n    compare: (a, b, next, recheck) => {\n      if (isLegacyZodFunction(a) || isLegacyZodFunction(b)) {\n        if (!isLegacyZodFunction(a) || !isLegacyZodFunction(b)) {\n          return false;\n        }\n        return recheck(\n          {\n            ...a,\n            // @ts-expect-error -- make it look like a ZodType\n            _zod: { def: a.def },\n          },\n          {\n            ...b,\n            _zod: { def: b.def },\n          },\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"unstable warn\",\n    compare: (a, b, next) => {\n      const unstableTypes = new Set<string>([\n        \"transform\",\n        \"default\",\n        \"prefault\",\n        \"success\",\n        \"catch\",\n        \"pipe\",\n        \"lazy\",\n        \"custom\",\n      ] satisfies $ZodTypes[\"_zod\"][\"def\"][\"type\"][]);\n\n      if (\n        unstableTypes.has(a._zod.def.type) ||\n        unstableTypes.has(b._zod.def.type)\n      ) {\n        const aType = a._zod.def.type;\n        const bType = b._zod.def.type;\n        console.warn(\n          [\n            \"[zod-compare] Unstable comparison detected.\",\n            \"This library is designed to compare TypeScript-level types (shape/compatibility).\",\n            \"The involved Zod kinds are not standardized/are unstable and results may be approximate:\",\n            `left.type=\\\"${aType}\\\" right.type=\\\"${bType}\\\".`,\n            \"Consider avoiding these kinds or validating with runtime tests if strict equality is required.\",\n            \"Alternatively, compose your own comparator by defining rules and using createCompareFn to override behavior for these kinds.\",\n            a,\n            b,\n          ].join(\" \"),\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"strict ZodTypes check\",\n    compare: (a, b, next) => {\n      const isZodTypesA = isZodTypes(a);\n      const isZodTypesB = isZodTypes(b);\n      if (!isZodTypesA || !isZodTypesB) {\n        console.warn(\"Failed to compare type! \" + a + \" \" + b);\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"undefined check\",\n    compare: (a, b, next) => {\n      if (a === undefined || b === undefined) {\n        console.warn(\"Failed to compare type! \" + a + \" \" + b);\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare reference\",\n    compare: (a, b, next) => {\n      if (a === b) {\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare type\",\n    compare: (a, b, next) => {\n      const aTypeName = a._zod.def.type;\n      const bTypeName = b._zod.def.type;\n      if (aTypeName !== bTypeName) {\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"unwrap innerType\",\n    // ZodOptionalDef\n    // ZodNullableDef\n    // ZodDefaultDef\n    // ZodNonOptionalDef\n    // ZodSuccessDef\n    // ZodCatchDef\n    // ZodReadonlyDef\n    // ZodPromiseDef\n    compare: (a, b, next, recheck) => {\n      const defA = a._zod.def;\n      const defB = b._zod.def;\n      if (\"innerType\" in defA && typeof defA.innerType === \"object\") {\n        if (!(\"innerType\" in defB && typeof defB.innerType === \"object\")) {\n          return false;\n        }\n        if (defA.type !== defB.type) {\n          return false;\n        }\n        const innerA = defA.innerType;\n        const innerB = defB.innerType;\n        if (!isZodType(innerA) || !isZodType(innerB)) {\n          console.warn(\"Failed to compare inner types\", innerA, innerB);\n          return false;\n        }\n        // In ZodDefault/ZodPrefault, the defaultValue will be ignored\n        return recheck(innerA, innerB);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare simple type\",\n    compare: (a, b, next) => {\n      if (isSimpleType(a) || isSimpleType(b)) {\n        const aType = a._zod.def.type;\n        const bType = b._zod.def.type;\n        return aType === bType;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare array\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"array\" && bType === \"array\") {\n        return recheck(a._zod.def.element, b._zod.def.element);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare object\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"object\" && bType === \"object\") {\n        const aShape = a._zod.def.shape;\n        const bShape = b._zod.def.shape;\n        if (Object.keys(aShape).length !== Object.keys(bShape).length)\n          return false;\n        for (const key in aShape) {\n          if (!(key in bShape)) return false;\n          if (!recheck(aShape[key], bShape[key])) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare record\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"record\" && bType === \"record\") {\n        return (\n          recheck(a._zod.def.keyType, b._zod.def.keyType) &&\n          recheck(a._zod.def.valueType, b._zod.def.valueType)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare tuple\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"tuple\" && bType === \"tuple\") {\n        const aItems = a._zod.def.items;\n        const bItems = b._zod.def.items;\n        if (aItems.length !== bItems.length) return false;\n        for (let i = 0; i < aItems.length; i++) {\n          if (!recheck(aItems[i], bItems[i])) return false;\n        }\n        // Compare rest\n        if (a._zod.def.rest || b._zod.def.rest) {\n          // If one has rest, the other must have rest\n          if (!a._zod.def.rest || !b._zod.def.rest) return false;\n          return recheck(a._zod.def.rest, b._zod.def.rest);\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare map\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"map\" && bType === \"map\") {\n        return (\n          recheck(a._zod.def.keyType, b._zod.def.keyType) &&\n          recheck(a._zod.def.valueType, b._zod.def.valueType)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare set\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"set\" && bType === \"set\") {\n        return recheck(a._zod.def.valueType, b._zod.def.valueType);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare enum\",\n    compare: (a, b, next) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"enum\" && bType === \"enum\") {\n        const aEntries = a._zod.def.entries as Record<string, unknown>;\n        const bEntries = b._zod.def.entries as Record<string, unknown>;\n        const aKeys = Object.keys(aEntries);\n        const bKeys = Object.keys(bEntries);\n        if (aKeys.length !== bKeys.length) return false;\n        for (const key of aKeys) {\n          if (!(key in bEntries)) return false;\n          if (aEntries[key] !== bEntries[key]) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare literal\",\n    compare: (a, b, next) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"literal\" && bType === \"literal\") {\n        const aValues = a._zod.def.values as readonly unknown[];\n        const bValues = b._zod.def.values as readonly unknown[];\n        if (aValues.length !== bValues.length) return false;\n        // Treat as set equality of primitive literals\n        const bSet = new Set(bValues);\n        for (const v of aValues) {\n          if (!bSet.has(v)) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare function\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      // Upgrade zod to v4.1 to resolve it\n      // @ts-expect-error -- see https://github.com/colinhacks/zod/issues/4143\n      if (aType === \"function\" && bType === \"function\") {\n        // In Zod4, function def has `input` (tuple-like) and `output` (ZodType)\n        return (\n          // @ts-expect-error\n          recheck(a._zod.def.input, b._zod.def.input) &&\n          // @ts-expect-error\n          recheck(a._zod.def.output, b._zod.def.output)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare intersection\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"intersection\" && bType === \"intersection\") {\n        const aLeft = a._zod.def.left;\n        const aRight = a._zod.def.right;\n        const bLeft = b._zod.def.left;\n        const bRight = b._zod.def.right;\n        // Commutative: (L==L && R==R) OR (L==R && R==L)\n        const direct = recheck(aLeft, bLeft) && recheck(aRight, bRight);\n        if (direct) return true;\n        const swapped = recheck(aLeft, bRight) && recheck(aRight, bLeft);\n        return swapped;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare union\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"union\" && bType === \"union\") {\n        const aOpts = flatUnwrapUnion(a as $ZodUnion);\n        const bOpts = flatUnwrapUnion(b as $ZodUnion);\n        // Set-like equality (ignore duplicates): A ⊆ B and B ⊆ A\n        const allAInB = aOpts.every((aOpt) =>\n          bOpts.some((bOpt) => recheck(aOpt, bOpt)),\n        );\n        if (!allAInB) return false;\n        const allBInA = bOpts.every((bOpt) =>\n          aOpts.some((aOpt) => recheck(aOpt, bOpt)),\n        );\n        return allBInA;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare template_literal\",\n    compare: (a, b, next, recheck) => {\n      const defA = a._zod.def;\n      const defB = b._zod.def;\n      if (\n        defA.type === \"template_literal\" &&\n        defB.type === \"template_literal\"\n      ) {\n        const aParts = defA.parts;\n        const bParts = defB.parts;\n        if (!Array.isArray(aParts) || !Array.isArray(bParts)) return false;\n        if (aParts.length !== bParts.length) return false;\n        for (let i = 0; i < aParts.length; i++) {\n          const pa = aParts[i];\n          const pb = bParts[i];\n          const isSchemaA = isZodType(pa);\n          const isSchemaB = isZodType(pb);\n          if (isSchemaA || isSchemaB) {\n            if (!(isSchemaA && isSchemaB)) return false;\n            if (!recheck(pa, pb)) return false;\n          } else {\n            // Both should be primitive literal parts\n            if (pa !== pb) return false;\n          }\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare pipe\",\n    compare: (a, b, next, recheck) => {\n      const defA = a._zod.def;\n      const defB = b._zod.def;\n      if (defA.type === \"pipe\" && defB.type === \"pipe\") {\n        return recheck(defA.in, defB.in) && recheck(defA.out, defB.out);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare lazy\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"lazy\" && bType === \"lazy\") {\n        const aGetter = a._zod.def.getter;\n        const bGetter = b._zod.def.getter;\n        // Fast path: same getter function reference\n        if (aGetter === bGetter) return true;\n        const aInner = aGetter();\n        const bInner = bGetter();\n        if (!isZodType(aInner) || !isZodType(bInner)) return false;\n        return recheck(aInner, bInner);\n      }\n      return next();\n    },\n  },\n  // {\n  //   name: \"compare unknown schemas\",\n  //   compare: (a, b, _next, recheck) => {\n  //     return compareSchemas(a, b, recheck);\n  //   },\n  // },\n  {\n    name: \"final fallback\",\n    // ZodTransform\n    compare: () => {\n      return false;\n    },\n  },\n] satisfies CompareRule[];\n\n/**\n * isSameType is a function that checks if two ZodTypes are the same.\n *\n * Caveats:\n * - The function does not validate specific criteria such as min or max values, length, email, etc.\n * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().\n *\n * @param a - The first ZodType to compare.\n * @param b - The second ZodType to compare.\n * @returns A boolean indicating whether the two types are the same.\n *\n * @throws Will throw an error if it encounters an unknown type.\n *\n * @example\n * ```ts\n * isSameType(z.string(), z.string()); // true\n * isSameType(z.string(), z.number()); // false\n * ```\n */\nexport const isSameType = createCompareFn(isSameTypePresetRules);\n","import type { $ZodUnion } from \"zod/v4/core\";\nimport { createCompareFn } from \"./create-compare-fn.ts\";\nimport { isSameType } from \"./is-same-type.ts\";\nimport type { CompareRule } from \"./types.ts\";\nimport { flatUnwrapUnion, isZodType } from \"./utils.ts\";\n\nexport const isCompatibleTypePresetRules: CompareRule[] = [\n  {\n    name: \"is same type\",\n    compare: (higherType, lowerType, next) => {\n      if (isSameType(higherType, lowerType)) {\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check typeName\",\n    compare: (higherType, lowerType, next) => {\n      // In Zod4, type information is in _zod.def\n      if (\n        !(\"_zod\" in higherType) ||\n        !(\"def\" in higherType._zod) ||\n        !(\"_zod\" in lowerType) ||\n        !(\"def\" in lowerType._zod)\n      ) {\n        throw new Error(\n          \"Failed to compare type! \" + higherType + \" \" + lowerType,\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check optional/nullable on lower\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const lowerDef = lowerType._zod.def;\n      if (\n        (lowerDef.type === \"optional\" || lowerDef.type === \"nullable\") &&\n        \"innerType\" in lowerDef &&\n        typeof lowerDef.innerType === \"object\" &&\n        isZodType(lowerDef.innerType)\n      ) {\n        return recheck(higherType, lowerDef.innerType);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check union\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"union\" && bType === \"union\") {\n        const aOpts = flatUnwrapUnion(higherType as $ZodUnion);\n        const bOpts = flatUnwrapUnion(lowerType as $ZodUnion);\n        // Every option in higher must be accepted by at least one option in lower\n        return aOpts.every((optA) => bOpts.some((optB) => recheck(optA, optB)));\n      }\n      if (aType === \"union\") {\n        const aOpts = flatUnwrapUnion(higherType as $ZodUnion);\n        // All options from higher must be compatible with the (non-union) lower\n        return aOpts.every((opt) => recheck(opt, lowerType));\n      }\n      if (bType === \"union\") {\n        const bOpts = flatUnwrapUnion(lowerType as $ZodUnion);\n        // Higher must match at least one option in lower\n        return bOpts.some((opt) => recheck(higherType, opt));\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare type by kind\",\n    compare: (higherType, lowerType, next) => {\n      const aTypeName = higherType._zod.def.type;\n      const bTypeName = lowerType._zod.def.type;\n      if (aTypeName !== bTypeName) return false;\n      return next();\n    },\n  },\n  {\n    name: \"check object (structural subset)\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"object\" && bType === \"object\") {\n        const superShape = higherType._zod.def.shape;\n        const subShape = lowerType._zod.def.shape;\n        if (Object.keys(superShape).length < Object.keys(subShape).length)\n          return false;\n        for (const key in subShape) {\n          if (!(key in superShape)) return false;\n          if (!recheck(superShape[key], subShape[key])) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check array\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"array\" && bType === \"array\") {\n        return recheck(higherType._zod.def.element, lowerType._zod.def.element);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check tuple (length and rest)\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"tuple\" && bType === \"tuple\") {\n        const aItems = higherType._zod.def.items;\n        const bItems = lowerType._zod.def.items;\n        if (aItems.length < bItems.length) return false;\n        for (let i = 0; i < bItems.length; i++) {\n          if (!recheck(aItems[i], bItems[i])) return false;\n        }\n        // If lower has rest, higher must have rest and be compatible\n        const aRest = higherType._zod.def.rest;\n        const bRest = lowerType._zod.def.rest;\n        if (bRest) {\n          if (!aRest) return false;\n          return recheck(aRest, bRest);\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n];\n\n/**\n * Check if a the higherType matches the lowerType\n *\n * @deprecated This a unstable API and still in development\n *\n * @param higherType The looser type\n * @param lowerType The stricter type\n *\n * @example\n * ```ts\n * isCompatibleType(z.string(), z.string()); // true\n *\n * isCompatibleType(\n *   z.object({ name: z.string(), other: z.number() }),\n *   z.object({ name: z.string() })\n * );\n * // true\n * ```\n */\nexport const isCompatibleType = createCompareFn(isCompatibleTypePresetRules);\n"],"names":["isLegacyZodFunction","maybeSchema","createCompareFn","rules","isSameTypeFn","left","right","context","prevIndex","runner","index","rule","strictA","strictB","compareResult","a","b","isZodType","typesSet","isZodTypes","schema","type","isSimpleType","flatUnwrapUnion","unionType","x","isSameTypePresetRules","next","recheck","unstableTypes","aType","bType","isZodTypesA","isZodTypesB","aTypeName","bTypeName","defA","defB","innerA","innerB","aShape","bShape","key","aItems","bItems","i","aEntries","bEntries","aKeys","bKeys","aValues","bValues","bSet","v","aLeft","aRight","bLeft","bRight","aOpts","bOpts","aOpt","bOpt","aParts","bParts","pa","pb","isSchemaA","isSchemaB","aGetter","bGetter","aInner","bInner","isSameType","isCompatibleTypePresetRules","higherType","lowerType","lowerDef","optA","optB","opt","superShape","subShape","aRest","bRest","isCompatibleType"],"mappings":"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"}

package/dist/is-compatible-type-DEERQsQI.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-compatible-type-DEERQsQI.js","sources":["../src/zod4/compat.ts","../src/zod4/create-compare-fn.ts","../src/zod4/utils.ts","../src/zod4/is-same-type.ts","../src/zod4/is-compatible-type.ts"],"sourcesContent":["import type { $ZodFunction } from \"zod/v4/core\";\n\n/**\n * Before zod v4.1, the $ZodFunction was not a Zod schema.\n * Learn more: https://github.com/colinhacks/zod/pull/5121/\n *\n * @deprecated Remove this union when we bump the zod version to v4.1+\n */\nexport type LegacyZodFunction = $ZodFunction;\n\n/**\n * Checks if a schema is a legacy ZodFunction (pre-v4.1).\n *\n * Before zod v4.1, the $ZodFunction was not a Zod schema.\n * Learn more: https://github.com/colinhacks/zod/pull/5121/\n *\n * @deprecated Remove this function when we bump the zod version to v4.1+\n */\nexport const isLegacyZodFunction = (\n  maybeSchema: unknown,\n): maybeSchema is LegacyZodFunction => {\n  if (typeof maybeSchema !== \"object\" || maybeSchema === null) {\n    return false;\n  }\n  if (\"_zod\" in maybeSchema) {\n    return false;\n  }\n  if (\n    !(\"def\" in maybeSchema) ||\n    typeof maybeSchema[\"def\"] !== \"object\" ||\n    maybeSchema[\"def\"] === null\n  ) {\n    return false;\n  }\n  if (\n    !(\"type\" in maybeSchema.def) ||\n    typeof maybeSchema.def.type !== \"string\"\n  ) {\n    return false;\n  }\n  return (\n    maybeSchema.def.type === \"function\" &&\n    \"input\" in maybeSchema.def &&\n    \"output\" in maybeSchema.def\n  );\n};\n","import type { $ZodType, $ZodTypes } from \"zod/v4/core\";\n\nimport type { LegacyZodFunction } from \"./compat.ts\";\nimport { type CompareContext, type CompareRule } from \"./types.ts\";\n\nexport const createCompareFn = (rules: CompareRule[]) => {\n  const isSameTypeFn = (\n    left: Readonly<$ZodType | LegacyZodFunction>,\n    right: Readonly<$ZodType | LegacyZodFunction>,\n    context: CompareContext = {},\n  ): boolean => {\n    let prevIndex = -1;\n    const runner = (index: number): boolean => {\n      if (index === rules.length) {\n        console.error(\"Failed to compare type! \" + left + \" \" + right);\n        return false;\n      }\n      if (index === prevIndex) {\n        console.error(\"next() called multiple times\");\n        return false;\n      }\n      prevIndex = index;\n      const rule = rules[index];\n\n      // We check $ZodTypes in the first rule in the isSameType\n      const strictA = left as $ZodTypes;\n      const strictB = right as $ZodTypes;\n\n      const compareResult = rule.compare(\n        strictA,\n        strictB,\n        () => runner(index + 1),\n        (a, b) => isSameTypeFn(a, b, context),\n        context,\n      );\n\n      if (\"stacks\" in context && Array.isArray(context.stacks)) {\n        context.stacks.push({\n          name: rule.name,\n          target: [strictA, strictB],\n          result: compareResult,\n        });\n      }\n\n      return compareResult;\n    };\n\n    return runner(0);\n  };\n  return isSameTypeFn;\n};\n","import type {\n  $ZodAny,\n  $ZodBigInt,\n  $ZodBoolean,\n  $ZodDate,\n  $ZodNaN,\n  $ZodNever,\n  $ZodNull,\n  $ZodNumber,\n  $ZodString,\n  $ZodSymbol,\n  $ZodType,\n  $ZodTypes,\n  $ZodUndefined,\n  $ZodUnion,\n  $ZodUnknown,\n  $ZodVoid,\n  SomeType,\n} from \"zod/v4/core\";\n\nexport const isZodType = (maybeSchema: unknown): maybeSchema is $ZodType => {\n  if (typeof maybeSchema !== \"object\" || maybeSchema === null) {\n    return false;\n  }\n  if (\n    !(\"~standard\" in maybeSchema) ||\n    typeof maybeSchema[\"~standard\"] !== \"object\"\n  ) {\n    return false;\n  }\n  return (\n    (maybeSchema[\"~standard\"] as $ZodType[\"~standard\"])[\"vendor\"] === \"zod\"\n  );\n};\n\nconst typesSet: Set<string> = new Set([\n  \"string\",\n  \"number\",\n  \"boolean\",\n  \"bigint\",\n  \"symbol\",\n  \"null\",\n  \"undefined\",\n  \"void\",\n  \"never\",\n  \"any\",\n  \"unknown\",\n  \"date\",\n  \"object\",\n  \"record\",\n  \"file\",\n  \"array\",\n  \"tuple\",\n  \"union\",\n  \"intersection\",\n  \"map\",\n  \"set\",\n  \"enum\",\n  \"literal\",\n  \"nullable\",\n  \"optional\",\n  \"nonoptional\",\n  \"success\",\n  \"transform\",\n  \"default\",\n  \"prefault\",\n  \"catch\",\n  \"nan\",\n  \"pipe\",\n  \"readonly\",\n  \"template_literal\",\n  \"promise\",\n  \"lazy\",\n  \"custom\",\n  // @ts-expect-error -- $ZodTypes includes function after v4.1\n  \"function\",\n] satisfies $ZodTypes[\"_zod\"][\"def\"][\"type\"][]);\n\nexport const isZodTypes = (schema: $ZodType): schema is $ZodTypes => {\n  const type = schema._zod.def.type;\n  return typesSet.has(type);\n};\n\nexport const isSimpleType = (\n  a: $ZodTypes,\n): a is\n  | $ZodString\n  | $ZodNumber\n  | $ZodBoolean\n  | $ZodBigInt\n  | $ZodSymbol\n  | $ZodUndefined\n  | $ZodNull\n  | $ZodAny\n  | $ZodUnknown\n  | $ZodNever\n  | $ZodVoid\n  | $ZodDate\n  | $ZodNaN => {\n  const type = a._zod.def.type;\n  return (\n    type === \"string\" ||\n    type === \"number\" ||\n    type === \"boolean\" ||\n    type === \"bigint\" ||\n    type === \"symbol\" ||\n    type === \"undefined\" ||\n    type === \"null\" ||\n    type === \"any\" ||\n    type === \"unknown\" ||\n    type === \"never\" ||\n    type === \"void\" ||\n    type === \"date\" ||\n    type === \"nan\" ||\n    type === \"file\"\n  );\n};\n\nexport const flatUnwrapUnion = <\n  Options extends readonly SomeType[] = readonly $ZodType[],\n>(\n  unionType: $ZodUnion<Options>,\n): Options => {\n  return unionType._zod.def.options.flatMap((x) => {\n    if (\n      x._zod.def.type === \"union\" &&\n      Array.isArray((x as $ZodUnion)._zod.def.options)\n    ) {\n      return flatUnwrapUnion(x as $ZodUnion);\n    }\n    return x;\n  }) as unknown as Options;\n};\n\n/**\n * @deprecated Not used\n */\nexport const compareSchemas = (\n  a: $ZodTypes,\n  b: $ZodTypes,\n  compareZod: (a: $ZodTypes, b: $ZodTypes) => boolean,\n): boolean => {\n  const aDef = a._zod.def;\n  const bDef = b._zod.def;\n  for (const key in aDef) {\n    if (!(key in bDef)) return false;\n    const aValue = aDef[key as keyof typeof aDef];\n    const bValue = bDef[key as keyof typeof bDef];\n\n    if (typeof aValue !== typeof bValue) return false;\n    if (aValue === null && bValue !== null) return false;\n    if (\n      typeof aValue === \"string\" ||\n      typeof aValue === \"number\" ||\n      typeof aValue === \"boolean\" ||\n      typeof aValue === \"symbol\" ||\n      typeof aValue === \"bigint\" ||\n      typeof aValue === \"undefined\"\n    ) {\n      if (aValue !== bValue) return false;\n      continue;\n    }\n    if (isZodType(aValue)) {\n      if (!isZodType(bValue)) return false;\n      const isEqual = compareZod(\n        aValue as unknown as $ZodTypes,\n        bValue as unknown as $ZodTypes,\n      );\n      if (!isEqual) return false;\n      continue;\n    }\n    if (Array.isArray(aValue)) {\n      if (!Array.isArray(bValue)) return false;\n      if (aValue.length !== bValue.length) return false;\n      for (let i = 0; i < aValue.length; i++) {\n        const aItem = aValue[i];\n        const bItem = bValue[i];\n        if (isZodType(aItem)) {\n          if (!isZodType(bItem)) return false;\n          if (!compareZod(aItem as $ZodTypes, bItem as $ZodTypes)) return false;\n          continue;\n        }\n        if (aItem !== bItem) {\n          return false;\n        }\n      }\n      continue;\n    }\n    if (typeof aValue === \"object\") {\n      if (typeof bValue !== \"object\" || bValue === null) return false;\n      const bShape = bValue;\n      if (Object.keys(aValue).length !== Object.keys(bShape).length)\n        return false;\n      console.warn(\"Skipping object comparison\", key, aValue, bValue);\n      continue;\n    }\n    if (typeof aValue === \"function\") {\n      // skip function comparison\n      console.warn(\"Skipping function comparison\", key, aValue, bValue);\n      continue;\n    }\n  }\n  return true;\n};\n","import type { $ZodTypes, $ZodUnion } from \"zod/v4/core\";\nimport { isLegacyZodFunction } from \"./compat.ts\";\nimport { createCompareFn } from \"./create-compare-fn.ts\";\nimport type { CompareRule } from \"./types.ts\";\nimport {\n  flatUnwrapUnion,\n  isSimpleType,\n  isZodType,\n  isZodTypes,\n} from \"./utils.ts\";\n\nexport const isSameTypePresetRules = [\n  // Compatible pre-v4.1 ZodFunction\n  {\n    name: \"compare legacy ZodFunction\",\n    compare: (a, b, next, recheck) => {\n      if (isLegacyZodFunction(a) || isLegacyZodFunction(b)) {\n        if (!isLegacyZodFunction(a) || !isLegacyZodFunction(b)) {\n          return false;\n        }\n        return recheck(\n          {\n            ...a,\n            // @ts-expect-error -- make it look like a ZodType\n            _zod: { def: a.def },\n          },\n          {\n            ...b,\n            _zod: { def: b.def },\n          },\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"unstable warn\",\n    compare: (a, b, next) => {\n      const unstableTypes = new Set<string>([\n        \"transform\",\n        \"default\",\n        \"prefault\",\n        \"success\",\n        \"catch\",\n        \"pipe\",\n        \"lazy\",\n        \"custom\",\n      ] satisfies $ZodTypes[\"_zod\"][\"def\"][\"type\"][]);\n\n      if (\n        unstableTypes.has(a._zod.def.type) ||\n        unstableTypes.has(b._zod.def.type)\n      ) {\n        const aType = a._zod.def.type;\n        const bType = b._zod.def.type;\n        console.warn(\n          [\n            \"[zod-compare] Unstable comparison detected.\",\n            \"This library is designed to compare TypeScript-level types (shape/compatibility).\",\n            \"The involved Zod kinds are not standardized/are unstable and results may be approximate:\",\n            `left.type=\\\"${aType}\\\" right.type=\\\"${bType}\\\".`,\n            \"Consider avoiding these kinds or validating with runtime tests if strict equality is required.\",\n            \"Alternatively, compose your own comparator by defining rules and using createCompareFn to override behavior for these kinds.\",\n            a,\n            b,\n          ].join(\" \"),\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"strict ZodTypes check\",\n    compare: (a, b, next) => {\n      const isZodTypesA = isZodTypes(a);\n      const isZodTypesB = isZodTypes(b);\n      if (!isZodTypesA || !isZodTypesB) {\n        // If neither are Zod types, we can compare them directly\n        console.warn(\"Failed to compare type! \" + a + \" \" + b);\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"undefined check\",\n    compare: (a, b, next) => {\n      if (a === undefined || b === undefined) {\n        console.warn(\"Failed to compare type! \" + a + \" \" + b);\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare reference\",\n    compare: (a, b, next) => {\n      if (a === b) {\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare type\",\n    compare: (a, b, next) => {\n      const aTypeName = a._zod.def.type;\n      const bTypeName = b._zod.def.type;\n      if (aTypeName !== bTypeName) {\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"unwrap innerType\",\n    // ZodOptionalDef\n    // ZodNullableDef\n    // ZodDefaultDef\n    // ZodNonOptionalDef\n    // ZodSuccessDef\n    // ZodCatchDef\n    // ZodReadonlyDef\n    // ZodPromiseDef\n    compare: (a, b, next, recheck) => {\n      const defA = a._zod.def;\n      const defB = b._zod.def;\n      if (\"innerType\" in defA && typeof defA.innerType === \"object\") {\n        if (!(\"innerType\" in defB && typeof defB.innerType === \"object\")) {\n          return false;\n        }\n        if (defA.type !== defB.type) {\n          return false;\n        }\n        const innerA = defA.innerType;\n        const innerB = defB.innerType;\n        if (!isZodType(innerA) || !isZodType(innerB)) {\n          console.warn(\"Failed to compare inner types\", innerA, innerB);\n          return false;\n        }\n        // In ZodDefault/ZodPrefault, the defaultValue will be ignored\n        return recheck(innerA, innerB);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare simple type\",\n    compare: (a, b, next) => {\n      if (isSimpleType(a) || isSimpleType(b)) {\n        const aType = a._zod.def.type;\n        const bType = b._zod.def.type;\n        return aType === bType;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare array\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"array\" && bType === \"array\") {\n        return recheck(a._zod.def.element, b._zod.def.element);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare object\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"object\" && bType === \"object\") {\n        const aShape = a._zod.def.shape;\n        const bShape = b._zod.def.shape;\n        if (Object.keys(aShape).length !== Object.keys(bShape).length)\n          return false;\n        for (const key in aShape) {\n          if (!(key in bShape)) return false;\n          if (!recheck(aShape[key], bShape[key])) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare record\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"record\" && bType === \"record\") {\n        return (\n          recheck(a._zod.def.keyType, b._zod.def.keyType) &&\n          recheck(a._zod.def.valueType, b._zod.def.valueType)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare tuple\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"tuple\" && bType === \"tuple\") {\n        const aItems = a._zod.def.items;\n        const bItems = b._zod.def.items;\n        if (aItems.length !== bItems.length) return false;\n        for (let i = 0; i < aItems.length; i++) {\n          if (!recheck(aItems[i], bItems[i])) return false;\n        }\n        // Compare rest\n        if (a._zod.def.rest || b._zod.def.rest) {\n          // If one has rest, the other must have rest\n          if (!a._zod.def.rest || !b._zod.def.rest) return false;\n          return recheck(a._zod.def.rest, b._zod.def.rest);\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare map\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"map\" && bType === \"map\") {\n        return (\n          recheck(a._zod.def.keyType, b._zod.def.keyType) &&\n          recheck(a._zod.def.valueType, b._zod.def.valueType)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare set\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"set\" && bType === \"set\") {\n        return recheck(a._zod.def.valueType, b._zod.def.valueType);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare enum\",\n    compare: (a, b, next) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"enum\" && bType === \"enum\") {\n        const aEntries = a._zod.def.entries as Record<string, unknown>;\n        const bEntries = b._zod.def.entries as Record<string, unknown>;\n        const aKeys = Object.keys(aEntries);\n        const bKeys = Object.keys(bEntries);\n        if (aKeys.length !== bKeys.length) return false;\n        for (const key of aKeys) {\n          if (!(key in bEntries)) return false;\n          if (aEntries[key] !== bEntries[key]) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare literal\",\n    compare: (a, b, next) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"literal\" && bType === \"literal\") {\n        const aValues = a._zod.def.values as readonly unknown[];\n        const bValues = b._zod.def.values as readonly unknown[];\n        if (aValues.length !== bValues.length) return false;\n        // Treat as set equality of primitive literals\n        const bSet = new Set(bValues);\n        for (const v of aValues) {\n          if (!bSet.has(v)) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare function\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      // Upgrade zod to v4.1 to resolve it\n      // @ts-expect-error -- see https://github.com/colinhacks/zod/issues/4143\n      if (aType === \"function\" && bType === \"function\") {\n        // In Zod4, function def has `input` (tuple-like) and `output` (ZodType)\n        return (\n          // @ts-expect-error\n          recheck(a._zod.def.input, b._zod.def.input) &&\n          // @ts-expect-error\n          recheck(a._zod.def.output, b._zod.def.output)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare intersection\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"intersection\" && bType === \"intersection\") {\n        const aLeft = a._zod.def.left;\n        const aRight = a._zod.def.right;\n        const bLeft = b._zod.def.left;\n        const bRight = b._zod.def.right;\n        // Commutative: (L==L && R==R) OR (L==R && R==L)\n        const direct = recheck(aLeft, bLeft) && recheck(aRight, bRight);\n        if (direct) return true;\n        const swapped = recheck(aLeft, bRight) && recheck(aRight, bLeft);\n        return swapped;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare union\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"union\" && bType === \"union\") {\n        const aOpts = flatUnwrapUnion(a as $ZodUnion);\n        const bOpts = flatUnwrapUnion(b as $ZodUnion);\n        // Set-like equality (ignore duplicates): A ⊆ B and B ⊆ A\n        const allAInB = aOpts.every((aOpt) =>\n          bOpts.some((bOpt) => recheck(aOpt, bOpt)),\n        );\n        if (!allAInB) return false;\n        const allBInA = bOpts.every((bOpt) =>\n          aOpts.some((aOpt) => recheck(aOpt, bOpt)),\n        );\n        return allBInA;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare template_literal\",\n    compare: (a, b, next, recheck) => {\n      const defA = a._zod.def;\n      const defB = b._zod.def;\n      if (\n        defA.type === \"template_literal\" &&\n        defB.type === \"template_literal\"\n      ) {\n        const aParts = defA.parts;\n        const bParts = defB.parts;\n        if (!Array.isArray(aParts) || !Array.isArray(bParts)) return false;\n        if (aParts.length !== bParts.length) return false;\n        for (let i = 0; i < aParts.length; i++) {\n          const pa = aParts[i];\n          const pb = bParts[i];\n          const isSchemaA = isZodType(pa);\n          const isSchemaB = isZodType(pb);\n          if (isSchemaA || isSchemaB) {\n            if (!(isSchemaA && isSchemaB)) return false;\n            if (!recheck(pa, pb)) return false;\n          } else {\n            // Both should be primitive literal parts\n            if (pa !== pb) return false;\n          }\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare pipe\",\n    compare: (a, b, next, recheck) => {\n      const defA = a._zod.def;\n      const defB = b._zod.def;\n      if (defA.type === \"pipe\" && defB.type === \"pipe\") {\n        return recheck(defA.in, defB.in) && recheck(defA.out, defB.out);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare lazy\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"lazy\" && bType === \"lazy\") {\n        const aGetter = a._zod.def.getter;\n        const bGetter = b._zod.def.getter;\n        // Fast path: same getter function reference\n        if (aGetter === bGetter) return true;\n        const aInner = aGetter();\n        const bInner = bGetter();\n        if (!isZodType(aInner) || !isZodType(bInner)) return false;\n        return recheck(aInner, bInner);\n      }\n      return next();\n    },\n  },\n  // {\n  //   name: \"compare unknown schemas\",\n  //   compare: (a, b, _next, recheck) => {\n  //     return compareSchemas(a, b, recheck);\n  //   },\n  // },\n  {\n    name: \"final fallback\",\n    // ZodTransform\n    compare: () => {\n      return false;\n    },\n  },\n] satisfies CompareRule[];\n\n/**\n * isSameType is a function that checks if two ZodTypes are the same.\n *\n * Caveats:\n * - The function does not validate specific criteria such as min or max values, length, email, etc.\n * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().\n *\n * @param a - The first ZodType to compare.\n * @param b - The second ZodType to compare.\n * @returns A boolean indicating whether the two types are the same.\n *\n * @throws Will throw an error if it encounters an unknown type.\n *\n * @example\n * ```ts\n * isSameType(z.string(), z.string()); // true\n * isSameType(z.string(), z.number()); // false\n * ```\n */\nexport const isSameType = createCompareFn(isSameTypePresetRules);\n","import type { $ZodUnion } from \"zod/v4/core\";\nimport { createCompareFn } from \"./create-compare-fn.ts\";\nimport { isSameType } from \"./is-same-type.ts\";\nimport type { CompareRule } from \"./types.ts\";\nimport { flatUnwrapUnion, isZodType } from \"./utils.ts\";\n\nexport const isCompatibleTypePresetRules: CompareRule[] = [\n  {\n    name: \"is same type\",\n    compare: (higherType, lowerType, next) => {\n      if (isSameType(higherType, lowerType)) {\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check typeName\",\n    compare: (higherType, lowerType, next) => {\n      // In Zod4, type information is in _zod.def\n      if (\n        !(\"_zod\" in higherType) ||\n        !(\"def\" in higherType._zod) ||\n        !(\"_zod\" in lowerType) ||\n        !(\"def\" in lowerType._zod)\n      ) {\n        throw new Error(\n          \"Failed to compare type! \" + higherType + \" \" + lowerType,\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check optional/nullable on lower\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const lowerDef = lowerType._zod.def;\n      if (\n        (lowerDef.type === \"optional\" || lowerDef.type === \"nullable\") &&\n        \"innerType\" in lowerDef &&\n        typeof lowerDef.innerType === \"object\" &&\n        isZodType(lowerDef.innerType)\n      ) {\n        return recheck(higherType, lowerDef.innerType);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check union\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"union\" && bType === \"union\") {\n        const aOpts = flatUnwrapUnion(higherType as $ZodUnion);\n        const bOpts = flatUnwrapUnion(lowerType as $ZodUnion);\n        // Every option in higher must be accepted by at least one option in lower\n        return aOpts.every((optA) => bOpts.some((optB) => recheck(optA, optB)));\n      }\n      if (aType === \"union\") {\n        const aOpts = flatUnwrapUnion(higherType as $ZodUnion);\n        // All options from higher must be compatible with the (non-union) lower\n        return aOpts.every((opt) => recheck(opt, lowerType));\n      }\n      if (bType === \"union\") {\n        const bOpts = flatUnwrapUnion(lowerType as $ZodUnion);\n        // Higher must match at least one option in lower\n        return bOpts.some((opt) => recheck(higherType, opt));\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare type by kind\",\n    compare: (higherType, lowerType, next) => {\n      const aTypeName = higherType._zod.def.type;\n      const bTypeName = lowerType._zod.def.type;\n      if (aTypeName !== bTypeName) return false;\n      return next();\n    },\n  },\n  {\n    name: \"check object (structural subset)\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"object\" && bType === \"object\") {\n        const superShape = higherType._zod.def.shape;\n        const subShape = lowerType._zod.def.shape;\n        if (Object.keys(superShape).length < Object.keys(subShape).length)\n          return false;\n        for (const key in subShape) {\n          if (!(key in superShape)) return false;\n          if (!recheck(superShape[key], subShape[key])) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check array\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"array\" && bType === \"array\") {\n        return recheck(higherType._zod.def.element, lowerType._zod.def.element);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check tuple (length and rest)\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"tuple\" && bType === \"tuple\") {\n        const aItems = higherType._zod.def.items;\n        const bItems = lowerType._zod.def.items;\n        if (aItems.length < bItems.length) return false;\n        for (let i = 0; i < bItems.length; i++) {\n          if (!recheck(aItems[i], bItems[i])) return false;\n        }\n        // If lower has rest, higher must have rest and be compatible\n        const aRest = higherType._zod.def.rest;\n        const bRest = lowerType._zod.def.rest;\n        if (bRest) {\n          if (!aRest) return false;\n          return recheck(aRest, bRest);\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n];\n\n/**\n * Check if a the higherType matches the lowerType\n *\n * @deprecated This a unstable API and still in development\n *\n * @param higherType The looser type\n * @param lowerType The stricter type\n *\n * @example\n * ```ts\n * isCompatibleType(z.string(), z.string()); // true\n *\n * isCompatibleType(\n *   z.object({ name: z.string(), other: z.number() }),\n *   z.object({ name: z.string() })\n * );\n * // true\n * ```\n */\nexport const isCompatibleType = createCompareFn(isCompatibleTypePresetRules);\n"],"names":["isLegacyZodFunction","maybeSchema","createCompareFn","rules","isSameTypeFn","left","right","context","prevIndex","runner","index","rule","strictA","strictB","compareResult","a","isZodType","typesSet","isZodTypes","schema","type","isSimpleType","flatUnwrapUnion","unionType","x","isSameTypePresetRules","b","next","recheck","unstableTypes","aType","bType","isZodTypesA","isZodTypesB","aTypeName","bTypeName","defA","defB","innerA","innerB","aShape","bShape","key","aItems","bItems","i","aEntries","bEntries","aKeys","bKeys","aValues","bValues","bSet","v","aLeft","aRight","bLeft","bRight","aOpts","bOpts","aOpt","bOpt","aParts","bParts","pa","pb","isSchemaA","isSchemaB","aGetter","bGetter","aInner","bInner","isSameType","isCompatibleTypePresetRules","higherType","lowerType","lowerDef","optA","optB","opt","superShape","subShape","aRest","bRest","isCompatibleType"],"mappings":"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"}
+{"version":3,"file":"is-compatible-type-DEERQsQI.js","sources":["../src/zod4/compat.ts","../src/zod4/create-compare-fn.ts","../src/zod4/utils.ts","../src/zod4/is-same-type.ts","../src/zod4/is-compatible-type.ts"],"sourcesContent":["import type { $ZodFunction } from \"zod/v4/core\";\n\n/**\n * Before zod v4.1, the $ZodFunction was not a Zod schema.\n * Learn more: https://github.com/colinhacks/zod/pull/5121/\n *\n * @deprecated Remove this union when we bump the zod version to v4.1+\n */\nexport type LegacyZodFunction = $ZodFunction;\n\n/**\n * Checks if a schema is a legacy ZodFunction (pre-v4.1).\n *\n * Before zod v4.1, the $ZodFunction was not a Zod schema.\n * Learn more: https://github.com/colinhacks/zod/pull/5121/\n *\n * @deprecated Remove this function when we bump the zod version to v4.1+\n */\nexport const isLegacyZodFunction = (\n  maybeSchema: unknown,\n): maybeSchema is LegacyZodFunction => {\n  if (typeof maybeSchema !== \"object\" || maybeSchema === null) {\n    return false;\n  }\n  if (\"_zod\" in maybeSchema) {\n    return false;\n  }\n  if (\n    !(\"def\" in maybeSchema) ||\n    typeof maybeSchema[\"def\"] !== \"object\" ||\n    maybeSchema[\"def\"] === null\n  ) {\n    return false;\n  }\n  if (\n    !(\"type\" in maybeSchema.def) ||\n    typeof maybeSchema.def.type !== \"string\"\n  ) {\n    return false;\n  }\n  return (\n    maybeSchema.def.type === \"function\" &&\n    \"input\" in maybeSchema.def &&\n    \"output\" in maybeSchema.def\n  );\n};\n","import type { $ZodType, $ZodTypes } from \"zod/v4/core\";\n\nimport type { LegacyZodFunction } from \"./compat.ts\";\nimport { type CompareContext, type CompareRule } from \"./types.ts\";\n\nexport const createCompareFn = (rules: CompareRule[]) => {\n  const isSameTypeFn = (\n    left: Readonly<$ZodType | LegacyZodFunction>,\n    right: Readonly<$ZodType | LegacyZodFunction>,\n    context: CompareContext = {},\n  ): boolean => {\n    let prevIndex = -1;\n    const runner = (index: number): boolean => {\n      if (index === rules.length) {\n        console.error(\"Failed to compare type! \" + left + \" \" + right);\n        return false;\n      }\n      if (index === prevIndex) {\n        console.error(\"next() called multiple times\");\n        return false;\n      }\n      prevIndex = index;\n      const rule = rules[index];\n\n      // We check $ZodTypes in the first rule in the isSameType\n      const strictA = left as $ZodTypes;\n      const strictB = right as $ZodTypes;\n\n      const compareResult = rule.compare(\n        strictA,\n        strictB,\n        () => runner(index + 1),\n        (a, b) => isSameTypeFn(a, b, context),\n        context,\n      );\n\n      if (\"stacks\" in context && Array.isArray(context.stacks)) {\n        context.stacks.push({\n          name: rule.name,\n          target: [strictA, strictB],\n          result: compareResult,\n        });\n      }\n\n      return compareResult;\n    };\n\n    return runner(0);\n  };\n  return isSameTypeFn;\n};\n","import type {\n  $ZodAny,\n  $ZodBigInt,\n  $ZodBoolean,\n  $ZodDate,\n  $ZodNaN,\n  $ZodNever,\n  $ZodNull,\n  $ZodNumber,\n  $ZodString,\n  $ZodSymbol,\n  $ZodType,\n  $ZodTypes,\n  $ZodUndefined,\n  $ZodUnion,\n  $ZodUnknown,\n  $ZodVoid,\n  SomeType,\n} from \"zod/v4/core\";\n\nexport const isZodType = (maybeSchema: unknown): maybeSchema is $ZodType => {\n  if (typeof maybeSchema !== \"object\" || maybeSchema === null) {\n    return false;\n  }\n  if (\n    !(\"~standard\" in maybeSchema) ||\n    typeof maybeSchema[\"~standard\"] !== \"object\"\n  ) {\n    return false;\n  }\n  return (\n    (maybeSchema[\"~standard\"] as $ZodType[\"~standard\"])[\"vendor\"] === \"zod\"\n  );\n};\n\nconst typesSet: Set<string> = new Set([\n  \"string\",\n  \"number\",\n  \"boolean\",\n  \"bigint\",\n  \"symbol\",\n  \"null\",\n  \"undefined\",\n  \"void\",\n  \"never\",\n  \"any\",\n  \"unknown\",\n  \"date\",\n  \"object\",\n  \"record\",\n  \"file\",\n  \"array\",\n  \"tuple\",\n  \"union\",\n  \"intersection\",\n  \"map\",\n  \"set\",\n  \"enum\",\n  \"literal\",\n  \"nullable\",\n  \"optional\",\n  \"nonoptional\",\n  \"success\",\n  \"transform\",\n  \"default\",\n  \"prefault\",\n  \"catch\",\n  \"nan\",\n  \"pipe\",\n  \"readonly\",\n  \"template_literal\",\n  \"promise\",\n  \"lazy\",\n  \"custom\",\n  // @ts-expect-error -- $ZodTypes includes function after v4.1\n  \"function\",\n] satisfies $ZodTypes[\"_zod\"][\"def\"][\"type\"][]);\n\nexport const isZodTypes = (schema: $ZodType): schema is $ZodTypes => {\n  const type = schema._zod.def.type;\n  return typesSet.has(type);\n};\n\nexport const isSimpleType = (\n  a: $ZodTypes,\n): a is\n  | $ZodString\n  | $ZodNumber\n  | $ZodBoolean\n  | $ZodBigInt\n  | $ZodSymbol\n  | $ZodUndefined\n  | $ZodNull\n  | $ZodAny\n  | $ZodUnknown\n  | $ZodNever\n  | $ZodVoid\n  | $ZodDate\n  | $ZodNaN => {\n  const type = a._zod.def.type;\n  return (\n    type === \"string\" ||\n    type === \"number\" ||\n    type === \"boolean\" ||\n    type === \"bigint\" ||\n    type === \"symbol\" ||\n    type === \"undefined\" ||\n    type === \"null\" ||\n    type === \"any\" ||\n    type === \"unknown\" ||\n    type === \"never\" ||\n    type === \"void\" ||\n    type === \"date\" ||\n    type === \"nan\" ||\n    type === \"file\"\n  );\n};\n\nexport const flatUnwrapUnion = <\n  Options extends readonly SomeType[] = readonly $ZodType[],\n>(\n  unionType: $ZodUnion<Options>,\n): Options => {\n  return unionType._zod.def.options.flatMap((x) => {\n    if (\n      x._zod.def.type === \"union\" &&\n      Array.isArray((x as $ZodUnion)._zod.def.options)\n    ) {\n      return flatUnwrapUnion(x as $ZodUnion);\n    }\n    return x;\n  }) as unknown as Options;\n};\n\nexport const zodToString = (\n  schema: $ZodType,\n  options?: { format?: boolean },\n  indent = 0,\n): string => {\n  if (!isZodTypes(schema)) {\n    return \"z.unknown()\";\n  }\n  const def = schema._zod.def;\n  const type = def.type;\n  const format = options?.format ?? false;\n  const nextIndent = indent + 2;\n  const indentStr = format ? \"\\n\" + \" \".repeat(nextIndent) : \"\";\n  const endIndentStr = format ? \"\\n\" + \" \".repeat(indent) : \"\";\n\n  switch (type) {\n    case \"string\":\n    case \"number\":\n    case \"boolean\":\n    case \"bigint\":\n    case \"symbol\":\n    case \"undefined\":\n    case \"null\":\n    case \"any\":\n    case \"unknown\":\n    case \"never\":\n    case \"void\":\n    case \"date\":\n    case \"nan\":\n      return `z.${type}()`;\n    case \"literal\":\n      const values = def.values as unknown[];\n      return `z.literal(${JSON.stringify(values[0])})`;\n    case \"array\":\n      return `z.array(${zodToString(def.element, options, indent)})`;\n    case \"object\":\n      const shape = def.shape;\n      const shapeStrs = Object.entries(shape).map(\n        ([k, v]) =>\n          `${indentStr}${k}: ${zodToString(v as $ZodType, options, nextIndent)}`,\n      );\n      if (format) {\n        return `z.object({${shapeStrs.join(\",\")}${endIndentStr}})`;\n      }\n      return `z.object({ ${shapeStrs.join(\", \")} })`;\n    case \"tuple\":\n      const items = def.items as $ZodType[];\n      const itemStrs = items.map((i) => zodToString(i, options, nextIndent));\n      if (format && items.length > 0) {\n        return `z.tuple([${indentStr}${itemStrs.join(\",\" + indentStr)}${endIndentStr}])`;\n      }\n      return `z.tuple([${itemStrs.join(\", \")}])`;\n    case \"union\":\n      const optionsList = def.options as $ZodType[];\n      const optStrs = optionsList.map((o) =>\n        zodToString(o, options, nextIndent),\n      );\n      if (format && optionsList.length > 0) {\n        return `z.union([${indentStr}${optStrs.join(\",\" + indentStr)}${endIndentStr}])`;\n      }\n      return `z.union([${optStrs.join(\", \")}])`;\n    case \"intersection\":\n      return `z.intersection(${zodToString(def.left, options, indent)}, ${zodToString(\n        def.right,\n        options,\n        indent,\n      )})`;\n    case \"optional\":\n      return `${zodToString(def.innerType, options, indent)}.optional()`;\n    case \"nullable\":\n      return `${zodToString(def.innerType, options, indent)}.nullable()`;\n    default:\n      return `z.${type}(...)`;\n  }\n};\n","import type { $ZodTypes, $ZodUnion } from \"zod/v4/core\";\nimport { isLegacyZodFunction } from \"./compat.ts\";\nimport { createCompareFn } from \"./create-compare-fn.ts\";\nimport type { CompareRule } from \"./types.ts\";\nimport {\n  flatUnwrapUnion,\n  isSimpleType,\n  isZodType,\n  isZodTypes,\n} from \"./utils.ts\";\n\nexport const isSameTypePresetRules = [\n  // Compatible pre-v4.1 ZodFunction\n  {\n    name: \"compare legacy ZodFunction\",\n    compare: (a, b, next, recheck) => {\n      if (isLegacyZodFunction(a) || isLegacyZodFunction(b)) {\n        if (!isLegacyZodFunction(a) || !isLegacyZodFunction(b)) {\n          return false;\n        }\n        return recheck(\n          {\n            ...a,\n            // @ts-expect-error -- make it look like a ZodType\n            _zod: { def: a.def },\n          },\n          {\n            ...b,\n            _zod: { def: b.def },\n          },\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"unstable warn\",\n    compare: (a, b, next) => {\n      const unstableTypes = new Set<string>([\n        \"transform\",\n        \"default\",\n        \"prefault\",\n        \"success\",\n        \"catch\",\n        \"pipe\",\n        \"lazy\",\n        \"custom\",\n      ] satisfies $ZodTypes[\"_zod\"][\"def\"][\"type\"][]);\n\n      if (\n        unstableTypes.has(a._zod.def.type) ||\n        unstableTypes.has(b._zod.def.type)\n      ) {\n        const aType = a._zod.def.type;\n        const bType = b._zod.def.type;\n        console.warn(\n          [\n            \"[zod-compare] Unstable comparison detected.\",\n            \"This library is designed to compare TypeScript-level types (shape/compatibility).\",\n            \"The involved Zod kinds are not standardized/are unstable and results may be approximate:\",\n            `left.type=\\\"${aType}\\\" right.type=\\\"${bType}\\\".`,\n            \"Consider avoiding these kinds or validating with runtime tests if strict equality is required.\",\n            \"Alternatively, compose your own comparator by defining rules and using createCompareFn to override behavior for these kinds.\",\n            a,\n            b,\n          ].join(\" \"),\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"strict ZodTypes check\",\n    compare: (a, b, next) => {\n      const isZodTypesA = isZodTypes(a);\n      const isZodTypesB = isZodTypes(b);\n      if (!isZodTypesA || !isZodTypesB) {\n        console.warn(\"Failed to compare type! \" + a + \" \" + b);\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"undefined check\",\n    compare: (a, b, next) => {\n      if (a === undefined || b === undefined) {\n        console.warn(\"Failed to compare type! \" + a + \" \" + b);\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare reference\",\n    compare: (a, b, next) => {\n      if (a === b) {\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare type\",\n    compare: (a, b, next) => {\n      const aTypeName = a._zod.def.type;\n      const bTypeName = b._zod.def.type;\n      if (aTypeName !== bTypeName) {\n        return false;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"unwrap innerType\",\n    // ZodOptionalDef\n    // ZodNullableDef\n    // ZodDefaultDef\n    // ZodNonOptionalDef\n    // ZodSuccessDef\n    // ZodCatchDef\n    // ZodReadonlyDef\n    // ZodPromiseDef\n    compare: (a, b, next, recheck) => {\n      const defA = a._zod.def;\n      const defB = b._zod.def;\n      if (\"innerType\" in defA && typeof defA.innerType === \"object\") {\n        if (!(\"innerType\" in defB && typeof defB.innerType === \"object\")) {\n          return false;\n        }\n        if (defA.type !== defB.type) {\n          return false;\n        }\n        const innerA = defA.innerType;\n        const innerB = defB.innerType;\n        if (!isZodType(innerA) || !isZodType(innerB)) {\n          console.warn(\"Failed to compare inner types\", innerA, innerB);\n          return false;\n        }\n        // In ZodDefault/ZodPrefault, the defaultValue will be ignored\n        return recheck(innerA, innerB);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare simple type\",\n    compare: (a, b, next) => {\n      if (isSimpleType(a) || isSimpleType(b)) {\n        const aType = a._zod.def.type;\n        const bType = b._zod.def.type;\n        return aType === bType;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare array\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"array\" && bType === \"array\") {\n        return recheck(a._zod.def.element, b._zod.def.element);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare object\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"object\" && bType === \"object\") {\n        const aShape = a._zod.def.shape;\n        const bShape = b._zod.def.shape;\n        if (Object.keys(aShape).length !== Object.keys(bShape).length)\n          return false;\n        for (const key in aShape) {\n          if (!(key in bShape)) return false;\n          if (!recheck(aShape[key], bShape[key])) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare record\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"record\" && bType === \"record\") {\n        return (\n          recheck(a._zod.def.keyType, b._zod.def.keyType) &&\n          recheck(a._zod.def.valueType, b._zod.def.valueType)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare tuple\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"tuple\" && bType === \"tuple\") {\n        const aItems = a._zod.def.items;\n        const bItems = b._zod.def.items;\n        if (aItems.length !== bItems.length) return false;\n        for (let i = 0; i < aItems.length; i++) {\n          if (!recheck(aItems[i], bItems[i])) return false;\n        }\n        // Compare rest\n        if (a._zod.def.rest || b._zod.def.rest) {\n          // If one has rest, the other must have rest\n          if (!a._zod.def.rest || !b._zod.def.rest) return false;\n          return recheck(a._zod.def.rest, b._zod.def.rest);\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare map\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"map\" && bType === \"map\") {\n        return (\n          recheck(a._zod.def.keyType, b._zod.def.keyType) &&\n          recheck(a._zod.def.valueType, b._zod.def.valueType)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare set\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"set\" && bType === \"set\") {\n        return recheck(a._zod.def.valueType, b._zod.def.valueType);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare enum\",\n    compare: (a, b, next) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"enum\" && bType === \"enum\") {\n        const aEntries = a._zod.def.entries as Record<string, unknown>;\n        const bEntries = b._zod.def.entries as Record<string, unknown>;\n        const aKeys = Object.keys(aEntries);\n        const bKeys = Object.keys(bEntries);\n        if (aKeys.length !== bKeys.length) return false;\n        for (const key of aKeys) {\n          if (!(key in bEntries)) return false;\n          if (aEntries[key] !== bEntries[key]) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare literal\",\n    compare: (a, b, next) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"literal\" && bType === \"literal\") {\n        const aValues = a._zod.def.values as readonly unknown[];\n        const bValues = b._zod.def.values as readonly unknown[];\n        if (aValues.length !== bValues.length) return false;\n        // Treat as set equality of primitive literals\n        const bSet = new Set(bValues);\n        for (const v of aValues) {\n          if (!bSet.has(v)) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare function\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      // Upgrade zod to v4.1 to resolve it\n      // @ts-expect-error -- see https://github.com/colinhacks/zod/issues/4143\n      if (aType === \"function\" && bType === \"function\") {\n        // In Zod4, function def has `input` (tuple-like) and `output` (ZodType)\n        return (\n          // @ts-expect-error\n          recheck(a._zod.def.input, b._zod.def.input) &&\n          // @ts-expect-error\n          recheck(a._zod.def.output, b._zod.def.output)\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare intersection\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"intersection\" && bType === \"intersection\") {\n        const aLeft = a._zod.def.left;\n        const aRight = a._zod.def.right;\n        const bLeft = b._zod.def.left;\n        const bRight = b._zod.def.right;\n        // Commutative: (L==L && R==R) OR (L==R && R==L)\n        const direct = recheck(aLeft, bLeft) && recheck(aRight, bRight);\n        if (direct) return true;\n        const swapped = recheck(aLeft, bRight) && recheck(aRight, bLeft);\n        return swapped;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare union\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"union\" && bType === \"union\") {\n        const aOpts = flatUnwrapUnion(a as $ZodUnion);\n        const bOpts = flatUnwrapUnion(b as $ZodUnion);\n        // Set-like equality (ignore duplicates): A ⊆ B and B ⊆ A\n        const allAInB = aOpts.every((aOpt) =>\n          bOpts.some((bOpt) => recheck(aOpt, bOpt)),\n        );\n        if (!allAInB) return false;\n        const allBInA = bOpts.every((bOpt) =>\n          aOpts.some((aOpt) => recheck(aOpt, bOpt)),\n        );\n        return allBInA;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare template_literal\",\n    compare: (a, b, next, recheck) => {\n      const defA = a._zod.def;\n      const defB = b._zod.def;\n      if (\n        defA.type === \"template_literal\" &&\n        defB.type === \"template_literal\"\n      ) {\n        const aParts = defA.parts;\n        const bParts = defB.parts;\n        if (!Array.isArray(aParts) || !Array.isArray(bParts)) return false;\n        if (aParts.length !== bParts.length) return false;\n        for (let i = 0; i < aParts.length; i++) {\n          const pa = aParts[i];\n          const pb = bParts[i];\n          const isSchemaA = isZodType(pa);\n          const isSchemaB = isZodType(pb);\n          if (isSchemaA || isSchemaB) {\n            if (!(isSchemaA && isSchemaB)) return false;\n            if (!recheck(pa, pb)) return false;\n          } else {\n            // Both should be primitive literal parts\n            if (pa !== pb) return false;\n          }\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare pipe\",\n    compare: (a, b, next, recheck) => {\n      const defA = a._zod.def;\n      const defB = b._zod.def;\n      if (defA.type === \"pipe\" && defB.type === \"pipe\") {\n        return recheck(defA.in, defB.in) && recheck(defA.out, defB.out);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare lazy\",\n    compare: (a, b, next, recheck) => {\n      const aType = a._zod.def.type;\n      const bType = b._zod.def.type;\n      if (aType === \"lazy\" && bType === \"lazy\") {\n        const aGetter = a._zod.def.getter;\n        const bGetter = b._zod.def.getter;\n        // Fast path: same getter function reference\n        if (aGetter === bGetter) return true;\n        const aInner = aGetter();\n        const bInner = bGetter();\n        if (!isZodType(aInner) || !isZodType(bInner)) return false;\n        return recheck(aInner, bInner);\n      }\n      return next();\n    },\n  },\n  // {\n  //   name: \"compare unknown schemas\",\n  //   compare: (a, b, _next, recheck) => {\n  //     return compareSchemas(a, b, recheck);\n  //   },\n  // },\n  {\n    name: \"final fallback\",\n    // ZodTransform\n    compare: () => {\n      return false;\n    },\n  },\n] satisfies CompareRule[];\n\n/**\n * isSameType is a function that checks if two ZodTypes are the same.\n *\n * Caveats:\n * - The function does not validate specific criteria such as min or max values, length, email, etc.\n * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().\n *\n * @param a - The first ZodType to compare.\n * @param b - The second ZodType to compare.\n * @returns A boolean indicating whether the two types are the same.\n *\n * @throws Will throw an error if it encounters an unknown type.\n *\n * @example\n * ```ts\n * isSameType(z.string(), z.string()); // true\n * isSameType(z.string(), z.number()); // false\n * ```\n */\nexport const isSameType = createCompareFn(isSameTypePresetRules);\n","import type { $ZodUnion } from \"zod/v4/core\";\nimport { createCompareFn } from \"./create-compare-fn.ts\";\nimport { isSameType } from \"./is-same-type.ts\";\nimport type { CompareRule } from \"./types.ts\";\nimport { flatUnwrapUnion, isZodType } from \"./utils.ts\";\n\nexport const isCompatibleTypePresetRules: CompareRule[] = [\n  {\n    name: \"is same type\",\n    compare: (higherType, lowerType, next) => {\n      if (isSameType(higherType, lowerType)) {\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check typeName\",\n    compare: (higherType, lowerType, next) => {\n      // In Zod4, type information is in _zod.def\n      if (\n        !(\"_zod\" in higherType) ||\n        !(\"def\" in higherType._zod) ||\n        !(\"_zod\" in lowerType) ||\n        !(\"def\" in lowerType._zod)\n      ) {\n        throw new Error(\n          \"Failed to compare type! \" + higherType + \" \" + lowerType,\n        );\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check optional/nullable on lower\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const lowerDef = lowerType._zod.def;\n      if (\n        (lowerDef.type === \"optional\" || lowerDef.type === \"nullable\") &&\n        \"innerType\" in lowerDef &&\n        typeof lowerDef.innerType === \"object\" &&\n        isZodType(lowerDef.innerType)\n      ) {\n        return recheck(higherType, lowerDef.innerType);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check union\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"union\" && bType === \"union\") {\n        const aOpts = flatUnwrapUnion(higherType as $ZodUnion);\n        const bOpts = flatUnwrapUnion(lowerType as $ZodUnion);\n        // Every option in higher must be accepted by at least one option in lower\n        return aOpts.every((optA) => bOpts.some((optB) => recheck(optA, optB)));\n      }\n      if (aType === \"union\") {\n        const aOpts = flatUnwrapUnion(higherType as $ZodUnion);\n        // All options from higher must be compatible with the (non-union) lower\n        return aOpts.every((opt) => recheck(opt, lowerType));\n      }\n      if (bType === \"union\") {\n        const bOpts = flatUnwrapUnion(lowerType as $ZodUnion);\n        // Higher must match at least one option in lower\n        return bOpts.some((opt) => recheck(higherType, opt));\n      }\n      return next();\n    },\n  },\n  {\n    name: \"compare type by kind\",\n    compare: (higherType, lowerType, next) => {\n      const aTypeName = higherType._zod.def.type;\n      const bTypeName = lowerType._zod.def.type;\n      if (aTypeName !== bTypeName) return false;\n      return next();\n    },\n  },\n  {\n    name: \"check object (structural subset)\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"object\" && bType === \"object\") {\n        const superShape = higherType._zod.def.shape;\n        const subShape = lowerType._zod.def.shape;\n        if (Object.keys(superShape).length < Object.keys(subShape).length)\n          return false;\n        for (const key in subShape) {\n          if (!(key in superShape)) return false;\n          if (!recheck(superShape[key], subShape[key])) return false;\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check array\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"array\" && bType === \"array\") {\n        return recheck(higherType._zod.def.element, lowerType._zod.def.element);\n      }\n      return next();\n    },\n  },\n  {\n    name: \"check tuple (length and rest)\",\n    compare: (higherType, lowerType, next, recheck) => {\n      const aType = higherType._zod.def.type;\n      const bType = lowerType._zod.def.type;\n      if (aType === \"tuple\" && bType === \"tuple\") {\n        const aItems = higherType._zod.def.items;\n        const bItems = lowerType._zod.def.items;\n        if (aItems.length < bItems.length) return false;\n        for (let i = 0; i < bItems.length; i++) {\n          if (!recheck(aItems[i], bItems[i])) return false;\n        }\n        // If lower has rest, higher must have rest and be compatible\n        const aRest = higherType._zod.def.rest;\n        const bRest = lowerType._zod.def.rest;\n        if (bRest) {\n          if (!aRest) return false;\n          return recheck(aRest, bRest);\n        }\n        return true;\n      }\n      return next();\n    },\n  },\n];\n\n/**\n * Check if a the higherType matches the lowerType\n *\n * @deprecated This a unstable API and still in development\n *\n * @param higherType The looser type\n * @param lowerType The stricter type\n *\n * @example\n * ```ts\n * isCompatibleType(z.string(), z.string()); // true\n *\n * isCompatibleType(\n *   z.object({ name: z.string(), other: z.number() }),\n *   z.object({ name: z.string() })\n * );\n * // true\n * ```\n */\nexport const isCompatibleType = createCompareFn(isCompatibleTypePresetRules);\n"],"names":["isLegacyZodFunction","maybeSchema","createCompareFn","rules","isSameTypeFn","left","right","context","prevIndex","runner","index","rule","strictA","strictB","compareResult","a","isZodType","typesSet","isZodTypes","schema","type","isSimpleType","flatUnwrapUnion","unionType","x","isSameTypePresetRules","b","next","recheck","unstableTypes","aType","bType","isZodTypesA","isZodTypesB","aTypeName","bTypeName","defA","defB","innerA","innerB","aShape","bShape","key","aItems","bItems","i","aEntries","bEntries","aKeys","bKeys","aValues","bValues","bSet","v","aLeft","aRight","bLeft","bRight","aOpts","bOpts","aOpt","bOpt","aParts","bParts","pa","pb","isSchemaA","isSchemaB","aGetter","bGetter","aInner","bInner","isSameType","isCompatibleTypePresetRules","higherType","lowerType","lowerDef","optA","optB","opt","superShape","subShape","aRest","bRest","isCompatibleType"],"mappings":"AAkBO,MAAMA,IAAsB,CACjCC,MAEI,OAAOA,KAAgB,YAAYA,MAAgB,QAGnD,UAAUA,KAIZ,EAAE,SAASA,MACX,OAAOA,EAAY,OAAW,YAC9BA,EAAY,QAAW,QAKvB,EAAE,UAAUA,EAAY,QACxB,OAAOA,EAAY,IAAI,QAAS,WAEzB,KAGPA,EAAY,IAAI,SAAS,cACzB,WAAWA,EAAY,OACvB,YAAYA,EAAY,KCtCfC,IAAkB,CAACC,MAAyB;AACvD,QAAMC,IAAe,CACnBC,GACAC,GACAC,IAA0B,CAAA,MACd;AACZ,QAAIC,IAAY;AAChB,UAAMC,IAAS,CAACC,MAA2B;AACzC,UAAIA,MAAUP,EAAM;AAClB,uBAAQ,MAAM,6BAA6BE,IAAO,MAAMC,CAAK,GACtD;AAET,UAAII,MAAUF;AACZ,uBAAQ,MAAM,8BAA8B,GACrC;AAET,MAAAA,IAAYE;AACZ,YAAMC,IAAOR,EAAMO,CAAK,GAGlBE,IAAUP,GACVQ,IAAUP,GAEVQ,IAAgBH,EAAK;AAAA,QACzBC;AAAA,QACAC;AAAA,QACA,MAAMJ,EAAOC,IAAQ,CAAC;AAAA,QACtB,CAACK,GAAG,MAAMX,EAAaW,GAAG,GAAGR,CAAO;AAAA,QACpCA;AAAA,MAAA;AAGF,aAAI,YAAYA,KAAW,MAAM,QAAQA,EAAQ,MAAM,KACrDA,EAAQ,OAAO,KAAK;AAAA,QAClB,MAAMI,EAAK;AAAA,QACX,QAAQ,CAACC,GAASC,CAAO;AAAA,QACzB,QAAQC;AAAA,MAAA,CACT,GAGIA;AAAA,IACT;AAEA,WAAOL,EAAO,CAAC;AAAA,EACjB;AACA,SAAOL;AACT,GC9BaY,IAAY,CAACf,MACpB,OAAOA,KAAgB,YAAYA,MAAgB,QAIrD,EAAE,eAAeA,MACjB,OAAOA,EAAY,WAAW,KAAM,WAE7B,KAGNA,EAAY,WAAW,EAA4B,WAAc,OAIhEgB,wBAA4B,IAAI;AAAA,EACpC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAEA;AACF,CAA8C,GAEjCC,IAAa,CAACC,MAA0C;AACnE,QAAMC,IAAOD,EAAO,KAAK,IAAI;AAC7B,SAAOF,EAAS,IAAIG,CAAI;AAC1B,GAEaC,IAAe,CAC1BN,MAca;AACb,QAAMK,IAAOL,EAAE,KAAK,IAAI;AACxB,SACEK,MAAS,YACTA,MAAS,YACTA,MAAS,aACTA,MAAS,YACTA,MAAS,YACTA,MAAS,eACTA,MAAS,UACTA,MAAS,SACTA,MAAS,aACTA,MAAS,WACTA,MAAS,UACTA,MAAS,UACTA,MAAS,SACTA,MAAS;AAEb,GAEaE,IAAkB,CAG7BC,MAEOA,EAAU,KAAK,IAAI,QAAQ,QAAQ,CAACC,MAEvCA,EAAE,KAAK,IAAI,SAAS,WACpB,MAAM,QAASA,EAAgB,KAAK,IAAI,OAAO,IAExCF,EAAgBE,CAAc,IAEhCA,CACR,GCxHUC,IAAwB;AAAA;AAAA,EAEnC;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACV,GAAGW,GAAGC,GAAMC,MAChB5B,EAAoBe,CAAC,KAAKf,EAAoB0B,CAAC,IAC7C,CAAC1B,EAAoBe,CAAC,KAAK,CAACf,EAAoB0B,CAAC,IAC5C,KAEFE;AAAA,MACL;AAAA,QACE,GAAGb;AAAA;AAAA,QAEH,MAAM,EAAE,KAAKA,EAAE,IAAA;AAAA,MAAI;AAAA,MAErB;AAAA,QACE,GAAGW;AAAA,QACH,MAAM,EAAE,KAAKA,EAAE,IAAA;AAAA,MAAI;AAAA,IACrB,IAGGC,EAAA;AAAA,EACT;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,MAAS;AACvB,YAAME,wBAAoB,IAAY;AAAA,QACpC;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MAAA,CAC4C;AAE9C,UACEA,EAAc,IAAId,EAAE,KAAK,IAAI,IAAI,KACjCc,EAAc,IAAIH,EAAE,KAAK,IAAI,IAAI,GACjC;AACA,cAAMI,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,gBAAQ;AAAA,UACN;AAAA,YACE;AAAA,YACA;AAAA,YACA;AAAA,YACA,cAAeI,CAAK,iBAAmBC,CAAK;AAAA,YAC5C;AAAA,YACA;AAAA,YACAhB;AAAA,YACAW;AAAA,UAAA,EACA,KAAK,GAAG;AAAA,QAAA;AAAA,MAEd;AACA,aAAOC,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,MAAS;AACvB,YAAMK,IAAcd,EAAWH,CAAC,GAC1BkB,IAAcf,EAAWQ,CAAC;AAChC,aAAI,CAACM,KAAe,CAACC,KACnB,QAAQ,KAAK,6BAA6BlB,IAAI,MAAMW,CAAC,GAC9C,MAEFC,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,MACVZ,MAAM,UAAaW,MAAM,UAC3B,QAAQ,KAAK,6BAA6BX,IAAI,MAAMW,CAAC,GAC9C,MAEFC,EAAA;AAAA,EACT;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,MACVZ,MAAMW,IACD,KAEFC,EAAA;AAAA,EACT;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,MAAS;AACvB,YAAMO,IAAYnB,EAAE,KAAK,IAAI,MACvBoB,IAAYT,EAAE,KAAK,IAAI;AAC7B,aAAIQ,MAAcC,IACT,KAEFR,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAMQ,IAAOrB,EAAE,KAAK,KACdsB,IAAOX,EAAE,KAAK;AACpB,UAAI,eAAeU,KAAQ,OAAOA,EAAK,aAAc,UAAU;AAI7D,YAHI,EAAE,eAAeC,KAAQ,OAAOA,EAAK,aAAc,aAGnDD,EAAK,SAASC,EAAK;AACrB,iBAAO;AAET,cAAMC,IAASF,EAAK,WACdG,IAASF,EAAK;AACpB,eAAI,CAACrB,EAAUsB,CAAM,KAAK,CAACtB,EAAUuB,CAAM,KACzC,QAAQ,KAAK,iCAAiCD,GAAQC,CAAM,GACrD,MAGFX,EAAQU,GAAQC,CAAM;AAAA,MAC/B;AACA,aAAOZ,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,MAAS;AACvB,UAAIN,EAAaN,CAAC,KAAKM,EAAaK,CAAC,GAAG;AACtC,cAAMI,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,eAAOI,MAAUC;AAAA,MACnB;AACA,aAAOJ,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAME,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,aAAII,MAAU,WAAWC,MAAU,UAC1BH,EAAQb,EAAE,KAAK,IAAI,SAASW,EAAE,KAAK,IAAI,OAAO,IAEhDC,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAME,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,UAAII,MAAU,YAAYC,MAAU,UAAU;AAC5C,cAAMS,IAASzB,EAAE,KAAK,IAAI,OACpB0B,IAASf,EAAE,KAAK,IAAI;AAC1B,YAAI,OAAO,KAAKc,CAAM,EAAE,WAAW,OAAO,KAAKC,CAAM,EAAE;AACrD,iBAAO;AACT,mBAAWC,KAAOF;AAEhB,cADI,EAAEE,KAAOD,MACT,CAACb,EAAQY,EAAOE,CAAG,GAAGD,EAAOC,CAAG,CAAC,EAAG,QAAO;AAEjD,eAAO;AAAA,MACT;AACA,aAAOf,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAME,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,aAAII,MAAU,YAAYC,MAAU,WAEhCH,EAAQb,EAAE,KAAK,IAAI,SAASW,EAAE,KAAK,IAAI,OAAO,KAC9CE,EAAQb,EAAE,KAAK,IAAI,WAAWW,EAAE,KAAK,IAAI,SAAS,IAG/CC,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAME,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,UAAII,MAAU,WAAWC,MAAU,SAAS;AAC1C,cAAMY,IAAS5B,EAAE,KAAK,IAAI,OACpB6B,IAASlB,EAAE,KAAK,IAAI;AAC1B,YAAIiB,EAAO,WAAWC,EAAO,OAAQ,QAAO;AAC5C,iBAASC,IAAI,GAAGA,IAAIF,EAAO,QAAQE;AACjC,cAAI,CAACjB,EAAQe,EAAOE,CAAC,GAAGD,EAAOC,CAAC,CAAC,EAAG,QAAO;AAG7C,eAAI9B,EAAE,KAAK,IAAI,QAAQW,EAAE,KAAK,IAAI,OAE5B,CAACX,EAAE,KAAK,IAAI,QAAQ,CAACW,EAAE,KAAK,IAAI,OAAa,KAC1CE,EAAQb,EAAE,KAAK,IAAI,MAAMW,EAAE,KAAK,IAAI,IAAI,IAE1C;AAAA,MACT;AACA,aAAOC,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAME,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,aAAII,MAAU,SAASC,MAAU,QAE7BH,EAAQb,EAAE,KAAK,IAAI,SAASW,EAAE,KAAK,IAAI,OAAO,KAC9CE,EAAQb,EAAE,KAAK,IAAI,WAAWW,EAAE,KAAK,IAAI,SAAS,IAG/CC,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAME,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,aAAII,MAAU,SAASC,MAAU,QACxBH,EAAQb,EAAE,KAAK,IAAI,WAAWW,EAAE,KAAK,IAAI,SAAS,IAEpDC,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,MAAS;AACvB,YAAMG,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,UAAII,MAAU,UAAUC,MAAU,QAAQ;AACxC,cAAMe,IAAW/B,EAAE,KAAK,IAAI,SACtBgC,IAAWrB,EAAE,KAAK,IAAI,SACtBsB,IAAQ,OAAO,KAAKF,CAAQ,GAC5BG,IAAQ,OAAO,KAAKF,CAAQ;AAClC,YAAIC,EAAM,WAAWC,EAAM,OAAQ,QAAO;AAC1C,mBAAWP,KAAOM;AAEhB,cADI,EAAEN,KAAOK,MACTD,EAASJ,CAAG,MAAMK,EAASL,CAAG,EAAG,QAAO;AAE9C,eAAO;AAAA,MACT;AACA,aAAOf,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,MAAS;AACvB,YAAMG,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,UAAII,MAAU,aAAaC,MAAU,WAAW;AAC9C,cAAMmB,IAAUnC,EAAE,KAAK,IAAI,QACrBoC,IAAUzB,EAAE,KAAK,IAAI;AAC3B,YAAIwB,EAAQ,WAAWC,EAAQ,OAAQ,QAAO;AAE9C,cAAMC,IAAO,IAAI,IAAID,CAAO;AAC5B,mBAAWE,KAAKH;AACd,cAAI,CAACE,EAAK,IAAIC,CAAC,EAAG,QAAO;AAE3B,eAAO;AAAA,MACT;AACA,aAAO1B,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAME,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AAGzB,aAAII,MAAU,cAAcC,MAAU;AAAA;AAAA,QAIlCH,EAAQb,EAAE,KAAK,IAAI,OAAOW,EAAE,KAAK,IAAI,KAAK;AAAA,QAE1CE,EAAQb,EAAE,KAAK,IAAI,QAAQW,EAAE,KAAK,IAAI,MAAM;AAAA,UAGzCC,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAME,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,UAAII,MAAU,kBAAkBC,MAAU,gBAAgB;AACxD,cAAMuB,IAAQvC,EAAE,KAAK,IAAI,MACnBwC,IAASxC,EAAE,KAAK,IAAI,OACpByC,IAAQ9B,EAAE,KAAK,IAAI,MACnB+B,IAAS/B,EAAE,KAAK,IAAI;AAG1B,eADeE,EAAQ0B,GAAOE,CAAK,KAAK5B,EAAQ2B,GAAQE,CAAM,IAC3C,KACH7B,EAAQ0B,GAAOG,CAAM,KAAK7B,EAAQ2B,GAAQC,CAAK;AAAA,MAEjE;AACA,aAAO7B,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAME,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,UAAII,MAAU,WAAWC,MAAU,SAAS;AAC1C,cAAM2B,IAAQpC,EAAgBP,CAAc,GACtC4C,IAAQrC,EAAgBI,CAAc;AAK5C,eAHgBgC,EAAM;AAAA,UAAM,CAACE,MAC3BD,EAAM,KAAK,CAACE,MAASjC,EAAQgC,GAAMC,CAAI,CAAC;AAAA,QAAA,IAG1BF,EAAM;AAAA,UAAM,CAACE,MAC3BH,EAAM,KAAK,CAACE,MAAShC,EAAQgC,GAAMC,CAAI,CAAC;AAAA,QAAA,IAFrB;AAAA,MAKvB;AACA,aAAOlC,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAMQ,IAAOrB,EAAE,KAAK,KACdsB,IAAOX,EAAE,KAAK;AACpB,UACEU,EAAK,SAAS,sBACdC,EAAK,SAAS,oBACd;AACA,cAAMyB,IAAS1B,EAAK,OACd2B,IAAS1B,EAAK;AAEpB,YADI,CAAC,MAAM,QAAQyB,CAAM,KAAK,CAAC,MAAM,QAAQC,CAAM,KAC/CD,EAAO,WAAWC,EAAO,OAAQ,QAAO;AAC5C,iBAASlB,IAAI,GAAGA,IAAIiB,EAAO,QAAQjB,KAAK;AACtC,gBAAMmB,IAAKF,EAAOjB,CAAC,GACboB,IAAKF,EAAOlB,CAAC,GACbqB,IAAYlD,EAAUgD,CAAE,GACxBG,IAAYnD,EAAUiD,CAAE;AAC9B,cAAIC,KAAaC;AAEf,gBADI,EAAED,KAAaC,MACf,CAACvC,EAAQoC,GAAIC,CAAE,EAAG,QAAO;AAAA,qBAGzBD,MAAOC,EAAI,QAAO;AAAA,QAE1B;AACA,eAAO;AAAA,MACT;AACA,aAAOtC,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAMQ,IAAOrB,EAAE,KAAK,KACdsB,IAAOX,EAAE,KAAK;AACpB,aAAIU,EAAK,SAAS,UAAUC,EAAK,SAAS,SACjCT,EAAQQ,EAAK,IAAIC,EAAK,EAAE,KAAKT,EAAQQ,EAAK,KAAKC,EAAK,GAAG,IAEzDV,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACZ,GAAGW,GAAGC,GAAMC,MAAY;AAChC,YAAME,IAAQf,EAAE,KAAK,IAAI,MACnBgB,IAAQL,EAAE,KAAK,IAAI;AACzB,UAAII,MAAU,UAAUC,MAAU,QAAQ;AACxC,cAAMqC,IAAUrD,EAAE,KAAK,IAAI,QACrBsD,IAAU3C,EAAE,KAAK,IAAI;AAE3B,YAAI0C,MAAYC,EAAS,QAAO;AAChC,cAAMC,IAASF,EAAA,GACTG,IAASF,EAAA;AACf,eAAI,CAACrD,EAAUsD,CAAM,KAAK,CAACtD,EAAUuD,CAAM,IAAU,KAC9C3C,EAAQ0C,GAAQC,CAAM;AAAA,MAC/B;AACA,aAAO5C,EAAA;AAAA,IACT;AAAA,EAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQF;AAAA,IACE,MAAM;AAAA;AAAA,IAEN,SAAS,MACA;AAAA,EACT;AAEJ,GAqBa6C,IAAatE,EAAgBuB,CAAqB,GClblDgD,IAA6C;AAAA,EACxD;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAACC,GAAYC,GAAWhD,MAC3B6C,EAAWE,GAAYC,CAAS,IAC3B,KAEFhD,EAAA;AAAA,EACT;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAAC+C,GAAYC,GAAWhD,MAAS;AAExC,UACE,EAAE,UAAU+C,MACZ,EAAE,SAASA,EAAW,SACtB,EAAE,UAAUC,MACZ,EAAE,SAASA,EAAU;AAErB,cAAM,IAAI;AAAA,UACR,6BAA6BD,IAAa,MAAMC;AAAA,QAAA;AAGpD,aAAOhD,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAAC+C,GAAYC,GAAWhD,GAAMC,MAAY;AACjD,YAAMgD,IAAWD,EAAU,KAAK;AAChC,cACGC,EAAS,SAAS,cAAcA,EAAS,SAAS,eACnD,eAAeA,KACf,OAAOA,EAAS,aAAc,YAC9B5D,EAAU4D,EAAS,SAAS,IAErBhD,EAAQ8C,GAAYE,EAAS,SAAS,IAExCjD,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAAC+C,GAAYC,GAAWhD,GAAMC,MAAY;AACjD,YAAME,IAAQ4C,EAAW,KAAK,IAAI,MAC5B3C,IAAQ4C,EAAU,KAAK,IAAI;AACjC,UAAI7C,MAAU,WAAWC,MAAU,SAAS;AAC1C,cAAM2B,IAAQpC,EAAgBoD,CAAuB,GAC/Cf,IAAQrC,EAAgBqD,CAAsB;AAEpD,eAAOjB,EAAM,MAAM,CAACmB,MAASlB,EAAM,KAAK,CAACmB,MAASlD,EAAQiD,GAAMC,CAAI,CAAC,CAAC;AAAA,MACxE;AACA,aAAIhD,MAAU,UACER,EAAgBoD,CAAuB,EAExC,MAAM,CAACK,MAAQnD,EAAQmD,GAAKJ,CAAS,CAAC,IAEjD5C,MAAU,UACET,EAAgBqD,CAAsB,EAEvC,KAAK,CAACI,MAAQnD,EAAQ8C,GAAYK,CAAG,CAAC,IAE9CpD,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAAC+C,GAAYC,GAAWhD,MAAS;AACxC,YAAMO,IAAYwC,EAAW,KAAK,IAAI,MAChCvC,IAAYwC,EAAU,KAAK,IAAI;AACrC,aAAIzC,MAAcC,IAAkB,KAC7BR,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAAC+C,GAAYC,GAAWhD,GAAMC,MAAY;AACjD,YAAME,IAAQ4C,EAAW,KAAK,IAAI,MAC5B3C,IAAQ4C,EAAU,KAAK,IAAI;AACjC,UAAI7C,MAAU,YAAYC,MAAU,UAAU;AAC5C,cAAMiD,IAAaN,EAAW,KAAK,IAAI,OACjCO,IAAWN,EAAU,KAAK,IAAI;AACpC,YAAI,OAAO,KAAKK,CAAU,EAAE,SAAS,OAAO,KAAKC,CAAQ,EAAE;AACzD,iBAAO;AACT,mBAAWvC,KAAOuC;AAEhB,cADI,EAAEvC,KAAOsC,MACT,CAACpD,EAAQoD,EAAWtC,CAAG,GAAGuC,EAASvC,CAAG,CAAC,EAAG,QAAO;AAEvD,eAAO;AAAA,MACT;AACA,aAAOf,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAAC+C,GAAYC,GAAWhD,GAAMC,MAAY;AACjD,YAAME,IAAQ4C,EAAW,KAAK,IAAI,MAC5B3C,IAAQ4C,EAAU,KAAK,IAAI;AACjC,aAAI7C,MAAU,WAAWC,MAAU,UAC1BH,EAAQ8C,EAAW,KAAK,IAAI,SAASC,EAAU,KAAK,IAAI,OAAO,IAEjEhD,EAAA;AAAA,IACT;AAAA,EAAA;AAAA,EAEF;AAAA,IACE,MAAM;AAAA,IACN,SAAS,CAAC+C,GAAYC,GAAWhD,GAAMC,MAAY;AACjD,YAAME,IAAQ4C,EAAW,KAAK,IAAI,MAC5B3C,IAAQ4C,EAAU,KAAK,IAAI;AACjC,UAAI7C,MAAU,WAAWC,MAAU,SAAS;AAC1C,cAAMY,IAAS+B,EAAW,KAAK,IAAI,OAC7B9B,IAAS+B,EAAU,KAAK,IAAI;AAClC,YAAIhC,EAAO,SAASC,EAAO,OAAQ,QAAO;AAC1C,iBAAS,IAAI,GAAG,IAAIA,EAAO,QAAQ;AACjC,cAAI,CAAChB,EAAQe,EAAO,CAAC,GAAGC,EAAO,CAAC,CAAC,EAAG,QAAO;AAG7C,cAAMsC,IAAQR,EAAW,KAAK,IAAI,MAC5BS,IAAQR,EAAU,KAAK,IAAI;AACjC,eAAIQ,IACGD,IACEtD,EAAQsD,GAAOC,CAAK,IADR,KAGd;AAAA,MACT;AACA,aAAOxD,EAAA;AAAA,IACT;AAAA,EAAA;AAEJ,GAqBayD,IAAmBlF,EAAgBuE,CAA2B;"}

package/dist/zod4/utils.d.ts

@@ -3,7 +3,6 @@ export declare const isZodType: (maybeSchema: unknown) => maybeSchema is $ZodTyp
 export declare const isZodTypes: (schema: $ZodType) => schema is $ZodTypes;
 export declare const isSimpleType: (a: $ZodTypes) => a is $ZodString | $ZodNumber | $ZodBoolean | $ZodBigInt | $ZodSymbol | $ZodUndefined | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodDate | $ZodNaN;
 export declare const flatUnwrapUnion: <Options extends readonly SomeType[] = readonly $ZodType[]>(unionType: $ZodUnion<Options>) => Options;
-/**
- * @deprecated Not used
- */
-export declare const compareSchemas: (a: $ZodTypes, b: $ZodTypes, compareZod: (a: $ZodTypes, b: $ZodTypes) => boolean) => boolean;
+export declare const zodToString: (schema: $ZodType, options?: {
+    format?: boolean;
+}, indent?: number) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-compare",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Compare two Zod schemas recursively.",
   "keywords": [
     "zod",
@@ -51,6 +51,8 @@
     "format:fix": "prettier --write .",
     "typeCheck": "tsc --noEmit",
     "test": "vitest",
+    "playground": "vite playground",
+    "build:playground": "vite build -c vite.config.playground.ts",
     "changeset": "changeset",
     "release": "pnpm run build && changeset publish"
   },

package/src/index.ts

@@ -4,11 +4,13 @@ import { haveSameZodMajor, isZod3Schema, isZod4Schema } from "./utils.ts";
 import {
   isCompatibleType as isCompatibleZod3Type,
   isSameType as isSameZod3Type,
+  type CompareContext as CompareContext3,
 } from "./zod3/index.ts";
 import type { LegacyZodFunction } from "./zod4/compat.ts";
 import {
   isCompatibleType as isCompatibleZod4Type,
   isSameType as isSameZod4Type,
+  type CompareContext as CompareContext4,
 } from "./zod4/index.ts";
 
 // Export versions checking utilities
@@ -36,12 +38,13 @@ export { haveSameZodMajor, isZod3Schema, isZod4Schema };
 export const isSameType = (
   a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,
   b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction,
+  context?: CompareContext3 & CompareContext4,
 ): boolean => {
   if (isZod4Schema(a) && isZod4Schema(b)) {
-    return isSameZod4Type(a, b);
+    return isSameZod4Type(a, b, context as CompareContext4);
   }
   if (isZod3Schema(a) && isZod3Schema(b)) {
-    return isSameZod3Type(a, b);
+    return isSameZod3Type(a, b, context as CompareContext3);
   }
   throw new Error("Failed to compare types: different Zod versions");
 };

package/src/zod4/__tests__/__snapshots__/shape.test.ts.snap

@@ -362,6 +362,164 @@ $ZodFunction {
 }
 `;
 
+exports[`snapshot > should z.function() with void input match snapshot 1`] = `
+$ZodFunction {
+  "_def": {
+    "input": {
+      "_zod": {
+        "def": {
+          "element": {
+            "_zod": {
+              "def": {
+                "type": "unknown",
+              },
+            },
+            "~standard": {
+              "validate": [Function],
+              "vendor": "zod",
+              "version": 1,
+            },
+          },
+          "type": "array",
+        },
+      },
+      "~standard": {
+        "validate": [Function],
+        "vendor": "zod",
+        "version": 1,
+      },
+    },
+    "output": {
+      "_zod": {
+        "def": {
+          "type": "void",
+        },
+      },
+      "def": {
+        "type": "void",
+      },
+      "~standard": {
+        "validate": [Function],
+        "vendor": "zod",
+        "version": 1,
+      },
+    },
+    "type": "function",
+  },
+  "def": {
+    "input": {
+      "_zod": {
+        "def": {
+          "element": {
+            "_zod": {
+              "def": {
+                "type": "unknown",
+              },
+            },
+            "~standard": {
+              "validate": [Function],
+              "vendor": "zod",
+              "version": 1,
+            },
+          },
+          "type": "array",
+        },
+      },
+      "~standard": {
+        "validate": [Function],
+        "vendor": "zod",
+        "version": 1,
+      },
+    },
+    "output": {
+      "_zod": {
+        "def": {
+          "type": "void",
+        },
+      },
+      "def": {
+        "type": "void",
+      },
+      "~standard": {
+        "validate": [Function],
+        "vendor": "zod",
+        "version": 1,
+      },
+    },
+    "type": "function",
+  },
+}
+`;
+
+exports[`snapshot > should z.function() with void input match snapshot 2`] = `
+$ZodFunction {
+  "_def": {
+    "input": {
+      "_zod": {
+        "def": {
+          "items": [],
+          "rest": null,
+          "type": "tuple",
+        },
+      },
+      "~standard": {
+        "validate": [Function],
+        "vendor": "zod",
+        "version": 1,
+      },
+    },
+    "output": {
+      "_zod": {
+        "def": {
+          "type": "void",
+        },
+      },
+      "def": {
+        "type": "void",
+      },
+      "~standard": {
+        "validate": [Function],
+        "vendor": "zod",
+        "version": 1,
+      },
+    },
+    "type": "function",
+  },
+  "def": {
+    "input": {
+      "_zod": {
+        "def": {
+          "items": [],
+          "rest": null,
+          "type": "tuple",
+        },
+      },
+      "~standard": {
+        "validate": [Function],
+        "vendor": "zod",
+        "version": 1,
+      },
+    },
+    "output": {
+      "_zod": {
+        "def": {
+          "type": "void",
+        },
+      },
+      "def": {
+        "type": "void",
+      },
+      "~standard": {
+        "validate": [Function],
+        "vendor": "zod",
+        "version": 1,
+      },
+    },
+    "type": "function",
+  },
+}
+`;
+
 exports[`snapshot > should z.intersection() match snapshot 1`] = `
 {
   "_zod": {
@@ -874,6 +1032,202 @@ exports[`snapshot > should z.object() match snapshot 2`] = `
 }
 `;
 
+exports[`snapshot > should z.object() variant match snapshot 1`] = `
+{
+  "_zod": {
+    "def": {
+      "catchall": {
+        "_zod": {
+          "def": {
+            "type": "unknown",
+          },
+        },
+        "def": {
+          "type": "unknown",
+        },
+        "~standard": {
+          "validate": [Function],
+          "vendor": "zod",
+          "version": 1,
+        },
+      },
+      "shape": {},
+      "type": "object",
+    },
+  },
+  "def": {
+    "catchall": {
+      "_zod": {
+        "def": {
+          "type": "unknown",
+        },
+      },
+      "def": {
+        "type": "unknown",
+      },
+      "~standard": {
+        "validate": [Function],
+        "vendor": "zod",
+        "version": 1,
+      },
+    },
+    "shape": {},
+    "type": "object",
+  },
+  "~standard": {
+    "validate": [Function],
+    "vendor": "zod",
+    "version": 1,
+  },
+}
+`;
+
+exports[`snapshot > should z.object() variant match snapshot 2`] = `
+{
+  "_zod": {
+    "def": {
+      "catchall": {
+        "_zod": {
+          "def": {
+            "type": "never",
+          },
+        },
+        "def": {
+          "type": "never",
+        },
+        "~standard": {
+          "validate": [Function],
+          "vendor": "zod",
+          "version": 1,
+        },
+      },
+      "shape": {},
+      "type": "object",
+    },
+  },
+  "def": {
+    "catchall": {
+      "_zod": {
+        "def": {
+          "type": "never",
+        },
+      },
+      "def": {
+        "type": "never",
+      },
+      "~standard": {
+        "validate": [Function],
+        "vendor": "zod",
+        "version": 1,
+      },
+    },
+    "shape": {},
+    "type": "object",
+  },
+  "~standard": {
+    "validate": [Function],
+    "vendor": "zod",
+    "version": 1,
+  },
+}
+`;
+
+exports[`snapshot > should z.promise() match snapshot 1`] = `
+{
+  "_zod": {
+    "def": {
+      "innerType": {
+        "_zod": {
+          "def": {
+            "type": "string",
+          },
+        },
+        "def": {
+          "type": "string",
+        },
+        "~standard": {
+          "validate": [Function],
+          "vendor": "zod",
+          "version": 1,
+        },
+      },
+      "type": "promise",
+    },
+  },
+  "def": {
+    "innerType": {
+      "_zod": {
+        "def": {
+          "type": "string",
+        },
+      },
+      "def": {
+        "type": "string",
+      },
+      "~standard": {
+        "validate": [Function],
+        "vendor": "zod",
+        "version": 1,
+      },
+    },
+    "type": "promise",
+  },
+  "~standard": {
+    "validate": [Function],
+    "vendor": "zod",
+    "version": 1,
+  },
+}
+`;
+
+exports[`snapshot > should z.promise() match snapshot 2`] = `
+{
+  "_zod": {
+    "def": {
+      "innerType": {
+        "_zod": {
+          "def": {
+            "type": "string",
+          },
+        },
+        "def": {
+          "type": "string",
+        },
+        "~standard": {
+          "validate": [Function],
+          "vendor": "zod",
+          "version": 1,
+        },
+      },
+      "type": "promise",
+    },
+  },
+  "def": {
+    "innerType": {
+      "_zod": {
+        "def": {
+          "type": "string",
+        },
+      },
+      "def": {
+        "type": "string",
+      },
+      "~standard": {
+        "validate": [Function],
+        "vendor": "zod",
+        "version": 1,
+      },
+    },
+    "type": "promise",
+  },
+  "~standard": {
+    "validate": [Function],
+    "vendor": "zod",
+    "version": 1,
+  },
+}
+`;
+
 exports[`snapshot > should z.record() match snapshot 1`] = `
 {
   "_zod": {

package/src/zod4/__tests__/shape.test.ts

@@ -101,4 +101,20 @@ describe("snapshot", () => {
       zm.function({ input: [z.string()], output: z.number() }),
     ).toMatchSnapshot();
   });
+
+  test("should z.function() with void input match snapshot", () => {
+    // Ignore `input` is invalid, parameters must be an array or a ZodTuple
+    expect(z.function({ output: z.void() })).toMatchSnapshot();
+    expect(z.function({ input: [], output: z.void() })).toMatchSnapshot();
+  });
+
+  test("should z.object() variant match snapshot", () => {
+    expect(z.looseObject({})).toMatchSnapshot();
+    expect(z.strictObject({})).toMatchSnapshot();
+  });
+
+  test("should z.promise() match snapshot", () => {
+    expect(z.promise(z.string())).toMatchSnapshot();
+    expect(zm.promise(zm.string())).toMatchSnapshot();
+  });
 });

package/src/zod4/__tests__/specific.test.ts

@@ -13,6 +13,13 @@ describe("zod4 specific test", () => {
     );
   });
 
+  // Zod4 deprecates strict and passthrough object types. Instead use the top-level z.strictObject() and z.looseObject() functions.
+  // https://zod.dev/v4/changelog?id=deprecates-strict-and-passthrough
+  test("zod4 can not distinguish between strictObject and looseObject types", () => {
+    expect(isSameType(z.strictObject({}), z.object({}))).toBe(true);
+    expect(isSameType(z.looseObject({}), z.strictObject({}))).toBe(true);
+  });
+
   // In Zod4, The result of z.function() is no longer a Zod schema.
   // Instead, it acts as a standalone "function factory" for defining Zod-validated functions.
   // See https://github.com/colinhacks/zod/issues/4143

package/src/zod4/__tests__/utils.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from "vitest";
+import { z } from "zod/v4";
+import { zodToString } from "../utils.ts";
+
+describe("zodToString", () => {
+  test("simple types", () => {
+    expect(zodToString(z.string())).toBe("z.string()");
+    expect(zodToString(z.number())).toBe("z.number()");
+    expect(zodToString(z.boolean())).toBe("z.boolean()");
+    expect(zodToString(z.null())).toBe("z.null()");
+    expect(zodToString(z.undefined())).toBe("z.undefined()");
+  });
+
+  test("object", () => {
+    const schema = z.object({
+      name: z.string(),
+      age: z.number(),
+    });
+    expect(zodToString(schema)).toBe(
+      "z.object({ name: z.string(), age: z.number() })",
+    );
+  });
+
+  test("nested object", () => {
+    const schema = z.object({
+      user: z.object({
+        id: z.number(),
+      }),
+    });
+    expect(zodToString(schema)).toBe(
+      "z.object({ user: z.object({ id: z.number() }) })",
+    );
+  });
+
+  test("array", () => {
+    expect(zodToString(z.array(z.string()))).toBe("z.array(z.string())");
+  });
+
+  test("optional", () => {
+    expect(zodToString(z.string().optional())).toBe("z.string().optional()");
+  });
+
+  test("formatted object", () => {
+    const schema = z.object({
+      user: z.object({
+        id: z.number(),
+      }),
+    });
+    const expected = `z.object({
+  user: z.object({
+    id: z.number()
+  })
+})`;
+    expect(zodToString(schema, { format: true })).toBe(expected);
+  });
+});

package/src/zod4/is-same-type.ts

@@ -75,7 +75,6 @@ export const isSameTypePresetRules = [
       const isZodTypesA = isZodTypes(a);
       const isZodTypesB = isZodTypes(b);
       if (!isZodTypesA || !isZodTypesB) {
-        // If neither are Zod types, we can compare them directly
         console.warn("Failed to compare type! " + a + " " + b);
         return false;
       }

package/src/zod4/utils.ts

@@ -132,73 +132,78 @@ export const flatUnwrapUnion = <
   }) as unknown as Options;
 };
 
-/**
- * @deprecated Not used
- */
-export const compareSchemas = (
-  a: $ZodTypes,
-  b: $ZodTypes,
-  compareZod: (a: $ZodTypes, b: $ZodTypes) => boolean,
-): boolean => {
-  const aDef = a._zod.def;
-  const bDef = b._zod.def;
-  for (const key in aDef) {
-    if (!(key in bDef)) return false;
-    const aValue = aDef[key as keyof typeof aDef];
-    const bValue = bDef[key as keyof typeof bDef];
+export const zodToString = (
+  schema: $ZodType,
+  options?: { format?: boolean },
+  indent = 0,
+): string => {
+  if (!isZodTypes(schema)) {
+    return "z.unknown()";
+  }
+  const def = schema._zod.def;
+  const type = def.type;
+  const format = options?.format ?? false;
+  const nextIndent = indent + 2;
+  const indentStr = format ? "\n" + " ".repeat(nextIndent) : "";
+  const endIndentStr = format ? "\n" + " ".repeat(indent) : "";
 
-    if (typeof aValue !== typeof bValue) return false;
-    if (aValue === null && bValue !== null) return false;
-    if (
-      typeof aValue === "string" ||
-      typeof aValue === "number" ||
-      typeof aValue === "boolean" ||
-      typeof aValue === "symbol" ||
-      typeof aValue === "bigint" ||
-      typeof aValue === "undefined"
-    ) {
-      if (aValue !== bValue) return false;
-      continue;
-    }
-    if (isZodType(aValue)) {
-      if (!isZodType(bValue)) return false;
-      const isEqual = compareZod(
-        aValue as unknown as $ZodTypes,
-        bValue as unknown as $ZodTypes,
+  switch (type) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "symbol":
+    case "undefined":
+    case "null":
+    case "any":
+    case "unknown":
+    case "never":
+    case "void":
+    case "date":
+    case "nan":
+      return `z.${type}()`;
+    case "literal":
+      const values = def.values as unknown[];
+      return `z.literal(${JSON.stringify(values[0])})`;
+    case "array":
+      return `z.array(${zodToString(def.element, options, indent)})`;
+    case "object":
+      const shape = def.shape;
+      const shapeStrs = Object.entries(shape).map(
+        ([k, v]) =>
+          `${indentStr}${k}: ${zodToString(v as $ZodType, options, nextIndent)}`,
       );
-      if (!isEqual) return false;
-      continue;
-    }
-    if (Array.isArray(aValue)) {
-      if (!Array.isArray(bValue)) return false;
-      if (aValue.length !== bValue.length) return false;
-      for (let i = 0; i < aValue.length; i++) {
-        const aItem = aValue[i];
-        const bItem = bValue[i];
-        if (isZodType(aItem)) {
-          if (!isZodType(bItem)) return false;
-          if (!compareZod(aItem as $ZodTypes, bItem as $ZodTypes)) return false;
-          continue;
-        }
-        if (aItem !== bItem) {
-          return false;
-        }
+      if (format) {
+        return `z.object({${shapeStrs.join(",")}${endIndentStr}})`;
       }
-      continue;
-    }
-    if (typeof aValue === "object") {
-      if (typeof bValue !== "object" || bValue === null) return false;
-      const bShape = bValue;
-      if (Object.keys(aValue).length !== Object.keys(bShape).length)
-        return false;
-      console.warn("Skipping object comparison", key, aValue, bValue);
-      continue;
-    }
-    if (typeof aValue === "function") {
-      // skip function comparison
-      console.warn("Skipping function comparison", key, aValue, bValue);
-      continue;
-    }
+      return `z.object({ ${shapeStrs.join(", ")} })`;
+    case "tuple":
+      const items = def.items as $ZodType[];
+      const itemStrs = items.map((i) => zodToString(i, options, nextIndent));
+      if (format && items.length > 0) {
+        return `z.tuple([${indentStr}${itemStrs.join("," + indentStr)}${endIndentStr}])`;
+      }
+      return `z.tuple([${itemStrs.join(", ")}])`;
+    case "union":
+      const optionsList = def.options as $ZodType[];
+      const optStrs = optionsList.map((o) =>
+        zodToString(o, options, nextIndent),
+      );
+      if (format && optionsList.length > 0) {
+        return `z.union([${indentStr}${optStrs.join("," + indentStr)}${endIndentStr}])`;
+      }
+      return `z.union([${optStrs.join(", ")}])`;
+    case "intersection":
+      return `z.intersection(${zodToString(def.left, options, indent)}, ${zodToString(
+        def.right,
+        options,
+        indent,
+      )})`;
+    case "optional":
+      return `${zodToString(def.innerType, options, indent)}.optional()`;
+    case "nullable":
+      return `${zodToString(def.innerType, options, indent)}.nullable()`;
+    default:
+      return `z.${type}(...)`;
   }
-  return true;
 };