zod-compare 2.0.0 → 3.0.0

package/README.md

@@ -5,7 +5,7 @@
 
 Compare two [Zod](https://zod.dev/) schemas recursively.
 
-`zod-compare` provides functions to compare Zod schemas, allowing you to determine whether two schemas are the same or compatible. Supports both Zod v3 and Zod v4.
+`zod-compare` provides functions to compare Zod schemas, allowing you to determine whether two schemas are the same or compatible. Supports Zod v4.
 
 ## Installation
 
@@ -46,21 +46,6 @@ Use the top-level helpers to compare schemas:
 - `isSameType(a, b)`: true only if the two schemas have the same shape and types (ignores refinements like min/max/length, transforms, etc.)
 - `isCompatibleType(higherType, lowerType)`: true if the looser schema (higherType) can be accepted wherever the stricter schema (lowerType) is expected
 
-### Versions and entry points
-
-The top-level APIs accept inputs from Zod v3 or v4 and automatically route to the right comparison engine when both inputs are from the same major. If inputs are mixed (v3 vs v4), both functions throw.
-
-If you’re on Zod v4, import from the v4 entry for the best types/inference:
-
-```ts
-import { isSameType } from "zod-compare/zod4";
-import { z } from "zod/v4";
-
-isSameType(z.string(), z.string()); // true
-```
-
-If you use Zod v3 exclusively, import from `zod-compare/zod3`.
-
 ## Advanced Usage
 
 ### Custom Rules
@@ -68,6 +53,7 @@ If you use Zod v3 exclusively, import from `zod-compare/zod3`.
 You can use `createCompareFn` to create a custom comparison function.
 
 ```ts
+import { z } from "zod";
 import {
   createCompareFn,
   isSameTypePresetRules,
@@ -77,8 +63,10 @@ import {
 const customRule = defineCompareRule(
   "compare description",
   (a, b, next, recheck, context) => {
-    // If the schemas are not having the same description, return false
-    if (a.description !== b.description) {
+    // In Zod 4, .describe() stores metadata via z.globalRegistry
+    const metaA = z.globalRegistry.get(a);
+    const metaB = z.globalRegistry.get(b);
+    if (metaA?.description !== metaB?.description) {
       return false;
     }
     return next();
@@ -136,11 +124,8 @@ import { createCompareFn, defineCompareRule } from "zod-compare";
 
 type defineCompareRule = (
   name: string,
-  rule: CompareFn,
-) => {
-  name: string;
-  rule: CompareFn;
-};
+  compare: CompareFn,
+) => CompareRule;
 
 type createCompareFn = (rules: CompareRule[]) => typeof isSameType;
 

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 y=e=>typeof e!="object"||e===null||"_zod"in e||!("def"in e)||typeof e.def!="object"||e.def===null||!("type"in e.def)||typeof e.def.type!="string"?!1:e.def.type==="function"&&"input"in e.def&&"output"in e.def,z=e=>{const t=(o,n,r={})=>{let s=-1;const d=a=>{if(a===e.length)return console.error("Failed to compare type! "+o+" "+n),!1;if(a===s)return console.error("next() called multiple times"),!1;s=a;const p=e[a],f=o,i=n,c=p.compare(f,i,()=>d(a+1),(m,j)=>t(m,j,r),r);return"stacks"in r&&Array.isArray(r.stacks)&&r.stacks.push({name:p.name,target:[f,i],result:c}),c};return d(0)};return t},u=e=>typeof e!="object"||e===null||!("~standard"in e)||typeof e["~standard"]!="object"?!1:e["~standard"].vendor==="zod",A=new Set(["string","number","boolean","bigint","symbol","null","undefined","void","never","any","unknown","date","object","record","file","array","tuple","union","intersection","map","set","enum","literal","nullable","optional","nonoptional","success","transform","default","prefault","catch","nan","pipe","readonly","template_literal","promise","lazy","custom","function"]),_=e=>{const t=e._zod.def.type;return A.has(t)},T=e=>{const t=e._zod.def.type;return t==="string"||t==="number"||t==="boolean"||t==="bigint"||t==="symbol"||t==="undefined"||t==="null"||t==="any"||t==="unknown"||t==="never"||t==="void"||t==="date"||t==="nan"||t==="file"},l=e=>e._zod.def.options.flatMap(t=>t._zod.def.type==="union"&&Array.isArray(t._zod.def.options)?l(t):t),b=[{name:"compare legacy ZodFunction",compare:(e,t,o,n)=>y(e)||y(t)?!y(e)||!y(t)?!1:n({...e,_zod:{def:e.def??e._def}},{...t,_zod:{def:t.def??t._def}}):o()},{name:"unstable warn",compare:(e,t,o)=>{const n=new Set(["transform","default","prefault","success","catch","pipe","lazy","custom"]);if(n.has(e._zod.def.type)||n.has(t._zod.def.type)){const r=e._zod.def.type,s=t._zod.def.type;console.warn(["[zod-compare] Unstable comparison detected.","This library is designed to compare TypeScript-level types (shape/compatibility).","The involved Zod kinds are not standardized/are unstable and results may be approximate:",`left.type="${r}" right.type="${s}".`,"Consider avoiding these kinds or validating with runtime tests if strict equality is required.","Alternatively, compose your own comparator by defining rules and using createCompareFn to override behavior for these kinds.",e,t].join(" "))}return o()}},{name:"strict ZodTypes check",compare:(e,t,o)=>{const n=_(e),r=_(t);return!n||!r?(console.warn("Failed to compare type! "+e+" "+t),!1):o()}},{name:"undefined check",compare:(e,t,o)=>e===void 0||t===void 0?(console.warn("Failed to compare type! "+e+" "+t),!1):o()},{name:"compare reference",compare:(e,t,o)=>e===t?!0:o()},{name:"compare type",compare:(e,t,o)=>{const n=e._zod.def.type,r=t._zod.def.type;return n!==r?!1:o()}},{name:"unwrap innerType",compare:(e,t,o,n)=>{const r=e._zod.def,s=t._zod.def;if("innerType"in r&&typeof r.innerType=="object"){if(!("innerType"in s&&typeof s.innerType=="object")||r.type!==s.type)return!1;const d=r.innerType,a=s.innerType;return!u(d)||!u(a)?(console.warn("Failed to compare inner types",d,a),!1):n(d,a)}return o()}},{name:"compare simple type",compare:(e,t,o)=>{if(T(e)||T(t)){const n=e._zod.def.type,r=t._zod.def.type;return n===r}return o()}},{name:"compare array",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;return r==="array"&&s==="array"?n(e._zod.def.element,t._zod.def.element):o()}},{name:"compare object",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;if(r==="object"&&s==="object"){const d=e._zod.def.shape,a=t._zod.def.shape;if(Object.keys(d).length!==Object.keys(a).length)return!1;for(const p in d)if(!(p in a)||!n(d[p],a[p]))return!1;return!0}return o()}},{name:"compare record",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;return r==="record"&&s==="record"?n(e._zod.def.keyType,t._zod.def.keyType)&&n(e._zod.def.valueType,t._zod.def.valueType):o()}},{name:"compare tuple",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;if(r==="tuple"&&s==="tuple"){const d=e._zod.def.items,a=t._zod.def.items;if(d.length!==a.length)return!1;for(let p=0;p<d.length;p++)if(!n(d[p],a[p]))return!1;return e._zod.def.rest||t._zod.def.rest?!e._zod.def.rest||!t._zod.def.rest?!1:n(e._zod.def.rest,t._zod.def.rest):!0}return o()}},{name:"compare map",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;return r==="map"&&s==="map"?n(e._zod.def.keyType,t._zod.def.keyType)&&n(e._zod.def.valueType,t._zod.def.valueType):o()}},{name:"compare set",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;return r==="set"&&s==="set"?n(e._zod.def.valueType,t._zod.def.valueType):o()}},{name:"compare enum",compare:(e,t,o)=>{const n=e._zod.def.type,r=t._zod.def.type;if(n==="enum"&&r==="enum"){const s=e._zod.def.entries,d=t._zod.def.entries,a=Object.keys(s),p=Object.keys(d);if(a.length!==p.length)return!1;for(const f of a)if(!(f in d)||s[f]!==d[f])return!1;return!0}return o()}},{name:"compare literal",compare:(e,t,o)=>{const n=e._zod.def.type,r=t._zod.def.type;if(n==="literal"&&r==="literal"){const s=e._zod.def.values,d=t._zod.def.values;if(s.length!==d.length)return!1;const a=new Set(d);for(const p of s)if(!a.has(p))return!1;return!0}return o()}},{name:"compare function",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;return r==="function"&&s==="function"?n(e._zod.def.input,t._zod.def.input)&&n(e._zod.def.output,t._zod.def.output):o()}},{name:"compare intersection",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;if(r==="intersection"&&s==="intersection"){const d=e._zod.def.left,a=e._zod.def.right,p=t._zod.def.left,f=t._zod.def.right;return n(d,p)&&n(a,f)?!0:n(d,f)&&n(a,p)}return o()}},{name:"compare union",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;if(r==="union"&&s==="union"){const d=l(e),a=l(t);return d.every(i=>a.some(c=>n(i,c)))?a.every(i=>d.some(c=>n(c,i))):!1}return o()}},{name:"compare template_literal",compare:(e,t,o,n)=>{const r=e._zod.def,s=t._zod.def;if(r.type==="template_literal"&&s.type==="template_literal"){const d=r.parts,a=s.parts;if(!Array.isArray(d)||!Array.isArray(a)||d.length!==a.length)return!1;for(let p=0;p<d.length;p++){const f=d[p],i=a[p],c=u(f),m=u(i);if(c||m){if(!(c&&m)||!n(f,i))return!1}else if(f!==i)return!1}return!0}return o()}},{name:"compare pipe",compare:(e,t,o,n)=>{const r=e._zod.def,s=t._zod.def;return r.type==="pipe"&&s.type==="pipe"?n(r.in,s.in)&&n(r.out,s.out):o()}},{name:"compare lazy",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;if(r==="lazy"&&s==="lazy"){const d=e._zod.def.getter,a=t._zod.def.getter;if(d===a)return!0;const p=d(),f=a();return!u(p)||!u(f)?!1:n(p,f)}return o()}},{name:"final fallback",compare:()=>!1}],g=z(b),v=[{name:"is same type",compare:(e,t,o)=>g(e,t)?!0:o()},{name:"check typeName",compare:(e,t,o)=>{if(!("_zod"in e)||!("def"in e._zod)||!("_zod"in t)||!("def"in t._zod))throw new Error("Failed to compare type! "+e+" "+t);return o()}},{name:"check optional/nullable on lower",compare:(e,t,o,n)=>{const r=t._zod.def;return(r.type==="optional"||r.type==="nullable")&&"innerType"in r&&typeof r.innerType=="object"&&u(r.innerType)?n(e,r.innerType):o()}},{name:"check union",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;if(r==="union"&&s==="union"){const d=l(e),a=l(t);return d.every(p=>a.some(f=>n(p,f)))}return r==="union"?l(e).every(a=>n(a,t)):s==="union"?l(t).some(a=>n(e,a)):o()}},{name:"compare type by kind",compare:(e,t,o)=>{const n=e._zod.def.type,r=t._zod.def.type;return n!==r?!1:o()}},{name:"check object (structural subset)",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;if(r==="object"&&s==="object"){const d=e._zod.def.shape,a=t._zod.def.shape;if(Object.keys(d).length<Object.keys(a).length)return!1;for(const p in a)if(!(p in d)||!n(d[p],a[p]))return!1;return!0}return o()}},{name:"check array",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;return r==="array"&&s==="array"?n(e._zod.def.element,t._zod.def.element):o()}},{name:"check tuple (length and rest)",compare:(e,t,o,n)=>{const r=e._zod.def.type,s=t._zod.def.type;if(r==="tuple"&&s==="tuple"){const d=e._zod.def.items,a=t._zod.def.items;if(d.length<a.length)return!1;for(let i=0;i<a.length;i++)if(!n(d[i],a[i]))return!1;const p=e._zod.def.rest,f=t._zod.def.rest;return f?p?n(p,f):!1:!0}return o()}}],k=z(v),O=(e,t)=>({name:e,compare:t});exports.createCompareFn=z;exports.defineCompareRule=O;exports.isCompatibleType=k;exports.isCompatibleTypePresetRules=v;exports.isLegacyZodFunction=y;exports.isSameType=g;exports.isSameTypePresetRules=b;
 //# 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/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","../src/zod4/rules.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  \"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            // Legacy ZodFunction compatibility - wrap def in _zod structure\n            // @ts-expect-error - LegacyZodFunction has .def, modern has ._def\n            _zod: { def: (a as any).def ?? a._def },\n          },\n          {\n            ...b,\n            _zod: { def: (b as any).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      if (aType === \"function\" && bType === \"function\") {\n        // In Zod4, function def has `input` (tuple-like) and `output` (ZodType)\n        return (\n          recheck(a._zod.def.input, b._zod.def.input) &&\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","import type { CompareFn, CompareRule } from \"./types.ts\";\n\nexport const defineCompareRule = (\n  name: string,\n  compare: CompareFn,\n): CompareRule => ({\n  name,\n  compare,\n});\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","defineCompareRule","name","compare"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,45 +1,6 @@
-import { haveSameZodMajor, isZod3Schema, isZod4Schema } from './utils.ts';
-import { LegacyZodFunction } from './zod4/compat.ts';
-import type * as z3 from "zod/v3";
-import type * as z4 from "zod/v4/core";
-export { haveSameZodMajor, isZod3Schema, isZod4Schema };
-/**
- * isSameType is a function that checks if two ZodTypes are the same.
- *
- * Caveats:
- * - The function does not validate specific criteria such as min or max values, length, email, etc.
- * - It excludes comparisons involving methods like .describe(), .catch(), .default(), .refine(), and .transform().
- *
- * @param a - The first ZodType to compare.
- * @param b - The second ZodType to compare.
- * @returns A boolean indicating whether the two types are the same.
- *
- * @throws Will throw an error if it encounters an unknown type.
- *
- * @example
- * ```ts
- * isSameType(z.string(), z.string()); // true
- * isSameType(z.string(), z.number()); // false
- * ```
- */
-export declare const isSameType: (a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction, b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction) => boolean;
-/**
- * Check if a the higherType matches the lowerType
- *
- * @deprecated This a unstable API and still in development
- *
- * @param higherType The looser type
- * @param lowerType The stricter type
- *
- * @example
- * ```ts
- * isCompatibleType(z.string(), z.string()); // true
- *
- * isCompatibleType(
- *   z.object({ name: z.string(), other: z.number() }),
- *   z.object({ name: z.string() })
- * );
- * // true
- * ```
- */
-export declare const isCompatibleType: (a: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction, b: z3.ZodTypeAny | z4.$ZodType | LegacyZodFunction) => boolean;
+export { isLegacyZodFunction } from './zod4/compat.ts';
+export { createCompareFn } from './zod4/create-compare-fn.ts';
+export { isCompatibleType, isCompatibleTypePresetRules, } from './zod4/is-compatible-type.ts';
+export { isSameType, isSameTypePresetRules } from './zod4/is-same-type.ts';
+export { defineCompareRule } from './zod4/rules.ts';
+export type * from './zod4/types.ts';