@gabrielbryk/json-schema-to-zod 2.12.1 → 2.14.0

package/dist/cli.js

@@ -7,8 +7,7 @@ const params = {
     input: {
         shorthand: "i",
         value: "string",
-        required: process.stdin.isTTY &&
-            "input is required when no JSON or file path is piped",
+        required: process.stdin.isTTY && "input is required when no JSON or file path is piped",
         description: "JSON or a source file path. Required if no data is piped.",
     },
     output: {
@@ -29,11 +28,11 @@ const params = {
     type: {
         shorthand: "t",
         value: "string",
-        description: "The name of the (optional) inferred type export."
+        description: "The name of the (optional) inferred type export.",
     },
     noImport: {
         shorthand: "ni",
-        description: "Removes the `import { z } from 'zod';` or equivalent from the output."
+        description: "Removes the `import { z } from 'zod';` or equivalent from the output.",
     },
     withJsdocs: {
         shorthand: "wj",

package/dist/core/analyzeSchema.js

@@ -1,27 +1,49 @@
 import { parseSchema } from "../parsers/parseSchema.js";
 import { detectCycles, computeScc } from "../utils/cycles.js";
 import { buildRefRegistry } from "../utils/buildRefRegistry.js";
+import { resolveSchemaName } from "../utils/schemaNaming.js";
 export const analyzeSchema = (schema, options = {}) => {
-    const { name, type, ...rest } = options;
+    const { name, type, naming, ...rest } = options;
     if (type && !name) {
         throw new Error("Option `type` requires `name` to be set");
     }
+    const nameContext = { isRoot: true, isLifted: false };
+    const rootBaseName = name;
+    let resolvedName = name;
+    const usedNames = new Set();
+    const usedBaseNames = new Set();
+    if (name && naming) {
+        resolvedName = resolveSchemaName(name, naming, nameContext, usedNames);
+        usedBaseNames.add(name);
+    }
+    if (resolvedName) {
+        usedNames.add(resolvedName);
+    }
     const normalized = {
-        name,
+        name: resolvedName,
         type,
+        naming,
         module: "esm",
         ...rest,
         exportRefs: rest.exportRefs ?? true,
         withMeta: rest.withMeta ?? true,
     };
     const refNameByPointer = new Map();
-    const usedNames = new Set();
-    if (name) {
-        usedNames.add(name);
+    const refBaseNameByPointer = new Map();
+    const baseNameBySchema = new Map();
+    if (naming && resolvedName && rootBaseName) {
+        baseNameBySchema.set(resolvedName, rootBaseName);
     }
     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: [],
@@ -30,28 +52,51 @@ export const analyzeSchema = (schema, options = {}) => {
         dependencies,
         inProgress: new Set(),
         refNameByPointer,
+        refBaseNameByPointer,
+        baseNameBySchema,
         usedNames,
+        usedBaseNames,
         root: schema,
-        currentSchemaName: name,
+        currentSchemaName: resolvedName,
         refRegistry,
         rootBaseUri,
         ...rest,
         withMeta: normalized.withMeta,
+        naming,
     };
     parseSchema(schema, pass1);
     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,
+        refBaseNameByPointer,
+        baseNameBySchema,
+        rootBaseName,
+        usedNames,
         cycleRefNames,
         cycleComponentByName: componentByName,
-        refRegistry,
-        rootBaseUri,
+        rootBaseUri: pass1.rootBaseUri,
+        refRegistry: pass1.refRegistry,
     };
 };

package/dist/core/emitZod.js

@@ -2,6 +2,7 @@ import { parseSchema } from "../parsers/parseSchema.js";
 import { expandJsdocs } from "../utils/jsdocs.js";
 import { inferTypeFromExpression } from "../utils/schemaRepresentation.js";
 import { EsmEmitter } from "../utils/esmEmitter.js";
+import { resolveTypeName } from "../utils/schemaNaming.js";
 /**
  * Split a z.object({...}).method1().method2() expression into base and method chain.
  * This is needed for Rule 2: Don't chain methods on recursive types.
@@ -148,8 +149,8 @@ const orderDeclarations = (entries, dependencies) => {
     return ordered.map((name) => [name, repByName.get(name)]);
 };
 export const emitZod = (analysis) => {
-    const { schema, options, refNameByPointer, cycleRefNames, cycleComponentByName, } = analysis;
-    const { name, type, noImport, exportRefs, typeExports, withMeta, ...rest } = options;
+    const { schema, options, refNameByPointer, cycleRefNames, cycleComponentByName, baseNameBySchema, rootBaseName, } = analysis;
+    const { name, type, naming, noImport, exportRefs, typeExports, withMeta, ...rest } = options;
     const declarations = new Map();
     const dependencies = new Map();
     // Fresh name registry for the emission pass.
@@ -175,6 +176,7 @@ export const emitZod = (analysis) => {
         rootBaseUri: analysis.rootBaseUri,
         ...rest,
         withMeta,
+        naming,
     });
     const jsdocs = rest.withJsdocs && typeof schema === "object" && schema !== null && "description" in schema
         ? expandJsdocs(typeof schema.description === "string"
@@ -182,6 +184,13 @@ export const emitZod = (analysis) => {
             : "")
         : "";
     const emitter = new EsmEmitter();
+    const usedTypeNames = new Set();
+    const resolveDeclarationTypeName = (schemaName) => {
+        if (!naming)
+            return schemaName;
+        const baseName = baseNameBySchema.get(schemaName) ?? schemaName;
+        return resolveTypeName(baseName, naming, { isRoot: false, isLifted: true }, usedTypeNames);
+    };
     if (!noImport) {
         emitter.addNamedImport("z", "zod");
     }
@@ -191,21 +200,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,13 +241,18 @@ 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) {
+                        const typeName = resolveDeclarationTypeName(refName);
                         emitter.addTypeExport({
-                            name: refName,
+                            name: typeName ?? refName,
                             type: `z.infer<typeof ${refName}>`,
                         });
+                        if (typeName) {
+                            usedTypeNames.add(typeName);
+                        }
                     }
                     continue;
                 }
@@ -245,10 +265,14 @@ export const emitZod = (analysis) => {
             });
             // Export type for this declaration if typeExports is enabled
             if (typeExports && exportRefs) {
+                const typeName = resolveDeclarationTypeName(refName);
                 emitter.addTypeExport({
-                    name: refName,
+                    name: typeName ?? refName,
                     type: `z.infer<typeof ${refName}>`,
                 });
+                if (typeName) {
+                    usedTypeNames.add(typeName);
+                }
             }
         }
     }
@@ -268,11 +292,18 @@ export const emitZod = (analysis) => {
     }
     // Export type for root schema if type option is set, or if typeExports is enabled
     if (name && (type || typeExports)) {
-        const typeName = typeof type === "string" ? type : `${name[0].toUpperCase()}${name.substring(1)}`;
-        emitter.addTypeExport({
-            name: typeName,
-            type: `z.infer<typeof ${name}>`,
-        });
+        const rootTypeName = typeof type === "string"
+            ? type
+            : naming && rootBaseName
+                ? resolveTypeName(rootBaseName, naming, { isRoot: true, isLifted: false }, usedTypeNames)
+                : `${name[0].toUpperCase()}${name.substring(1)}`;
+        if (rootTypeName) {
+            emitter.addTypeExport({
+                name: rootTypeName,
+                type: `z.infer<typeof ${name}>`,
+            });
+            usedTypeNames.add(rootTypeName);
+        }
     }
     return emitter.render();
 };

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/index.js

@@ -33,6 +33,7 @@ export * from "./utils/namingService.js";
 export * from "./utils/omit.js";
 export * from "./utils/resolveRef.js";
 export * from "./utils/resolveUri.js";
+export * from "./utils/schemaNaming.js";
 export * from "./utils/schemaRepresentation.js";
 export * from "./utils/withMessage.js";
 export * from "./zodToJsonSchema.js";

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}]>`;