@gabrielbryk/json-schema-to-zod 2.12.0 → 2.13.0

package/dist/core/analyzeSchema.js

@@ -21,7 +21,14 @@ export const analyzeSchema = (schema, options = {}) => {
     }
     const declarations = new Map();
     const dependencies = new Map();
-    const { registry: refRegistry, rootBaseUri } = buildRefRegistry(schema);
+    // Use provided registry or build a new one for this schema
+    let refRegistry = rest.refRegistry;
+    let rootBaseUri = rest.rootBaseUri ?? "root:///";
+    if (!refRegistry) {
+        const built = buildRefRegistry(schema, rootBaseUri);
+        refRegistry = built.registry;
+        rootBaseUri = built.rootBaseUri;
+    }
     const pass1 = {
         name,
         path: [],
@@ -42,16 +49,32 @@ export const analyzeSchema = (schema, options = {}) => {
     const names = Array.from(declarations.keys());
     const cycleRefNames = detectCycles(names, dependencies);
     const { componentByName } = computeScc(names, dependencies);
+    // Pass 2: Re-parse with cycle information if cycles were detected.
+    // This allows parseRef to correctly identify cyclic references and wrap them in z.lazy().
+    if (cycleRefNames.size > 0) {
+        declarations.clear();
+        pass1.seen.clear();
+        pass1.inProgress.clear();
+        // We reuse refNameByPointer to ensure stable naming across passes
+        const pass2 = {
+            ...pass1,
+            declarations,
+            cycleRefNames,
+            cycleComponentByName: componentByName,
+        };
+        parseSchema(schema, pass2);
+    }
     return {
         schema,
         options: normalized,
-        refNameByPointer,
-        usedNames,
         declarations,
+        definitions: {}, // Legacy support
         dependencies,
+        refNameByPointer,
+        usedNames,
         cycleRefNames,
         cycleComponentByName: componentByName,
-        refRegistry,
-        rootBaseUri,
+        rootBaseUri: pass1.rootBaseUri,
+        refRegistry: pass1.refRegistry,
     };
 };

package/dist/core/emitZod.js

@@ -148,7 +148,7 @@ const orderDeclarations = (entries, dependencies) => {
     return ordered.map((name) => [name, repByName.get(name)]);
 };
 export const emitZod = (analysis) => {
-    const { schema, options, refNameByPointer, cycleRefNames, cycleComponentByName, } = analysis;
+    const { schema, options, refNameByPointer, cycleRefNames, cycleComponentByName } = analysis;
     const { name, type, noImport, exportRefs, typeExports, withMeta, ...rest } = options;
     const declarations = new Map();
     const dependencies = new Map();
@@ -191,21 +191,27 @@ export const emitZod = (analysis) => {
             if (typeof expression !== "string") {
                 throw new Error(`Expected declaration expression for ${refName}`);
             }
-            const hintedType = typeof rep === "object" && rep && "type" in rep && typeof rep.type === "string"
+            const hintedType = typeof rep === "object" &&
+                rep &&
+                "type" in rep &&
+                typeof rep.type === "string"
                 ? rep.type
                 : undefined;
+            const effectiveHint = hintedType === "z.ZodTypeAny" ? undefined : hintedType;
             const hasLazy = expression.includes("z.lazy(");
             const hasGetter = expression.includes("get ");
             // Check if this schema references any cycle members (recursive schemas)
             // This can cause TS7056 when TypeScript tries to serialize the expanded type
-            const referencesRecursiveSchema = Array.from(cycleRefNames).some(cycleName => new RegExp(`\\b${cycleName}\\b`).test(expression));
+            const referencesRecursiveSchema = Array.from(cycleRefNames).some((cycleName) => new RegExp(`\\b${cycleName}\\b`).test(expression));
             // Per Zod v4 docs: type annotations should be on GETTERS for recursive types, not on const declarations.
             // TypeScript can infer the type of const declarations.
             // Exceptions that need explicit type annotation:
             // 1. z.lazy() without getters
             // 2. Any schema that references recursive schemas (to prevent TS7056)
             const needsTypeAnnotation = (hasLazy && !hasGetter) || referencesRecursiveSchema;
-            const storedType = needsTypeAnnotation ? (hintedType ?? inferTypeFromExpression(expression)) : undefined;
+            const storedType = needsTypeAnnotation
+                ? (effectiveHint ?? inferTypeFromExpression(expression))
+                : undefined;
             // Rule 2 from Zod v4: Don't chain methods on recursive types
             // If the schema has getters (recursive), we need to split it:
             // 1. Emit base schema as _RefName
@@ -226,6 +232,7 @@ export const emitZod = (analysis) => {
                         name: refName,
                         expression: `${baseName}${methodChain}`,
                         exported: exportRefs,
+                        typeAnnotation: storedType !== "z.ZodTypeAny" ? storedType : undefined,
                     });
                     // Export type for this declaration if typeExports is enabled
                     if (typeExports && exportRefs) {

package/dist/generators/generateBundle.js

@@ -11,29 +11,31 @@ export const generateSchemaBundle = (schema, options = {}) => {
         ? liftInlineObjects(schema, {
             enable: true,
             nameForPath: liftOpts.nameForPath,
-            parentName: options.splitDefs?.rootTypeName ?? options.splitDefs?.rootName ?? schema.title,
+            parentName: options.splitDefs?.rootTypeName ??
+                options.splitDefs?.rootName ??
+                schema.title,
             dedup: liftOpts.dedup === true,
             allowInDefs: liftOpts.allowInDefs,
         }).schema
         : schema;
-    const defs = liftedSchema.$defs || {};
-    const definitions = liftedSchema.definitions || {};
-    const defNames = Object.keys(defs);
-    const { rootName, rootTypeName, defInfoMap } = buildBundleContext(defNames, defs, options);
+    const allDefs = {
+        ...liftedSchema.definitions,
+        ...liftedSchema.$defs,
+    };
+    const defNames = Object.keys(allDefs);
+    const { rootName, rootTypeName, defInfoMap } = buildBundleContext(defNames, allDefs, options);
     const files = [];
-    const targets = planBundleTargets(liftedSchema, defs, definitions, defNames, options, rootName, defInfoMap, rootTypeName);
+    const targets = planBundleTargets(liftedSchema, allDefs, {}, defNames, options, rootName, defInfoMap, rootTypeName);
     for (const target of targets) {
-        const usedRefs = target.usedRefs;
+        const usedRefs = new Set();
         const zodParts = [];
         for (const member of target.members) {
             const analysis = analyzeSchema(member.schemaWithDefs, {
                 ...options,
                 name: member.schemaName,
                 type: member.typeName,
-                parserOverride: createRefHandler(member.defName, defInfoMap, usedRefs, {
-                    ...(member.schemaWithDefs.$defs || {}),
-                    ...(member.schemaWithDefs.definitions || {}),
-                }, options, target.groupId),
+                documentRoot: liftedSchema,
+                parserOverride: createRefHandler(member.defName, defInfoMap, usedRefs, allDefs, options, target.groupId),
             });
             const zodSchema = emitZod(analysis);
             zodParts.push(zodSchema);
@@ -44,7 +46,7 @@ export const generateSchemaBundle = (schema, options = {}) => {
     // Nested types extraction (optional)
     const nestedTypesEnabled = options.nestedTypes?.enable;
     if (nestedTypesEnabled) {
-        const nestedTypes = collectNestedTypes(liftedSchema, defs, defNames, rootTypeName ?? rootName);
+        const nestedTypes = collectNestedTypes(liftedSchema, allDefs, defNames, rootTypeName ?? rootName);
         if (nestedTypes.length > 0) {
             const nestedFileName = options.nestedTypes?.fileName ?? "nested-types.ts";
             const nestedContent = generateNestedTypesFile(nestedTypes);
@@ -89,19 +91,28 @@ const buildBundleContext = (defNames, defs, options) => {
         if (info)
             info.hasCycle = true;
     }
-    const groups = buildSccGroups(defInfoMap);
-    for (const [groupId, members] of groups) {
-        for (const defName of members) {
+    /*
+    const useLazyCrossRefs = options.refResolution?.lazyCrossRefs ?? true;
+    // NOTE: SCC grouping is currently disabled to ensure 1-to-1 mapping of $defs to files,
+    // which is expected by the test suite and preferred for clarity.
+    if (!useLazyCrossRefs) {
+      const groups = buildSccGroups(defInfoMap);
+      for (const [groupId, members] of groups) {
+        if (members.length > 1) {
+          for (const defName of members) {
             const info = defInfoMap.get(defName);
-            if (info)
-                info.groupId = groupId;
+            if (info) info.groupId = groupId;
+          }
         }
+      }
     }
+    */
     const rootName = options.splitDefs?.rootName ?? options.name ?? "RootSchema";
     const rootTypeName = typeof options.type === "string"
         ? options.type
-        : options.splitDefs?.rootTypeName ?? (typeof options.type === "boolean" && options.type ? rootName : undefined);
-    return { defInfoMap, rootName, rootTypeName, groups };
+        : (options.splitDefs?.rootTypeName ??
+            (typeof options.type === "boolean" && options.type ? rootName : undefined));
+    return { defInfoMap, rootName, rootTypeName };
 };
 const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options, currentGroupId) => {
     const useLazyCrossRefs = options.refResolution?.lazyCrossRefs ?? true;
@@ -111,10 +122,7 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
             const match = refPath.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
             if (match) {
                 const refName = match[1];
-                // Only intercept top-level def refs (no nested path like a/$defs/x)
-                if (refName.includes("/")) {
-                    return undefined;
-                }
+                // First check if it's exactly a top-level definition
                 const refInfo = defInfoMap.get(refName);
                 if (refInfo) {
                     // Track imports when referencing other defs
@@ -131,25 +139,26 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
                     });
                     if (resolved)
                         return resolved;
+                    // Self-recursion ALWAYS needs z.lazy if not using getters
+                    if (refName === currentDefName) {
+                        return `z.lazy(() => ${refInfo.schemaName})`;
+                    }
                     if (isCycle && useLazyCrossRefs) {
-                        const inObjectProperty = refs.path.includes("properties") ||
-                            refs.path.includes("patternProperties") ||
-                            refs.path.includes("additionalProperties");
-                        if (inObjectProperty && refName === currentDefName) {
-                            // Self-recursion inside object getters can safely reference the schema name
-                            return refInfo.schemaName;
-                        }
-                        return `z.lazy<typeof ${refInfo.schemaName}>(() => ${refInfo.schemaName})`;
+                        return `z.lazy(() => ${refInfo.schemaName})`;
                     }
                     return refInfo.schemaName;
                 }
-                // If the ref points to a local/inline $def (not part of top-level defs),
-                // let the default parser resolve it normally.
-                if (allDefs && Object.prototype.hasOwnProperty.call(allDefs, refName)) {
-                    return undefined;
-                }
+                // If it's NOT exactly a top-level definition, it could be:
+                // 1. A path into a top-level definition (e.g. #/$defs/alpha/properties/foo)
+                // 2. A local/inline definition NOT in allDefs
+                // 3. A reference to allDefs that we missed? (shouldn't happen)
+                // We return undefined to let the standard parser resolve it.
+                return undefined;
             }
-            const unknown = options.refResolution?.onUnknownRef?.({ ref: refPath, currentDef: currentDefName });
+            const unknown = options.refResolution?.onUnknownRef?.({
+                ref: refPath,
+                currentDef: currentDefName,
+            });
             if (unknown)
                 return unknown;
             return options.useUnknown ? "z.unknown()" : "z.any()";
@@ -160,7 +169,7 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
 const buildSchemaFile = (zodCodeParts, usedRefs, defInfoMap) => {
     const groupFileById = new Map();
     for (const info of defInfoMap.values()) {
-        if (!groupFileById.has(info.groupId)) {
+        if (info.groupId && !groupFileById.has(info.groupId)) {
             groupFileById.set(info.groupId, info.fileName.replace(/\.ts$/, ".js"));
         }
     }
@@ -168,7 +177,8 @@ const buildSchemaFile = (zodCodeParts, usedRefs, defInfoMap) => {
     for (const refName of [...usedRefs].sort()) {
         const refInfo = defInfoMap.get(refName);
         if (refInfo) {
-            const groupFile = groupFileById.get(refInfo.groupId) ?? refInfo.fileName.replace(/\.ts$/, ".js");
+            const groupFile = (refInfo.groupId ? groupFileById.get(refInfo.groupId) : null) ??
+                refInfo.fileName.replace(/\.ts$/, ".js");
             const path = `./${groupFile}`;
             const set = importsByFile.get(path) ?? new Set();
             set.add(refInfo.schemaName);
@@ -187,7 +197,7 @@ const buildSchemaFile = (zodCodeParts, usedRefs, defInfoMap) => {
     })
         .join("\n");
     const withImports = imports.length
-        ? body.replace('import { z } from "zod"', `import { z } from "zod"\n${imports.join("\n")}`)
+        ? body.replace(/import \{ z \} from "zod";?/, `import { z } from "zod";\n${imports.join("\n")}`)
         : body;
     return withImports;
 };
@@ -207,7 +217,10 @@ const planBundleTargets = (rootSchema, defs, definitions, defNames, options, roo
             const defSchema = defs[defName];
             const defSchemaWithDefs = {
                 ...defSchema,
-                $defs: { ...defs, ...defSchema?.$defs },
+                $defs: {
+                    ...defs,
+                    ...defSchema?.$defs,
+                },
                 definitions: {
                     ...defSchema.definitions,
                     ...definitions,
@@ -342,52 +355,6 @@ const detectCycles = (defInfoMap) => {
     }
     return cycleNodes;
 };
-const buildSccGroups = (defInfoMap) => {
-    const indexMap = new Map();
-    const lowLink = new Map();
-    const onStack = new Set();
-    const stack = [];
-    let index = 0;
-    const groups = new Map();
-    const strongConnect = (node) => {
-        indexMap.set(node, index);
-        lowLink.set(node, index);
-        index += 1;
-        stack.push(node);
-        onStack.add(node);
-        const info = defInfoMap.get(node);
-        if (info) {
-            for (const dep of info.dependencies) {
-                if (!indexMap.has(dep)) {
-                    strongConnect(dep);
-                    lowLink.set(node, Math.min(lowLink.get(node), lowLink.get(dep)));
-                }
-                else if (onStack.has(dep)) {
-                    lowLink.set(node, Math.min(lowLink.get(node), indexMap.get(dep)));
-                }
-            }
-        }
-        if (lowLink.get(node) === indexMap.get(node)) {
-            const members = [];
-            let w;
-            do {
-                w = stack.pop();
-                if (w) {
-                    onStack.delete(w);
-                    members.push(w);
-                }
-            } while (w && w !== node);
-            const groupId = members.sort().join("__");
-            groups.set(groupId, members);
-        }
-    };
-    for (const name of defInfoMap.keys()) {
-        if (!indexMap.has(name)) {
-            strongConnect(name);
-        }
-    }
-    return groups;
-};
 const collectNestedTypes = (rootSchema, defs, defNames, rootTypeName) => {
     const allNestedTypes = [];
     for (const defName of defNames) {
@@ -400,7 +367,10 @@ const collectNestedTypes = (rootSchema, defs, defNames, rootTypeName) => {
             allNestedTypes.push(nested);
         }
     }
-    const workflowNestedTypes = findNestedTypesInSchema({ properties: rootSchema.properties, required: rootSchema.required }, rootTypeName, defNames);
+    const workflowNestedTypes = findNestedTypesInSchema({
+        properties: rootSchema.properties,
+        required: rootSchema.required,
+    }, rootTypeName, defNames);
     for (const nested of workflowNestedTypes) {
         nested.file = "workflow";
         nested.parentType = rootTypeName;
@@ -450,7 +420,10 @@ const findNestedTypesInSchema = (schema, parentTypeName, defNames, currentPath =
         nestedTypes.push(...findNestedTypesInSchema(record.items, parentTypeName, defNames, [...currentPath, "items"]));
     }
     if (record.additionalProperties && typeof record.additionalProperties === "object") {
-        nestedTypes.push(...findNestedTypesInSchema(record.additionalProperties, parentTypeName, defNames, [...currentPath, "additionalProperties"]));
+        nestedTypes.push(...findNestedTypesInSchema(record.additionalProperties, parentTypeName, defNames, [
+            ...currentPath,
+            "additionalProperties",
+        ]));
     }
     return nestedTypes;
 };
@@ -467,9 +440,9 @@ const generateNestedTypesFile = (nestedTypes) => {
         "  P extends []",
         "    ? NonNullable<T>",
         "    : P extends readonly [infer H, ...infer R]",
-        "      ? H extends \"items\"",
+        '      ? H extends "items"',
         "        ? Access<NonNullable<T> extends Array<infer U> ? U : unknown, Extract<R, (string | number)[]>>",
-        "        : H extends \"additionalProperties\"",
+        '        : H extends "additionalProperties"',
         "          ? Access<NonNullable<T> extends Record<string, infer V> ? V : unknown, Extract<R, (string | number)[]>>",
         "          : H extends number",
         "            ? Access<NonNullable<T> extends Array<infer U> ? U : unknown, Extract<R, (string | number)[]>>",
@@ -502,7 +475,9 @@ const generateNestedTypesFile = (nestedTypes) => {
     }
     lines.push("");
     const buildAccessExpr = (parentType, propertyPath) => {
-        const path = propertyPath.map((prop) => (typeof prop === "number" ? prop : JSON.stringify(prop))).join(", ");
+        const path = propertyPath
+            .map((prop) => (typeof prop === "number" ? prop : JSON.stringify(prop)))
+            .join(", ");
         return `Access<${parentType}, [${path}]>`;
     };
     for (const [parentType, types] of [...byParent.entries()].sort()) {

package/dist/parsers/parseAllOf.js

@@ -34,12 +34,8 @@ const parseObjectShape = (schema, refs, pathPrefix) => {
             ? schema.required.includes(key)
             : typeof propSchema === "object" && propSchema.required === true;
         const optional = !hasDefault && !required;
-        const valueExpr = optional
-            ? `${parsedProp.expression}.optional()`
-            : parsedProp.expression;
-        const valueType = optional
-            ? `z.ZodOptional<${parsedProp.type}>`
-            : parsedProp.type;
+        const valueExpr = optional ? `${parsedProp.expression}.exactOptional()` : parsedProp.expression;
+        const valueType = optional ? `z.ZodExactOptional<${parsedProp.type}>` : parsedProp.type;
         shapeEntries.push(`${JSON.stringify(key)}: ${valueExpr}`);
         shapeTypes.push(`${JSON.stringify(key)}: ${valueType}`);
     }
@@ -61,14 +57,18 @@ const trySpreadPattern = (allOfMembers, refs) => {
             return undefined;
         }
         // Extract shape entries from inline object
-        const { shapeEntries: entries, shapeTypes: types } = parseObjectShape(member, refs, [...refs.path, "allOf", idx]);
+        const { shapeEntries: entries, shapeTypes: types } = parseObjectShape(member, refs, [
+            ...refs.path,
+            "allOf",
+            idx,
+        ]);
         shapeEntries.push(...entries);
         shapeTypes.push(...types);
     }
     if (shapeEntries.length === 0)
         return undefined;
     return {
-        expression: `z.object({ ${shapeEntries.join(", ")} })`,
+        expression: `z.looseObject({ ${shapeEntries.join(", ")} })`,
         type: `z.ZodObject<{ ${shapeTypes.join(", ")} }>`,
     };
 };
@@ -79,9 +79,7 @@ const ensureOriginalIndex = (arr) => {
         if (typeof item === "boolean") {
             newArr.push(item ? { [originalIndexKey]: i } : { [originalIndexKey]: i, not: {} });
         }
-        else if (typeof item === "object" &&
-            item !== null &&
-            originalIndexKey in item) {
+        else if (typeof item === "object" && item !== null && originalIndexKey in item) {
             return arr;
         }
         else {
@@ -96,7 +94,7 @@ export function parseAllOf(schema, refs) {
     }
     else if (schema.allOf.length === 1) {
         const item = schema.allOf[0];
-        return parseSchema(item, {
+        const parsed = parseSchema(item, {
             ...refs,
             path: [
                 ...refs.path,
@@ -104,6 +102,7 @@ export function parseAllOf(schema, refs) {
                 item[originalIndexKey] ?? 0,
             ],
         });
+        return parsed;
     }
     else {
         // Try spread pattern first (more efficient than intersection)

package/dist/parsers/parseAnyOf.js

@@ -19,8 +19,8 @@ export const parseAnyOf = (schema, refs) => {
         }
         return parseSchema(memberSchema, { ...refs, path: [...refs.path, "anyOf", i] });
     });
-    const expressions = members.map(m => m.expression).join(", ");
-    const types = members.map(m => m.type).join(", ");
+    const expressions = members.map((m) => m.expression).join(", ");
+    const types = members.map((m) => m.type).join(", ");
     const expression = `z.union([${expressions}])`;
     // Use readonly tuple for union type annotations (required for recursive type inference)
     const type = `z.ZodUnion<readonly [${types}]>`;

package/dist/parsers/parseArray.js

@@ -2,12 +2,39 @@ import { withMessage } from "../utils/withMessage.js";
 import { parseSchema } from "./parseSchema.js";
 import { anyOrUnknown } from "../utils/anyOrUnknown.js";
 export const parseArray = (schema, refs) => {
-    if (Array.isArray(schema.items)) {
+    // JSON Schema 2020-12 uses `prefixItems` for tuples.
+    // Older drafts used `items` as an array.
+    const prefixItems = schema.prefixItems || (Array.isArray(schema.items) ? schema.items : undefined);
+    if (prefixItems) {
         // Tuple case
-        const itemResults = schema.items.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "items", i] }));
-        let tuple = `z.tuple([${itemResults.map(r => r.expression).join(", ")}])`;
-        const tupleTypes = itemResults.map(r => r.type).join(", ");
-        let tupleType = `z.ZodTuple<[${tupleTypes}]>`;
+        const itemResults = prefixItems.map((v, i) => parseSchema(v, { ...refs, path: [...refs.path, "prefixItems", i] }));
+        let tuple = `z.tuple([${itemResults.map((r) => r.expression).join(", ")}])`;
+        // We construct the type manually for the tuple part
+        let tupleTypes = itemResults.map((r) => r.type).join(", ");
+        let tupleType = `z.ZodTuple<[${tupleTypes}], null>`; // Default null rest
+        // Handle "additionalItems" (older drafts) or "items" (2020-12 when prefixItems is used)
+        // If prefixItems is present, `items` acts as the schema for additional items.
+        // If prefixItems came from `items` (array form), then `additionalItems` controls the rest.
+        const additionalSchema = schema.prefixItems ? schema.items : schema.additionalItems;
+        if (additionalSchema === false) {
+            // Closed tuple
+        }
+        else if (additionalSchema) {
+            const restSchema = additionalSchema === true
+                ? anyOrUnknown(refs)
+                : parseSchema(additionalSchema, {
+                    ...refs,
+                    path: [...refs.path, "items"],
+                });
+            tuple += `.rest(${restSchema.expression})`;
+            tupleType = `z.ZodTuple<[${tupleTypes}], ${restSchema.type}>`;
+        }
+        else {
+            // Open by default
+            const anyRes = anyOrUnknown(refs);
+            tuple += `.rest(${anyRes.expression})`;
+            tupleType = `z.ZodTuple<[${tupleTypes}], ${anyRes.type}>`;
+        }
         if (schema.contains) {
             const containsResult = parseSchema(schema.contains, {
                 ...refs,
@@ -24,18 +51,18 @@ export const parseArray = (schema, refs) => {
     ctx.addIssue({ code: "custom", message: "Array contains too many matching items" });
   }
 })`;
-            // In Zod v4, .superRefine() doesn't change the type
         }
         return {
             expression: tuple,
             type: tupleType,
         };
     }
-    // Array case
+    // Regular Array case
+    const itemsSchema = schema.items;
     const anyOrUnknownResult = anyOrUnknown(refs);
-    const itemResult = !schema.items
+    const itemResult = !itemsSchema || itemsSchema === true
         ? anyOrUnknownResult
-        : parseSchema(schema.items, {
+        : parseSchema(itemsSchema, {
             ...refs,
             path: [...refs.path, "items"],
         });
@@ -44,13 +71,13 @@ export const parseArray = (schema, refs) => {
     r += withMessage(schema, "minItems", ({ json }) => ({
         opener: `.min(${json}`,
         closer: ")",
-        messagePrefix: ", { error: ",
+        messagePrefix: ", { message: ",
         messageCloser: " })",
     }));
     r += withMessage(schema, "maxItems", ({ json }) => ({
         opener: `.max(${json}`,
         closer: ")",
-        messagePrefix: ", { error: ",
+        messagePrefix: ", { message: ",
         messageCloser: " })",
     }));
     if (schema.uniqueItems === true) {
@@ -94,7 +121,6 @@ export const parseArray = (schema, refs) => {
   }
 })`;
     }
-    // In Zod v4, .superRefine() doesn't change the type, so no wrapping needed
     return {
         expression: r,
         type: arrayType,

package/dist/parsers/parseMultipleType.js

@@ -1,8 +1,8 @@
 import { parseSchema } from "./parseSchema.js";
 export const parseMultipleType = (schema, refs) => {
     const schemas = schema.type.map((type) => parseSchema({ ...schema, type }, { ...refs, withoutDefaults: true }));
-    const expressions = schemas.map(s => s.expression).join(", ");
-    const types = schemas.map(s => s.type).join(", ");
+    const expressions = schemas.map((s) => s.expression).join(", ");
+    const types = schemas.map((s) => s.type).join(", ");
     return {
         expression: `z.union([${expressions}])`,
         type: `z.ZodUnion<[${types}]>`,