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

package/dist/utils/liftInlineObjects.js

@@ -122,7 +122,12 @@ const deepTransform = (obj, ctx, forceInDefs) => {
     if (clone.$defs && typeof clone.$defs === "object" && ctx.allowInDefs) {
         const defsObj = clone.$defs;
         for (const [key, value] of Object.entries(defsObj)) {
-            const visited = visit(value, { ...ctx, path: [...ctx.path, "$defs", key], inDefs: true, context: "root" });
+            const visited = visit(value, {
+                ...ctx,
+                path: [...ctx.path, "$defs", key],
+                inDefs: true,
+                context: "root",
+            });
             ctx.defs[key] = visited;
         }
         clone.$defs = ctx.defs;
@@ -131,7 +136,12 @@ const deepTransform = (obj, ctx, forceInDefs) => {
     if (clone.patternProperties && typeof clone.patternProperties === "object") {
         const newPatterns = {};
         for (const [key, value] of Object.entries(clone.patternProperties)) {
-            newPatterns[key] = visit(value, { ...ctx, path: [...ctx.path, key], inDefs: nextInDefs, context: "patternProperties" });
+            newPatterns[key] = visit(value, {
+                ...ctx,
+                path: [...ctx.path, key],
+                inDefs: nextInDefs,
+                context: "patternProperties",
+            });
         }
         clone.patternProperties = newPatterns;
     }
@@ -146,7 +156,12 @@ const deepTransform = (obj, ctx, forceInDefs) => {
     }
     // items / additionalItems
     if (clone.items) {
-        clone.items = visit(clone.items, { ...ctx, path: [...ctx.path, "items"], inDefs: nextInDefs, context: "items" });
+        clone.items = visit(clone.items, {
+            ...ctx,
+            path: [...ctx.path, "items"],
+            inDefs: nextInDefs,
+            context: "items",
+        });
     }
     if (clone.additionalItems) {
         clone.additionalItems = visit(clone.additionalItems, {
@@ -159,13 +174,30 @@ const deepTransform = (obj, ctx, forceInDefs) => {
     // compositions
     for (const keyword of ["allOf", "anyOf", "oneOf"]) {
         if (Array.isArray(clone[keyword])) {
-            clone[keyword] = clone[keyword].map((entry, index) => visit(entry, { ...ctx, path: [...ctx.path, keyword, index], inDefs: nextInDefs, context: keyword }));
+            clone[keyword] = clone[keyword].map((entry, index) => visit(entry, {
+                ...ctx,
+                path: [...ctx.path, keyword, index],
+                inDefs: nextInDefs,
+                context: keyword,
+            }));
         }
     }
     // conditionals
-    for (const keyword of ["if", "then", "else", "not", "contains", "unevaluatedProperties"]) {
+    for (const keyword of [
+        "if",
+        "then",
+        "else",
+        "not",
+        "contains",
+        "unevaluatedProperties",
+    ]) {
         if (clone[keyword]) {
-            clone[keyword] = visit(clone[keyword], { ...ctx, path: [...ctx.path, keyword], inDefs: nextInDefs, context: keyword });
+            clone[keyword] = visit(clone[keyword], {
+                ...ctx,
+                path: [...ctx.path, keyword],
+                inDefs: nextInDefs,
+                context: keyword,
+            });
         }
     }
     // dependentSchemas
@@ -184,7 +216,9 @@ const deepTransform = (obj, ctx, forceInDefs) => {
     return clone;
 };
 const getDefs = (schema) => {
-    if (typeof schema === "object" && schema !== null && typeof schema.$defs === "object") {
+    if (typeof schema === "object" &&
+        schema !== null &&
+        typeof schema.$defs === "object") {
         return { ...schema.$defs };
     }
     return {};
@@ -192,7 +226,11 @@ const getDefs = (schema) => {
 const isObjectSchema = (schema) => {
     if (schema.type === "object")
         return true;
-    return Boolean(schema.properties || schema.patternProperties || schema.additionalProperties || schema.required || schema.unevaluatedProperties);
+    return Boolean(schema.properties ||
+        schema.patternProperties ||
+        schema.additionalProperties ||
+        schema.required ||
+        schema.unevaluatedProperties);
 };
 const isMetaOnly = (schema) => {
     const keys = Object.keys(schema);
@@ -200,7 +238,11 @@ const isMetaOnly = (schema) => {
 };
 const isRecursiveRef = (schema, ctx) => {
     // Only guard when refs are present on the schema itself
-    const ref = typeof schema.$ref === "string" ? schema.$ref : typeof schema.$dynamicRef === "string" ? schema.$dynamicRef : null;
+    const ref = typeof schema.$ref === "string"
+        ? schema.$ref
+        : typeof schema.$dynamicRef === "string"
+            ? schema.$dynamicRef
+            : null;
     if (!ref)
         return false;
     const resolved = resolveRef(schema, ref, {
@@ -244,7 +286,9 @@ const extractCallConst = (ctx) => {
         return undefined;
     const parentPath = ctx.path.slice(0, -1);
     const parentNode = getAtPath(ctx.rootSchema, parentPath);
-    if (parentNode && typeof parentNode === "object" && parentNode.properties) {
+    if (parentNode &&
+        typeof parentNode === "object" &&
+        parentNode.properties) {
         const props = parentNode.properties;
         const callProp = props["call"];
         if (callProp && typeof callProp === "object" && callProp.const) {
@@ -301,7 +345,11 @@ const computeCyclicPaths = (schema, refRegistry, rootBaseUri) => {
         nodes.add(pathStr);
         nodes.add(ownerStr);
         const nextBase = typeof obj.$id === "string" ? resolveUri(baseUri, obj.$id) : baseUri;
-        const ref = typeof obj.$ref === "string" ? obj.$ref : typeof obj.$dynamicRef === "string" ? obj.$dynamicRef : obj.$recursiveRef;
+        const ref = typeof obj.$ref === "string"
+            ? obj.$ref
+            : typeof obj.$dynamicRef === "string"
+                ? obj.$dynamicRef
+                : obj.$recursiveRef;
         if (typeof ref === "string") {
             const resolved = resolveRef(obj, ref, {
                 path,
@@ -432,9 +480,18 @@ const subtreeHasCycle = (node, ctx, pathPrefix) => {
     // When a schema is reached through these keywords and participates in a cycle,
     // it will generate z.lazy() which causes type annotation issues when lifted
     const structuralKeywords = new Set([
-        "additionalProperties", "items", "additionalItems", "contains",
-        "unevaluatedProperties", "not", "if", "then", "else",
-        "allOf", "anyOf", "oneOf"
+        "additionalProperties",
+        "items",
+        "additionalItems",
+        "contains",
+        "unevaluatedProperties",
+        "not",
+        "if",
+        "then",
+        "else",
+        "allOf",
+        "anyOf",
+        "oneOf",
     ]);
     const rootPathStr = normalizePath(pathPrefix);
     const walk = (value, path, parentContext) => {
@@ -443,7 +500,11 @@ const subtreeHasCycle = (node, ctx, pathPrefix) => {
         const obj = value;
         // Check if this node has a $ref that points back to the root or an ancestor
         // This would create self-referential recursion which blocks lifting
-        const ref = typeof obj.$ref === "string" ? obj.$ref : typeof obj.$dynamicRef === "string" ? obj.$dynamicRef : null;
+        const ref = typeof obj.$ref === "string"
+            ? obj.$ref
+            : typeof obj.$dynamicRef === "string"
+                ? obj.$dynamicRef
+                : null;
         if (ref) {
             // Resolve the ref to see if it points to root or an ancestor
             if (ref.startsWith("#/")) {

package/dist/utils/resolveRef.js

@@ -22,7 +22,12 @@ export const resolveRef = (schemaNode, ref, refs) => {
                 const key = `${entry.uri}#${name}`;
                 const target = refs.refRegistry?.get(key);
                 if (target) {
-                    return { schema: target.schema, path: target.path, baseUri: target.baseUri, pointerKey: key };
+                    return {
+                        schema: target.schema,
+                        path: target.path,
+                        baseUri: target.baseUri,
+                        pointerKey: key,
+                    };
                 }
             }
         }
@@ -33,7 +38,12 @@ export const resolveRef = (schemaNode, ref, refs) => {
     const key = fragment ? `${uriBase}#${fragment}` : uriBase;
     let regEntry = refs.refRegistry?.get(key);
     if (regEntry) {
-        return { schema: regEntry.schema, path: regEntry.path, baseUri: regEntry.baseUri, pointerKey: key };
+        return {
+            schema: regEntry.schema,
+            path: regEntry.path,
+            baseUri: regEntry.baseUri,
+            pointerKey: key,
+        };
     }
     // Legacy recursive ref: treat as dynamic to __recursive__
     if (schemaNode.$recursiveRef) {
@@ -51,13 +61,12 @@ export const resolveRef = (schemaNode, ref, refs) => {
     // External resolver hook
     const extBase = uriBaseFromRef(resolvedUri);
     if (refs.resolveExternalRef && extBase && !isLocalBase(extBase, refs.rootBaseUri ?? "")) {
+        // console.log("ATTEMPTING EXTERNAL RESOLUTION FOR", ref, "AT BASE", extBase);
         const loaded = refs.resolveExternalRef(extBase);
         if (loaded) {
             // If async resolver is used synchronously here, it will be ignored; keep simple sync for now
             const maybePromise = loaded;
-            const schema = typeof maybePromise.then === "function"
-                ? undefined
-                : loaded;
+            const schema = typeof maybePromise.then === "function" ? undefined : loaded;
             if (schema) {
                 const { registry } = buildRefRegistry(schema, extBase);
                 registry.forEach((entry, k) => refs.refRegistry?.set(k, entry));
@@ -80,13 +89,29 @@ export const resolveRef = (schemaNode, ref, refs) => {
             .split("/")
             .filter((segment) => segment.length > 0)
             .map(decodePointerSegment);
-        let current = refs.root;
-        for (const segment of rawSegments) {
-            if (typeof current !== "object" || current === null)
+        const tryResolve = (rootNode) => {
+            if (!rootNode)
                 return undefined;
-            current = current[segment];
+            let current = rootNode;
+            for (const segment of rawSegments) {
+                const record = current;
+                if (!record || typeof record !== "object") {
+                    return undefined;
+                }
+                current = record[segment];
+                if (current === undefined)
+                    return undefined;
+            }
+            return current;
+        };
+        let resolved = tryResolve(refs.root);
+        if (resolved === undefined && refs.documentRoot && refs.documentRoot !== refs.root) {
+            resolved = tryResolve(refs.documentRoot);
+        }
+        if (resolved !== undefined) {
+            return { schema: resolved, path: rawSegments, baseUri: base, pointerKey: ref };
         }
-        return { schema: current, path: rawSegments, baseUri: base, pointerKey: ref };
+        return undefined;
     }
     return undefined;
 };

package/dist/utils/schemaRepresentation.js

@@ -182,7 +182,7 @@ export const zodObject = (shape) => {
 export const zodStrictObject = (shape) => {
     const base = zodObject(shape);
     return {
-        expression: `${base.expression}.strict()`,
+        expression: base.expression.replace(/^z\.object\(/, "z.strictObject("),
         type: base.type, // strict() doesn't change the type signature
     };
 };
@@ -245,31 +245,31 @@ export const fromExpression = (expression) => ({
  * This is used for backward compatibility during migration.
  */
 export const inferTypeFromExpression = (expr) => {
-    // Handle z.lazy with explicit type (possibly with method chains like .optional())
-    const lazyTypedMatch = expr.match(/^z\.lazy<([^>]+)>\(\s*\(\)\s*=>\s*([A-Za-z0-9_.$]+)\s*\)(\.[a-z]+\(\))*$/);
-    if (lazyTypedMatch) {
-        let type = `z.ZodLazy<${lazyTypedMatch[1]}>`;
-        const methods = lazyTypedMatch[3] || "";
-        if (methods.includes(".optional()")) {
+    const applyOptionality = (type, methods) => {
+        if (methods.includes(".exactOptional()")) {
+            type = `z.ZodExactOptional<${type}>`;
+        }
+        else if (methods.includes(".optional()")) {
             type = `z.ZodOptional<${type}>`;
         }
         if (methods.includes(".nullable()")) {
             type = `z.ZodNullable<${type}>`;
         }
         return type;
+    };
+    // Handle z.lazy with explicit type (possibly with method chains like .optional())
+    const lazyTypedMatch = expr.match(/^z\.lazy<([^>]+)>\(\s*\(\)\s*=>\s*([A-Za-z0-9_.$]+)\s*\)(\.[a-z]+\(\))*$/);
+    if (lazyTypedMatch) {
+        let type = `z.ZodLazy<${lazyTypedMatch[1]}>`;
+        const methods = lazyTypedMatch[3] || "";
+        return applyOptionality(type, methods);
     }
     // Handle z.lazy without explicit type (possibly with method chains like .optional())
     const lazyMatch = expr.match(/^z\.lazy\(\s*\(\)\s*=>\s*([A-Za-z0-9_.$]+)\s*\)(\.[a-z]+\(\))*$/);
     if (lazyMatch) {
         let type = `z.ZodLazy<typeof ${lazyMatch[1]}>`;
         const methods = lazyMatch[2] || "";
-        if (methods.includes(".optional()")) {
-            type = `z.ZodOptional<${type}>`;
-        }
-        if (methods.includes(".nullable()")) {
-            type = `z.ZodNullable<${type}>`;
-        }
-        return type;
+        return applyOptionality(type, methods);
     }
     // Handle .and() method chains - this creates an intersection type
     // Need to find the .and( that's not inside nested parentheses
@@ -286,13 +286,7 @@ export const inferTypeFromExpression = (expr) => {
             const andType = inferTypeFromExpression(andArg);
             let type = `z.ZodIntersection<${baseType}, ${andType}>`;
             // Handle trailing methods
-            if (remainder.includes(".optional()")) {
-                type = `z.ZodOptional<${type}>`;
-            }
-            if (remainder.includes(".nullable()")) {
-                type = `z.ZodNullable<${type}>`;
-            }
-            return type;
+            return applyOptionality(type, remainder);
         }
     }
     // Handle z.intersection(X, Y)
@@ -312,26 +306,19 @@ export const inferTypeFromExpression = (expr) => {
             }
         }
     }
-    // Handle z.object({...}) - for objects with getters or complex shapes
-    if (expr.startsWith("z.object(")) {
+    // Handle z.object({...})/z.strictObject({...})/z.looseObject({...})
+    const objectPrefixes = ["z.object(", "z.strictObject(", "z.looseObject("];
+    const objectPrefix = objectPrefixes.find((prefix) => expr.startsWith(prefix));
+    if (objectPrefix) {
         // Find the end of z.object({...})
-        const argsStart = 9; // length of "z.object("
+        const argsStart = objectPrefix.length; // length of prefix
         const argsEnd = findMatchingParen(expr, argsStart - 1);
         if (argsEnd !== -1) {
             const remainder = expr.substring(argsEnd + 1);
             // Base type for any z.object
             let type = "z.ZodObject<Record<string, z.ZodTypeAny>>";
             // Handle method chains after z.object({...})
-            if (remainder.includes(".strict()")) {
-                // .strict() doesn't change the type
-            }
-            if (remainder.includes(".optional()")) {
-                type = `z.ZodOptional<${type}>`;
-            }
-            if (remainder.includes(".nullable()")) {
-                type = `z.ZodNullable<${type}>`;
-            }
-            return type;
+            return applyOptionality(type, remainder);
         }
     }
     // Handle z.record(K, V)
@@ -377,13 +364,7 @@ export const inferTypeFromExpression = (expr) => {
         const baseName = refMatch[1];
         const methods = refMatch[2] || "";
         let type = `typeof ${baseName}`;
-        if (methods.includes(".optional()")) {
-            type = `z.ZodOptional<${type}>`;
-        }
-        if (methods.includes(".nullable()")) {
-            type = `z.ZodNullable<${type}>`;
-        }
-        return type;
+        return applyOptionality(type, methods);
     }
     // Handle z.array(X)
     const arrayMatch = expr.match(/^z\.array\((.+)\)(\.[a-z]+\(\))*$/);
@@ -391,13 +372,7 @@ export const inferTypeFromExpression = (expr) => {
         const innerType = inferTypeFromExpression(arrayMatch[1]);
         let type = `z.ZodArray<${innerType}>`;
         const methods = arrayMatch[2] || "";
-        if (methods.includes(".optional()")) {
-            type = `z.ZodOptional<${type}>`;
-        }
-        if (methods.includes(".nullable()")) {
-            type = `z.ZodNullable<${type}>`;
-        }
-        return type;
+        return applyOptionality(type, methods);
     }
     // Handle z.nullable(X)
     const nullableMatch = expr.match(/^z\.nullable\((.+)\)$/);
@@ -413,16 +388,10 @@ export const inferTypeFromExpression = (expr) => {
         if (bracketEnd !== -1) {
             const arrayContent = expr.substring(bracketStart + 1, bracketEnd); // inside the []
             const memberTypes = parseTopLevelArrayElements(arrayContent);
-            const types = memberTypes.map(m => inferTypeFromExpression(m.trim()));
+            const types = memberTypes.map((m) => inferTypeFromExpression(m.trim()));
             let baseType = `z.ZodUnion<readonly [${types.join(", ")}]>`;
             const remainder = expr.substring(bracketEnd + 2); // skip ] and )
-            if (remainder.includes(".optional()")) {
-                baseType = `z.ZodOptional<${baseType}>`;
-            }
-            if (remainder.includes(".nullable()")) {
-                baseType = `z.ZodNullable<${baseType}>`;
-            }
-            return baseType;
+            return applyOptionality(baseType, remainder);
         }
     }
     // Handle z.discriminatedUnion(...) - Zod v4 uses readonly arrays
@@ -445,10 +414,10 @@ export const inferTypeFromExpression = (expr) => {
 const findTopLevelMethod = (expr, method) => {
     let depth = 0;
     for (let i = 0; i < expr.length - method.length; i++) {
-        if (expr[i] === '(' || expr[i] === '[' || expr[i] === '{') {
+        if (expr[i] === "(" || expr[i] === "[" || expr[i] === "{") {
             depth++;
         }
-        else if (expr[i] === ')' || expr[i] === ']' || expr[i] === '}') {
+        else if (expr[i] === ")" || expr[i] === "]" || expr[i] === "}") {
             depth--;
         }
         else if (depth === 0 && expr.substring(i, i + method.length) === method) {
@@ -463,10 +432,10 @@ const findTopLevelMethod = (expr, method) => {
 const findMatchingParen = (expr, openIndex) => {
     let depth = 0;
     for (let i = openIndex; i < expr.length; i++) {
-        if (expr[i] === '(' || expr[i] === '[' || expr[i] === '{') {
+        if (expr[i] === "(" || expr[i] === "[" || expr[i] === "{") {
             depth++;
         }
-        else if (expr[i] === ')' || expr[i] === ']' || expr[i] === '}') {
+        else if (expr[i] === ")" || expr[i] === "]" || expr[i] === "}") {
             depth--;
             if (depth === 0) {
                 return i;
@@ -481,13 +450,13 @@ const findMatchingParen = (expr, openIndex) => {
 const findTopLevelComma = (expr) => {
     let depth = 0;
     for (let i = 0; i < expr.length; i++) {
-        if (expr[i] === '(' || expr[i] === '[' || expr[i] === '{') {
+        if (expr[i] === "(" || expr[i] === "[" || expr[i] === "{") {
             depth++;
         }
-        else if (expr[i] === ')' || expr[i] === ']' || expr[i] === '}') {
+        else if (expr[i] === ")" || expr[i] === "]" || expr[i] === "}") {
             depth--;
         }
-        else if (depth === 0 && expr[i] === ',') {
+        else if (depth === 0 && expr[i] === ",") {
             return i;
         }
     }
@@ -502,15 +471,15 @@ const parseTopLevelArrayElements = (content) => {
     let current = "";
     for (let i = 0; i < content.length; i++) {
         const char = content[i];
-        if (char === '(' || char === '[' || char === '{') {
+        if (char === "(" || char === "[" || char === "{") {
             depth++;
             current += char;
         }
-        else if (char === ')' || char === ']' || char === '}') {
+        else if (char === ")" || char === "]" || char === "}") {
             depth--;
             current += char;
         }
-        else if (char === ',' && depth === 0) {
+        else if (char === "," && depth === 0) {
             if (current.trim()) {
                 elements.push(current.trim());
             }

package/dist/zodToJsonSchema.js

@@ -39,8 +39,7 @@ export function reconstructJsonSchema(schema) {
             secondElement.__jsonSchema.conditional) {
             // Extract the main schema and conditional
             const mainSchema = reconstructJsonSchema(result.allOf[0]);
-            const conditionalMeta = secondElement.__jsonSchema
-                .conditional;
+            const conditionalMeta = secondElement.__jsonSchema.conditional;
             // Merge: main schema + if/then/else at top level
             const merged = {
                 ...mainSchema,

package/docs/IMPROVEMENT-PLAN.md

@@ -9,17 +9,20 @@ Based on analysis of our generated output and Zod v4 limitations research.
 ### Problem 1: `z.record()` with recursive values lacks `z.lazy()`
 
 **Current output:**
+
 ```typescript
 export const TaskList: z.ZodArray<z.ZodRecord<typeof z, typeof Task>> =
   z.array(z.record(z.string(), Task).meta({...}))
 ```
 
 **Issues:**
+
 1. `Task` referenced directly in `z.record()` - Colin confirmed in #4881 this REQUIRES `z.lazy()`
 2. Type annotation is completely wrong - `typeof z` as key type is nonsense
 3. This will cause runtime TDZ errors if Task isn't declared yet
 
 **Should be:**
+
 ```typescript
 export const TaskList = z.array(
   z.record(z.string(), z.lazy(() => Task)).meta({...})
@@ -31,16 +34,19 @@ export const TaskList = z.array(
 ### Problem 2: Union type annotations use `z.ZodTypeAny`
 
 **Current output:**
+
 ```typescript
 export const CallTask: z.ZodUnion<readonly z.ZodTypeAny[]> = z.union([...])
 ```
 
 **Issues:**
+
 1. `z.ZodTypeAny[]` defeats the entire purpose of type safety
 2. Loses all type information about what's actually in the union
 
 **Should be:**
 Either remove the type annotation entirely:
+
 ```typescript
 export const CallTask = z.union([...])
 ```
@@ -52,6 +58,7 @@ Or if we must have one (for circular reference reasons), at least don't use `Zod
 ### Problem 3: Object type annotations use `Record<string, z.ZodTypeAny>`
 
 **Current output:**
+
 ```typescript
 export const DoTask: z.ZodIntersection<
   z.ZodObject<Record<string, z.ZodTypeAny>>,
@@ -60,11 +67,13 @@ export const DoTask: z.ZodIntersection<
 ```
 
 **Issues:**
+
 1. `Record<string, z.ZodTypeAny>` loses all property type information
 2. The intersection type is overly complex and still loses info
 
 **Should be:**
 Remove the type annotation and let TypeScript infer:
+
 ```typescript
 export const DoTask = z.object({}).and(z.intersection(TaskBase, z.object({...})))
 ```
@@ -74,6 +83,7 @@ export const DoTask = z.object({}).and(z.intersection(TaskBase, z.object({...}))
 ### Problem 4: Getters ARE being used correctly ✅
 
 **Current output (GOOD):**
+
 ```typescript
 get "do"(): z.ZodOptional<typeof TaskList>{ return TaskList.optional() }
 ```
@@ -85,6 +95,7 @@ This follows the Zod v4 pattern correctly! The getter with explicit return type
 ### Problem 5: Empty object base with `.and()` is wasteful
 
 **Current output:**
+
 ```typescript
 z.object({}).and(z.intersection(TaskBase, z.object({...})))
 ```
@@ -93,6 +104,7 @@ z.object({}).and(z.intersection(TaskBase, z.object({...})))
 Starting with `z.object({})` then using `.and()` is unnecessary when there are no direct properties.
 
 **Should be:**
+
 ```typescript
 z.intersection(TaskBase, z.object({...}))
 // OR
@@ -111,9 +123,8 @@ When reference is inside a `z.record()` context AND the target is recursive, use
 
 ```typescript
 // Check if we're inside a record value context
-const inRecordValue = refs.path.some((p, i) =>
-  p === "additionalProperties" ||
-  (refs.path[i-1] === "record" && p === "1") // second arg to z.record
+const inRecordValue = refs.path.some(
+  (p, i) => p === "additionalProperties" || (refs.path[i - 1] === "record" && p === "1") // second arg to z.record
 );
 
 if (inRecordValue && (isSameCycle || isForwardRef)) {
@@ -128,6 +139,7 @@ if (inRecordValue && (isSameCycle || isForwardRef)) {
 **File:** `src/core/emitZod.ts`
 
 Current logic adds type annotations when there's a cycle/lazy/getter. Change to:
+
 1. Only add type annotation if we can infer a GOOD type
 2. Never use `z.ZodTypeAny` - either infer correctly or don't annotate
 
@@ -135,9 +147,11 @@ Current logic adds type annotations when there's a cycle/lazy/getter. Change to:
 if (isCycle || hasLazy || hasGetter) {
   const inferredType = inferTypeFromExpression(value);
   // Skip annotation if it's useless or wrong
-  if (inferredType !== "z.ZodTypeAny" &&
-      !inferredType.includes("Record<string, z.ZodTypeAny>") &&
-      !inferredType.includes("typeof z,")) {
+  if (
+    inferredType !== "z.ZodTypeAny" &&
+    !inferredType.includes("Record<string, z.ZodTypeAny>") &&
+    !inferredType.includes("typeof z,")
+  ) {
     return `${shouldExport ? "export " : ""}const ${refName}: ${inferredType} = ${value}`;
   }
 }
@@ -196,6 +210,7 @@ When there are no direct properties but there IS composition (allOf), don't crea
 ```
 
 Then when building output with `.and()`:
+
 ```typescript
 if (output === null && its.an.allOf(objectSchema)) {
   // No base object, just use the composition directly
@@ -209,18 +224,19 @@ if (output === null && its.an.allOf(objectSchema)) {
 
 ## Summary of Changes
 
-| File | Change | Priority |
-|------|--------|----------|
-| `parseSchema.ts` | Add `z.lazy()` for refs inside `z.record()` | HIGH |
-| `emitZod.ts` | Don't add `z.ZodTypeAny` annotations | HIGH |
-| `schemaRepresentation.ts` | Fix `z.record()` type inference | HIGH |
-| `parseObject.ts` | Remove unnecessary `z.object({}).and()` | MEDIUM |
+| File                      | Change                                      | Priority |
+| ------------------------- | ------------------------------------------- | -------- |
+| `parseSchema.ts`          | Add `z.lazy()` for refs inside `z.record()` | HIGH     |
+| `emitZod.ts`              | Don't add `z.ZodTypeAny` annotations        | HIGH     |
+| `schemaRepresentation.ts` | Fix `z.record()` type inference             | HIGH     |
+| `parseObject.ts`          | Remove unnecessary `z.object({}).and()`     | MEDIUM   |
 
 ---
 
 ## Expected Outcome
 
 **Before:**
+
 ```typescript
 export const TaskList: z.ZodArray<z.ZodRecord<typeof z, typeof Task>> =
   z.array(z.record(z.string(), Task).meta({...}))
@@ -229,6 +245,7 @@ export const CallTask: z.ZodUnion<readonly z.ZodTypeAny[]> = z.union([...])
 ```
 
 **After:**
+
 ```typescript
 export const TaskList = z.array(
   z.record(z.string(), z.lazy(() => Task)).meta({...})
@@ -238,6 +255,7 @@ export const CallTask = z.union([...])  // Let TS infer
 ```
 
 This aligns with:
+
 1. Colin's guidance that `z.record()` REQUIRES `z.lazy()` for recursive values
 2. Best practice of not using `z.ZodTypeAny` which defeats type safety
 3. Zod v4's getter pattern for recursive object properties (which we already do)