@gabrielbryk/json-schema-to-zod 2.10.1 → 2.11.0

package/AGENTS.md

@@ -0,0 +1,44 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+- `src/`: TypeScript source; CLI entry in `src/cli.ts`, library entry in `src/index.ts`, conversion logic in `src/jsonSchemaToZod.ts`, parsers under `src/parsers/`, and helpers in `src/utils/`.
+- `test/`: TS test suite executed via `tsx`; fixtures live in `test/fixtures/`; snapshots in `test/generateSchemaBundle.snap.test.ts`.
+- `docs/`: Design proposals. Build outputs land in `dist/`; do not edit generated files.
+- `scripts/` and `createIndex.ts`: Codegen utilities used during builds.
+
+## Build, Test, and Development Commands
+- Install with `pnpm install` (pinned `pnpm@10.x`).
+- `pnpm gen`: Regenerate index exports.
+- `pnpm test`: Run the TSX-based test suite.
+- `pnpm lint`: Lint `src/` and `test/` with ESLint + @typescript-eslint.
+- `pnpm build`: Generate exports, run tests, clear `dist/`, and emit types + CJS/ESM bundles.
+- `pnpm dev`: Watch tests for rapid iteration.
+- `pnpm smoke:esm`: Quick check that the ESM bundle imports and runs.
+
+## Coding Style & Naming Conventions
+- Language: TypeScript with NodeNext/ESM; keep `.js` extensions on internal imports. Package ships ESM-only with flat `dist/`; avoid adding CJS outputs or require-based entrypoints. Build config lives in `tsconfig.build.json`.
+- Indentation: 2 spaces; include semicolons; prefer camelCase for functions/vars and PascalCase for types.
+- Avoid CommonJS `require`; ESLint forbids it. Keep functions small and pure.
+- Use existing utility patterns (e.g., `withMessage`, `buildRefRegistry`) before adding helpers.
+
+## Code Quality & Best Practices
+- Type safety first: prefer explicit generics and narrow types over `any`; keep option shapes well-typed and avoid implicit `unknown` casts.
+- Embrace SOLID: single-purpose parsers/utilities, extract shared helpers, and inject collaborators instead of hard-coding globals.
+- Validate boundary cases: cyclical refs, `$ref` resolution, discriminated unions, and recursion depth—add targeted tests when touching those paths.
+- Keep emitted code deterministic; avoid data-dependent randomness or network calls in conversion paths.
+
+## Testing Guidelines
+- Tests use a lightweight harness in `test/suite.ts`; add new suites under `test/` mirroring module paths.
+- Prefer fixtures in `test/fixtures/` for schema examples; extend snapshots only when behavior intentionally changes.
+- Cover new parsing paths; add regression cases for edge refs/recursion.
+- Run `pnpm test` (or `pnpm dev`) before opening a PR.
+
+## Commit & Pull Request Guidelines
+- Open an issue first; PRs without one are usually not considered (`CONTRIBUTING.md`).
+- Commit messages are short and imperative; gitmoji is welcome but optional. Keep related changes in separate commits.
+- PRs should describe the problem, approach, and risks; link the issue and note test coverage or added fixtures. Screenshots are unnecessary unless CLI UX changes.
+- Keep PR scope tight; avoid editing generated `dist/` files. Mention breaking changes explicitly.
+
+## Security & Configuration Tips
+- Avoid adding runtime dependencies that fetch remotely; conversions should stay deterministic and offline.
+- When touching CLI paths, ensure `--module`, `--type`, and `$ref` handling stay backward compatible; add tests for recursion and bundle ordering when modifying ref logic.

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @gabrielbryk/json-schema-to-zod
 
+## 2.11.0
+
+### Minor Changes
+
+- 2656c90: Fix Zod v4 type compatibility and improve discriminated union detection
+
+  ### Zod v4 Type Fixes
+
+  - Remove `ZodEffects` usage which doesn't exist in Zod v4
+  - `.superRefine()` and `.refine()` no longer change the schema type
+  - `.transform()` now correctly returns `ZodPipe` type instead of `ZodEffects`
+
+  ### Discriminated Union Detection Improvements
+
+  - Enhanced `findImplicitDiscriminator` to detect discriminators in `allOf` members
+  - Properly resolves `$ref` when checking for discriminator values
+  - Correctly collects `required` fields from both parent schema and `allOf` members
+
+  ### Cleaner Output Generation
+
+  - Simplified `parseAllOf` to avoid generating redundant `z.record().superRefine()` patterns
+  - Build proper object types with specific property annotations instead of generic `ZodObject<Record<string, ZodTypeAny>>`
+  - Intersection types are now properly tracked and reflected in type annotations
+
+### Patch Changes
+
+- 63c6a1c: Enable inline object lifting by default with improved naming and cycle guards
+
 ## 2.10.1
 
 ### Patch Changes

package/README.md

@@ -53,8 +53,7 @@ json-refs resolve mySchema.json | json-schema-to-zod | prettier --parser typescr
 | `--output`     | `-o`      | A file path to write to. If not supplied stdout will be used.                                  |
 | `--name`       | `-n`      | The name of the schema in the output                                                           |
 | `--depth`      | `-d`      | Maximum depth of recursion in schema before falling back to `z.any()`. Defaults to 0.          |
-| `--module`     | `-m`      | Module syntax; `esm`, `cjs` or none. Defaults to `esm` in the CLI and `none` programmaticly.   |
-| `--type`       | `-t`      | Export a named type along with the schema. Requires `name` to be set and `module` to be `esm`. |
+| `--type`       | `-t`      | Export a named type along with the schema. Requires `name` to be set. |
 | `--noImport`   | `-ni`     | Removes the `import { z } from 'zod';` or equivalent from the output.                          |
 | `--withJsdocs` | `-wj`     | Generate jsdocs off of the description property.                                               |
 
@@ -74,28 +73,16 @@ const myObject = {
   },
 };
 
-const module = jsonSchemaToZod(myObject, { module: "esm" });
+const schemaCode = jsonSchemaToZod(myObject);
 
 // `type` can be either a string or - outside of the CLI - a boolean. If its `true`, the name of the type will be the name of the schema with a capitalized first letter.
 const moduleWithType = jsonSchemaToZod(myObject, {
   name: "mySchema",
-  module: "esm",
   type: true,
 });
-
-const cjs = jsonSchemaToZod(myObject, { module: "cjs", name: "mySchema" });
-
 const justTheSchema = jsonSchemaToZod(myObject);
 ```
 
-##### `module`
-
-```typescript
-import { z } from "zod";
-
-export default z.object({ hello: z.string().optional() });
-```
-
 ##### `moduleWithType`
 
 ```typescript
@@ -105,20 +92,6 @@ export const mySchema = z.object({ hello: z.string().optional() });
 export type MySchema = z.infer<typeof mySchema>;
 ```
 
-##### `cjs`
-
-```typescript
-const { z } = require("zod");
-
-module.exports = { mySchema: z.object({ hello: z.string().optional() }) };
-```
-
-##### `justTheSchema`
-
-```typescript
-z.object({ hello: z.string().optional() });
-```
-
 #### Example with `$refs` resolved and output formatted
 
 ```typescript
@@ -148,10 +121,10 @@ Factored schemas (like object schemas with "oneOf" etc.) is only partially suppo
 
 The output of this package is not meant to be used at runtime. JSON Schema and Zod does not overlap 100% and the scope of the parsers are purposefully limited in order to help the author avoid a permanent state of chaotic insanity. As this may cause some details of the original schema to be lost in translation, it is instead recommended to use tools such as [Ajv](https://ajv.js.org/) to validate your runtime values directly against the original JSON Schema.
 
-That said, it's possible in most cases to use `eval`. Here's an example that you shouldn't use:
+That said, it's possible in most cases to load the generated ESM with a data URL. Here's an example that you still probably shouldn't use:
 
 ```typescript
-const zodSchema = eval(jsonSchemaToZod({ type: "string" }, { module: "cjs" }));
-
-zodSchema.safeParse("Please just use Ajv instead");
+const code = jsonSchemaToZod({ type: "string" }, { name: "mySchema" });
+const { mySchema } = await import(`data:text/javascript,${encodeURIComponent(code)}`);
+mySchema.safeParse("Please just use Ajv instead");
 ```

package/check-types-lift.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# Generate and typecheck workflow schema with inline object lifting enabled
+
+# Create a temporary ESM script
+cat > .tmp-wf-check-lift.ts << 'EOF'
+import yaml from 'js-yaml';
+import { readFileSync, writeFileSync } from 'fs';
+import { jsonSchemaToZod } from './src/jsonSchemaToZod.js';
+
+const schema = yaml.load(readFileSync('test/fixtures/workflow.yaml', 'utf8'));
+const output = jsonSchemaToZod(schema, {
+  name: 'workflowSchemaLifted',
+  liftInlineObjects: { enable: true },
+});
+writeFileSync('.tmp-workflow-schema-output-lift.ts', output);
+console.log('Generated .tmp-workflow-schema-output-lift.ts');
+EOF
+
+pnpm tsx .tmp-wf-check-lift.ts
+
+echo ""
+echo "Type-checking lifted..."
+pnpm tsc --noEmit --module NodeNext --moduleResolution nodenext --target ES2022 --strict --skipLibCheck .tmp-workflow-schema-output-lift.ts

package/check-types.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# Quick script to generate and typecheck workflow schema
+
+# Create a temporary ESM script
+cat > .tmp-wf-check.ts << 'EOF'
+import yaml from 'js-yaml';
+import { readFileSync, writeFileSync } from 'fs';
+import { jsonSchemaToZod } from './src/jsonSchemaToZod.js';
+
+const schema = yaml.load(readFileSync('test/fixtures/workflow.yaml', 'utf8'));
+const output = jsonSchemaToZod(schema, { name: 'workflowSchema' });
+writeFileSync('.tmp-workflow-schema-output.ts', output);
+console.log('Generated .tmp-workflow-schema-output.ts');
+EOF
+
+pnpm tsx .tmp-wf-check.ts
+
+echo ""
+echo "Type-checking..."
+pnpm tsc --noEmit --module NodeNext --moduleResolution nodenext --target ES2022 --strict --skipLibCheck .tmp-workflow-schema-output.ts

package/dist/{esm/cli.js → cli.js}

@@ -26,11 +26,6 @@ const params = {
         value: "number",
         description: "Maximum depth of recursion before falling back to z.any(). Defaults to 0.",
     },
-    module: {
-        shorthand: "m",
-        value: ["esm", "cjs", "none"],
-        description: "Module syntax; 'esm', 'cjs' or 'none'. Defaults to 'esm'.",
-    },
     type: {
         shorthand: "t",
         value: "string",
@@ -52,7 +47,6 @@ async function main() {
     const zodSchema = jsonSchemaToZod(jsonSchema, {
         name: args.name,
         depth: args.depth,
-        module: args.module || "esm",
         noImport: args.noImport,
         type: args.type,
         withJsdocs: args.withJsdocs,

package/dist/{esm/core → core}/analyzeSchema.js

@@ -2,14 +2,14 @@ import { parseSchema } from "../parsers/parseSchema.js";
 import { detectCycles, computeScc } from "../utils/cycles.js";
 import { buildRefRegistry } from "../utils/buildRefRegistry.js";
 export const analyzeSchema = (schema, options = {}) => {
-    const { module, name, type, ...rest } = options;
-    if (type && (!name || module !== "esm")) {
-        throw new Error("Option `type` requires `name` to be set and `module` to be `esm`");
+    const { name, type, ...rest } = options;
+    if (type && !name) {
+        throw new Error("Option `type` requires `name` to be set");
     }
     const normalized = {
-        module,
         name,
         type,
+        module: "esm",
         ...rest,
         exportRefs: rest.exportRefs ?? true,
         withMeta: rest.withMeta ?? true,
@@ -23,7 +23,6 @@ export const analyzeSchema = (schema, options = {}) => {
     const dependencies = new Map();
     const { registry: refRegistry, rootBaseUri } = buildRefRegistry(schema);
     const pass1 = {
-        module,
         name,
         path: [],
         seen: new Map(),

package/dist/core/emitZod.js

@@ -0,0 +1,263 @@
+import { parseSchema } from "../parsers/parseSchema.js";
+import { expandJsdocs } from "../utils/jsdocs.js";
+import { inferTypeFromExpression } from "../utils/schemaRepresentation.js";
+import { EsmEmitter } from "../utils/esmEmitter.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.
+ *
+ * Only splits if the TOP-LEVEL z.object() contains a getter (not nested ones in .and() etc.)
+ */
+const splitObjectMethodChain = (expr) => {
+    if (!expr.startsWith("z.object(")) {
+        return { base: expr, methodChain: null };
+    }
+    // Find the matching closing brace for z.object({
+    let depth = 1;
+    let i = 9; // length of "z.object("
+    // Find the opening { of the object literal
+    while (i < expr.length && expr[i] !== "{") {
+        i++;
+    }
+    if (i >= expr.length) {
+        return { base: expr, methodChain: null };
+    }
+    const objectLiteralStart = i;
+    i++; // move past the {
+    // Find the matching }
+    while (i < expr.length && depth > 0) {
+        const char = expr[i];
+        if (char === "{" || char === "(" || char === "[") {
+            depth++;
+        }
+        else if (char === "}" || char === ")" || char === "]") {
+            depth--;
+        }
+        i++;
+    }
+    const objectLiteralEnd = i - 1; // position of closing }
+    // Extract just the top-level object literal content
+    const objectLiteralContent = expr.substring(objectLiteralStart, objectLiteralEnd + 1);
+    // Check if the TOP-LEVEL object has a getter (not nested ones)
+    // A getter in the top-level object would appear as "get " at depth 1
+    if (!hasTopLevelGetter(objectLiteralContent)) {
+        return { base: expr, methodChain: null };
+    }
+    // Now find the closing ) for z.object(
+    while (i < expr.length && expr[i] !== ")") {
+        i++;
+    }
+    if (i >= expr.length) {
+        return { base: expr, methodChain: null };
+    }
+    i++; // move past the )
+    // Everything after is the method chain
+    const base = expr.substring(0, i);
+    const methodChain = expr.substring(i);
+    // Only return a method chain if there actually is one (like .strict() or .meta())
+    // Don't split if the method chain is .and() since that's adding more schema, not metadata
+    if (!methodChain || methodChain.length === 0 || methodChain.startsWith(".and(")) {
+        return { base: expr, methodChain: null };
+    }
+    return { base, methodChain };
+};
+/**
+ * Check if an object literal has a getter at its top level (not nested).
+ */
+const hasTopLevelGetter = (objectLiteral) => {
+    let depth = 0;
+    for (let i = 0; i < objectLiteral.length - 4; i++) {
+        const char = objectLiteral[i];
+        if (char === "{" || char === "(" || char === "[") {
+            depth++;
+        }
+        else if (char === "}" || char === ")" || char === "]") {
+            depth--;
+        }
+        else if (depth === 1 && objectLiteral.substring(i, i + 4) === "get ") {
+            // Found "get " at depth 1 (inside the top-level object, not nested)
+            return true;
+        }
+    }
+    return false;
+};
+const orderDeclarations = (entries, dependencies) => {
+    const repByName = new Map(entries);
+    const depGraph = new Map();
+    // Seed graph with empty deps for all nodes
+    for (const [name] of entries) {
+        depGraph.set(name, new Set());
+    }
+    // Add explicit dependencies (analyzeSchema) filtered to known names
+    for (const [from, set] of dependencies.entries()) {
+        const onlyKnown = new Set();
+        for (const dep of set) {
+            if (repByName.has(dep) && dep !== from) {
+                onlyKnown.add(dep);
+            }
+        }
+        const current = depGraph.get(from) ?? new Set();
+        onlyKnown.forEach((d) => current.add(d));
+        depGraph.set(from, current);
+    }
+    // Add regex-detected dependencies from expressions
+    const names = Array.from(repByName.keys());
+    for (const [name, rep] of entries) {
+        const deps = depGraph.get(name) ?? new Set();
+        for (const candidate of names) {
+            if (candidate === name)
+                continue;
+            const matcher = new RegExp(`\\b${candidate}\\b`);
+            if (matcher.test(rep.expression)) {
+                deps.add(candidate);
+            }
+        }
+        depGraph.set(name, deps);
+    }
+    // Kahn's algorithm with stable ordering
+    const indegree = new Map();
+    for (const name of names)
+        indegree.set(name, 0);
+    for (const [name, deps] of depGraph.entries()) {
+        const count = deps.size;
+        if (count > 0) {
+            indegree.set(name, (indegree.get(name) ?? 0) + count);
+        }
+    }
+    const queue = names.filter((n) => (indegree.get(n) ?? 0) === 0);
+    const ordered = [];
+    while (queue.length) {
+        const current = queue.shift();
+        ordered.push(current);
+        for (const dep of depGraph.get(current) ?? []) {
+            indegree.set(dep, (indegree.get(dep) ?? 1) - 1);
+            if ((indegree.get(dep) ?? 0) === 0) {
+                queue.push(dep);
+            }
+        }
+    }
+    // Fallback in case of cycles: append any remaining nodes
+    if (ordered.length < names.length) {
+        for (const name of names) {
+            if (!ordered.includes(name))
+                ordered.push(name);
+        }
+        // const remaining = names.filter((n) => !ordered.includes(n)).sort();
+        // ordered.push(...remaining);
+    }
+    return ordered.map((name) => [name, repByName.get(name)]);
+};
+export const emitZod = (analysis) => {
+    const { schema, options, refNameByPointer, cycleRefNames, cycleComponentByName, } = analysis;
+    const { name, type, noImport, exportRefs, withMeta, ...rest } = options;
+    const declarations = new Map();
+    const dependencies = new Map();
+    // Fresh name registry for the emission pass.
+    // Seed only with reserved ref names (from $ref resolution) and the root name to keep names stable
+    // without inheriting inline allocations from the first pass.
+    const emitUsedNames = new Set([...refNameByPointer.values()]);
+    if (name)
+        emitUsedNames.add(name);
+    const parsedSchema = parseSchema(schema, {
+        name,
+        path: [],
+        seen: new Map(),
+        declarations,
+        dependencies,
+        inProgress: new Set(),
+        refNameByPointer,
+        usedNames: emitUsedNames,
+        root: schema,
+        currentSchemaName: name,
+        cycleRefNames,
+        cycleComponentByName,
+        refRegistry: analysis.refRegistry,
+        rootBaseUri: analysis.rootBaseUri,
+        ...rest,
+        withMeta,
+    });
+    const jsdocs = rest.withJsdocs && typeof schema === "object" && schema !== null && "description" in schema
+        ? expandJsdocs(typeof schema.description === "string"
+            ? schema.description
+            : "")
+        : "";
+    const emitter = new EsmEmitter();
+    if (!noImport) {
+        emitter.addNamedImport("z", "zod");
+    }
+    if (declarations.size) {
+        for (const [refName, rep] of orderDeclarations(Array.from(declarations.entries()), dependencies)) {
+            const expression = typeof rep === "string" ? rep : rep.expression;
+            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"
+                ? rep.type
+                : undefined;
+            const hasLazy = expression.includes("z.lazy(");
+            const hasGetter = expression.includes("get ");
+            const isUnion = expression.startsWith("z.union(") || expression.startsWith("z.discriminatedUnion(");
+            // Check if this union references any cycle members (recursive schemas)
+            const referencesRecursiveSchema = isUnion && 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. Union types that reference recursive schemas (for proper type inference)
+            const needsTypeAnnotation = (hasLazy && !hasGetter) || referencesRecursiveSchema;
+            const storedType = needsTypeAnnotation ? (hintedType ?? 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
+            // 2. Emit decorated schema as RefName = _RefName.methods()
+            if (hasGetter && expression.startsWith("z.object(")) {
+                const { base, methodChain } = splitObjectMethodChain(expression);
+                if (methodChain) {
+                    // Emit base schema (internal, not exported)
+                    // No type annotation needed - type is on getters, TypeScript infers the rest
+                    const baseName = `_${refName}`;
+                    emitter.addConst({
+                        name: baseName,
+                        expression: base,
+                        exported: false,
+                    });
+                    // Emit decorated schema (exported)
+                    emitter.addConst({
+                        name: refName,
+                        expression: `${baseName}${methodChain}`,
+                        exported: exportRefs,
+                    });
+                    continue;
+                }
+            }
+            emitter.addConst({
+                name: refName,
+                expression,
+                exported: exportRefs,
+                typeAnnotation: storedType !== "z.ZodTypeAny" ? storedType : undefined,
+            });
+        }
+    }
+    if (name) {
+        emitter.addConst({
+            name,
+            expression: parsedSchema.expression,
+            exported: true,
+            jsdoc: jsdocs,
+        });
+    }
+    else {
+        emitter.addDefaultExport({
+            expression: parsedSchema.expression,
+            jsdoc: jsdocs,
+        });
+    }
+    if (type && name) {
+        const typeName = typeof type === "string" ? type : `${name[0].toUpperCase()}${name.substring(1)}`;
+        emitter.addTypeExport({
+            name: typeName,
+            type: `z.infer<typeof ${name}>`,
+        });
+    }
+    return emitter.render();
+};

package/dist/{esm/generators → generators}/generateBundle.js

@@ -1,23 +1,33 @@
 import { analyzeSchema } from "../core/analyzeSchema.js";
 import { emitZod } from "../core/emitZod.js";
+import { liftInlineObjects } from "../utils/liftInlineObjects.js";
 export const generateSchemaBundle = (schema, options = {}) => {
-    const module = options.module ?? "esm";
     if (!schema || typeof schema !== "object") {
         throw new Error("generateSchemaBundle requires an object schema");
     }
-    const defs = schema.$defs || {};
-    const definitions = schema.definitions || {};
+    const liftOpts = options.liftInlineObjects ?? {};
+    const useLift = liftOpts.enable !== false;
+    const liftedSchema = useLift
+        ? liftInlineObjects(schema, {
+            enable: true,
+            nameForPath: liftOpts.nameForPath,
+            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, groups } = buildBundleContext(defNames, defs, options);
+    const { rootName, rootTypeName, defInfoMap } = buildBundleContext(defNames, defs, options);
     const files = [];
-    const targets = planBundleTargets(schema, defs, definitions, defNames, options, rootName, defInfoMap, rootTypeName);
+    const targets = planBundleTargets(liftedSchema, defs, definitions, defNames, options, rootName, defInfoMap, rootTypeName);
     for (const target of targets) {
         const usedRefs = target.usedRefs;
         const zodParts = [];
         for (const member of target.members) {
             const analysis = analyzeSchema(member.schemaWithDefs, {
                 ...options,
-                module,
                 name: member.schemaName,
                 type: member.typeName,
                 parserOverride: createRefHandler(member.defName, defInfoMap, usedRefs, {
@@ -28,13 +38,13 @@ export const generateSchemaBundle = (schema, options = {}) => {
             const zodSchema = emitZod(analysis);
             zodParts.push(zodSchema);
         }
-        const finalSchema = buildSchemaFile(zodParts, usedRefs, defInfoMap, module, target);
+        const finalSchema = buildSchemaFile(zodParts, usedRefs, defInfoMap);
         files.push({ fileName: target.fileName, contents: finalSchema });
     }
     // Nested types extraction (optional)
     const nestedTypesEnabled = options.nestedTypes?.enable;
     if (nestedTypesEnabled) {
-        const nestedTypes = collectNestedTypes(schema, defs, defNames, rootTypeName ?? rootName);
+        const nestedTypes = collectNestedTypes(liftedSchema, defs, defNames, rootTypeName ?? rootName);
         if (nestedTypes.length > 0) {
             const nestedFileName = options.nestedTypes?.fileName ?? "nested-types.ts";
             const nestedContent = generateNestedTypesFile(nestedTypes);
@@ -129,7 +139,7 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
                             // Self-recursion inside object getters can safely reference the schema name
                             return refInfo.schemaName;
                         }
-                        return `z.lazy(() => ${refInfo.schemaName})`;
+                        return `z.lazy<typeof ${refInfo.schemaName}>(() => ${refInfo.schemaName})`;
                     }
                     return refInfo.schemaName;
                 }
@@ -147,9 +157,7 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
         return undefined;
     };
 };
-const buildSchemaFile = (zodCodeParts, usedRefs, defInfoMap, module, target) => {
-    if (module !== "esm")
-        return zodCodeParts.join("\n");
+const buildSchemaFile = (zodCodeParts, usedRefs, defInfoMap) => {
     const groupFileById = new Map();
     for (const info of defInfoMap.values()) {
         if (!groupFileById.has(info.groupId)) {
@@ -178,9 +186,10 @@ const buildSchemaFile = (zodCodeParts, usedRefs, defInfoMap, module, target) =>
         return code.replace(/^import \{ z \} from "zod"\n?/, "");
     })
         .join("\n");
-    return imports.length
+    const withImports = imports.length
         ? body.replace('import { z } from "zod"', `import { z } from "zod"\n${imports.join("\n")}`)
         : body;
+    return withImports;
 };
 const planBundleTargets = (rootSchema, defs, definitions, defNames, options, rootName, defInfoMap, rootTypeName) => {
     const targets = [];
@@ -245,9 +254,13 @@ const planBundleTargets = (rootSchema, defs, definitions, defNames, options, roo
 };
 const findRefDependencies = (schema, validDefNames) => {
     const deps = new Set();
+    const seen = new WeakSet();
     function traverse(obj) {
         if (obj === null || typeof obj !== "object")
             return;
+        if (seen.has(obj))
+            return;
+        seen.add(obj);
         if (Array.isArray(obj)) {
             obj.forEach(traverse);
             return;

package/dist/{esm/index.js → index.js}

@@ -24,10 +24,16 @@ export * from "./parsers/parseString.js";
 export * from "./utils/anyOrUnknown.js";
 export * from "./utils/buildRefRegistry.js";
 export * from "./utils/cycles.js";
+export * from "./utils/esmEmitter.js";
+export * from "./utils/extractInlineObject.js";
 export * from "./utils/half.js";
 export * from "./utils/jsdocs.js";
+export * from "./utils/liftInlineObjects.js";
+export * from "./utils/namingService.js";
 export * from "./utils/omit.js";
+export * from "./utils/resolveRef.js";
 export * from "./utils/resolveUri.js";
+export * from "./utils/schemaRepresentation.js";
 export * from "./utils/withMessage.js";
 export * from "./zodToJsonSchema.js";
 import { jsonSchemaToZod } from "./jsonSchemaToZod.js";

package/dist/jsonSchemaToZod.js

@@ -0,0 +1,17 @@
+import { analyzeSchema } from "./core/analyzeSchema.js";
+import { emitZod } from "./core/emitZod.js";
+import { liftInlineObjects } from "./utils/liftInlineObjects.js";
+export const jsonSchemaToZod = (schema, options = {}) => {
+    const liftOpts = options.liftInlineObjects ?? {};
+    const sourceSchema = liftOpts.enable !== false
+        ? liftInlineObjects(schema, {
+            enable: true,
+            nameForPath: liftOpts.nameForPath,
+            parentName: options.name,
+            dedup: liftOpts.dedup === true,
+            allowInDefs: liftOpts.allowInDefs,
+        }).schema
+        : schema;
+    const analysis = analyzeSchema(sourceSchema, options);
+    return emitZod(analysis);
+};