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

package/dist/cjs/utils/buildRefRegistry.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildRefRegistry = void 0;
 const resolveUri_js_1 = require("./resolveUri.js");
-const buildRefRegistry = (schema, rootBaseUri = "root:///", opts = {}) => {
+const buildRefRegistry = (schema, rootBaseUri = "root:///") => {
     const registry = new Map();
     const walk = (node, baseUri, path) => {
         if (typeof node !== "object" || node === null)

package/dist/cjs/utils/omit.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.omit = void 0;
 const omit = (obj, ...keys) => Object.keys(obj).reduce((acc, key) => {
-    if (!keys.includes(key)) {
-        acc[key] = obj[key];
+    const typedKey = key;
+    if (!keys.includes(typedKey)) {
+        acc[typedKey] = obj[typedKey];
     }
     return acc;
 }, {});

package/dist/esm/core/emitZod.js

@@ -70,6 +70,16 @@ export const emitZod = (analysis) => {
     const { module, name, type, noImport, exportRefs, withMeta, ...rest } = options;
     const declarations = new Map();
     const dependencies = new Map();
+    const reserveName = (base) => {
+        let candidate = base;
+        let i = 1;
+        while (usedNames.has(candidate) || declarations.has(candidate)) {
+            candidate = `${base}${i}`;
+            i += 1;
+        }
+        usedNames.add(candidate);
+        return candidate;
+    };
     const parsedSchema = parseSchema(schema, {
         module,
         name,
@@ -91,15 +101,21 @@ export const emitZod = (analysis) => {
     });
     const declarationBlock = declarations.size
         ? orderDeclarations(Array.from(declarations.entries()), dependencies)
-            .map(([refName, value]) => {
+            .flatMap(([refName, value]) => {
             const shouldExport = exportRefs && module === "esm";
-            const decl = `${shouldExport ? "export " : ""}const ${refName} = ${value}`;
-            return decl;
+            const isCycle = cycleRefNames.has(refName);
+            if (!isCycle) {
+                return [`${shouldExport ? "export " : ""}const ${refName} = ${value}`];
+            }
+            const baseName = `${refName}Def`;
+            const lines = [`const ${baseName} = ${value}`];
+            lines.push(`${shouldExport ? "export " : ""}const ${refName} = ${baseName}`);
+            return lines;
         })
             .join("\n")
         : "";
-    const jsdocs = rest.withJsdocs && typeof schema !== "boolean" && schema.description
-        ? expandJsdocs(schema.description)
+    const jsdocs = rest.withJsdocs && typeof schema === "object" && schema !== null && "description" in schema
+        ? expandJsdocs(String(schema.description ?? ""))
         : "";
     const lines = [];
     if (module === "cjs" && !noImport) {

package/dist/esm/generators/generateBundle.js

@@ -8,23 +8,27 @@ export const generateSchemaBundle = (schema, options = {}) => {
     const defs = schema.$defs || {};
     const definitions = schema.definitions || {};
     const defNames = Object.keys(defs);
-    const { rootName, rootTypeName, defInfoMap } = buildBundleContext(defNames, defs, options);
+    const { rootName, rootTypeName, defInfoMap, groups } = buildBundleContext(defNames, defs, options);
     const files = [];
-    const targets = planBundleTargets(schema, defs, definitions, defNames, options, rootName, rootTypeName);
+    const targets = planBundleTargets(schema, defs, definitions, defNames, options, rootName, defInfoMap, rootTypeName);
     for (const target of targets) {
         const usedRefs = target.usedRefs;
-        const analysis = analyzeSchema(target.schemaWithDefs, {
-            ...options,
-            module,
-            name: target.schemaName,
-            type: target.typeName,
-            parserOverride: createRefHandler(target.defName, defInfoMap, usedRefs, {
-                ...(target.schemaWithDefs.$defs || {}),
-                ...(target.schemaWithDefs.definitions || {}),
-            }, options),
-        });
-        const zodSchema = emitZod(analysis);
-        const finalSchema = buildSchemaFile(zodSchema, usedRefs, defInfoMap, module);
+        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, {
+                    ...(member.schemaWithDefs.$defs || {}),
+                    ...(member.schemaWithDefs.definitions || {}),
+                }, options, target.groupId),
+            });
+            const zodSchema = emitZod(analysis);
+            zodParts.push(zodSchema);
+        }
+        const finalSchema = buildSchemaFile(zodParts, usedRefs, defInfoMap, module, target);
         files.push({ fileName: target.fileName, contents: finalSchema });
     }
     // Nested types extraction (optional)
@@ -53,13 +57,16 @@ const buildDefInfoMap = (defNames, defs, options) => {
         const pascalName = toPascalCase(defName);
         const schemaName = options.splitDefs?.schemaName?.(defName, { isRoot: false }) ?? `${pascalName}Schema`;
         const typeName = options.splitDefs?.typeName?.(defName, { isRoot: false }) ?? pascalName;
+        const fileName = options.splitDefs?.fileName?.(defName, { isRoot: false }) ?? `${defName}.schema.ts`;
         map.set(defName, {
             name: defName,
             pascalName,
             schemaName,
             typeName,
+            fileName,
             dependencies,
             hasCycle: false,
+            groupId: "",
         });
     }
     return map;
@@ -72,13 +79,22 @@ 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 info = defInfoMap.get(defName);
+            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 };
+    return { defInfoMap, rootName, rootTypeName, groups };
 };
-const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options) => {
+const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options, currentGroupId) => {
+    const useLazyCrossRefs = options.refResolution?.lazyCrossRefs ?? true;
     return (schema, refs) => {
         if (typeof schema["$ref"] === "string") {
             const refPath = schema["$ref"];
@@ -92,7 +108,7 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
                 const refInfo = defInfoMap.get(refName);
                 if (refInfo) {
                     // Track imports when referencing other defs
-                    if (refName !== currentDefName) {
+                    if (refName !== currentDefName && refInfo.groupId !== currentGroupId) {
                         usedRefs.add(refName);
                     }
                     const isCycle = refName === currentDefName || (refInfo.hasCycle && !!currentDefName);
@@ -105,7 +121,14 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
                     });
                     if (resolved)
                         return resolved;
-                    if (isCycle && options.refResolution?.lazyCrossRefs) {
+                    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(() => ${refInfo.schemaName})`;
                     }
                     return refInfo.schemaName;
@@ -124,42 +147,73 @@ const createRefHandler = (currentDefName, defInfoMap, usedRefs, allDefs, options
         return undefined;
     };
 };
-const buildSchemaFile = (zodCode, usedRefs, defInfoMap, module) => {
+const buildSchemaFile = (zodCodeParts, usedRefs, defInfoMap, module, target) => {
     if (module !== "esm")
-        return zodCode;
-    const imports = [];
+        return zodCodeParts.join("\n");
+    const groupFileById = new Map();
+    for (const info of defInfoMap.values()) {
+        if (!groupFileById.has(info.groupId)) {
+            groupFileById.set(info.groupId, info.fileName.replace(/\.ts$/, ".js"));
+        }
+    }
+    const importsByFile = new Map();
     for (const refName of [...usedRefs].sort()) {
         const refInfo = defInfoMap.get(refName);
         if (refInfo) {
-            imports.push(`import { ${refInfo.schemaName} } from './${refName}.schema.js';`);
+            const groupFile = groupFileById.get(refInfo.groupId) ?? refInfo.fileName.replace(/\.ts$/, ".js");
+            const path = `./${groupFile}`;
+            const set = importsByFile.get(path) ?? new Set();
+            set.add(refInfo.schemaName);
+            importsByFile.set(path, set);
         }
     }
-    if (!imports.length)
-        return zodCode;
-    return zodCode.replace('import { z } from "zod"', `import { z } from "zod"\n${imports.join("\n")}`);
+    const imports = [];
+    for (const [path, names] of [...importsByFile.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+        imports.push(`import { ${[...names].sort().join(", ")} } from '${path}';`);
+    }
+    const body = zodCodeParts
+        .map((code, idx) => {
+        if (idx === 0)
+            return code;
+        return code.replace(/^import \{ z \} from "zod"\n?/, "");
+    })
+        .join("\n");
+    return imports.length
+        ? body.replace('import { z } from "zod"', `import { z } from "zod"\n${imports.join("\n")}`)
+        : body;
 };
-const planBundleTargets = (rootSchema, defs, definitions, defNames, options, rootName, rootTypeName) => {
+const planBundleTargets = (rootSchema, defs, definitions, defNames, options, rootName, defInfoMap, rootTypeName) => {
     const targets = [];
+    const groupById = new Map();
     for (const defName of defNames) {
-        const defSchema = defs[defName];
-        const defSchemaWithDefs = {
-            ...defSchema,
-            $defs: { ...defs, ...defSchema?.$defs },
-            definitions: {
-                ...defSchema.definitions,
-                ...definitions,
-            },
-        };
-        const pascalName = toPascalCase(defName);
-        const schemaName = options.splitDefs?.schemaName?.(defName, { isRoot: false }) ?? `${pascalName}Schema`;
-        const typeName = options.splitDefs?.typeName?.(defName, { isRoot: false }) ?? pascalName;
-        const fileName = options.splitDefs?.fileName?.(defName, { isRoot: false }) ?? `${defName}.schema.ts`;
+        const info = defInfoMap.get(defName);
+        const gid = info?.groupId || defName;
+        if (!groupById.has(gid))
+            groupById.set(gid, []);
+        groupById.get(gid).push(defName);
+    }
+    for (const [groupId, memberDefs] of groupById.entries()) {
+        const orderedDefs = orderGroupMembers(memberDefs, defInfoMap);
+        const members = orderedDefs.map((defName) => {
+            const defSchema = defs[defName];
+            const defSchemaWithDefs = {
+                ...defSchema,
+                $defs: { ...defs, ...defSchema?.$defs },
+                definitions: {
+                    ...defSchema.definitions,
+                    ...definitions,
+                },
+            };
+            const pascalName = toPascalCase(defName);
+            const schemaName = options.splitDefs?.schemaName?.(defName, { isRoot: false }) ?? `${pascalName}Schema`;
+            const typeName = options.splitDefs?.typeName?.(defName, { isRoot: false }) ?? pascalName;
+            return { defName, schemaWithDefs: defSchemaWithDefs, schemaName, typeName };
+        });
+        const fileName = defInfoMap.get(memberDefs[0])?.fileName ?? `${memberDefs[0]}.schema.ts`;
         targets.push({
-            defName,
-            schemaWithDefs: defSchemaWithDefs,
-            schemaName,
-            typeName,
+            groupId,
             fileName,
+            members,
             usedRefs: new Set(),
             isRoot: false,
         });
@@ -167,17 +221,22 @@ const planBundleTargets = (rootSchema, defs, definitions, defNames, options, roo
     if (options.splitDefs?.includeRoot ?? true) {
         const rootFile = options.splitDefs?.fileName?.("root", { isRoot: true }) ?? "workflow.schema.ts";
         targets.push({
-            defName: null,
-            schemaWithDefs: {
-                ...rootSchema,
-                definitions: {
-                    ...rootSchema.definitions,
-                    ...definitions,
-                },
-            },
-            schemaName: rootName,
-            typeName: rootTypeName,
+            groupId: "root",
             fileName: rootFile,
+            members: [
+                {
+                    defName: null,
+                    schemaWithDefs: {
+                        ...rootSchema,
+                        definitions: {
+                            ...rootSchema.definitions,
+                            ...definitions,
+                        },
+                    },
+                    schemaName: rootName,
+                    typeName: rootTypeName,
+                },
+            ],
             usedRefs: new Set(),
             isRoot: true,
         });
@@ -208,6 +267,35 @@ const findRefDependencies = (schema, validDefNames) => {
     traverse(schema);
     return deps;
 };
+const orderGroupMembers = (defs, defInfoMap) => {
+    const inGroup = new Set(defs);
+    const visited = new Set();
+    const temp = new Set();
+    const result = [];
+    const visit = (name) => {
+        if (visited.has(name))
+            return;
+        if (temp.has(name)) {
+            return;
+        }
+        temp.add(name);
+        const info = defInfoMap.get(name);
+        if (info) {
+            for (const dep of info.dependencies) {
+                if (inGroup.has(dep)) {
+                    visit(dep);
+                }
+            }
+        }
+        temp.delete(name);
+        visited.add(name);
+        result.push(name);
+    };
+    for (const name of defs) {
+        visit(name);
+    }
+    return result;
+};
 const detectCycles = (defInfoMap) => {
     const cycleNodes = new Set();
     const visited = new Set();
@@ -241,6 +329,52 @@ 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) {
@@ -285,7 +419,7 @@ const findNestedTypesInSchema = (schema, parentTypeName, defNames, currentPath =
     }
     // inline $defs
     if (record.$defs && typeof record.$defs === "object") {
-        for (const [_defName, defSchema] of Object.entries(record.$defs)) {
+        for (const [, defSchema] of Object.entries(record.$defs)) {
             nestedTypes.push(...findNestedTypesInSchema(defSchema, parentTypeName, defNames, currentPath));
         }
     }
@@ -316,6 +450,26 @@ const generateNestedTypesFile = (nestedTypes) => {
         " * They are extracted using TypeScript indexed access types.",
         " */",
         "",
+        "type Access<T, P extends readonly (string | number)[]> =",
+        "  P extends []",
+        "    ? NonNullable<T>",
+        "    : P extends readonly [infer H, ...infer R]",
+        "      ? H extends \"items\"",
+        "        ? Access<NonNullable<T> extends Array<infer U> ? U : unknown, Extract<R, (string | number)[]>>",
+        "        : 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)[]>>",
+        "            : H extends string",
+        "              ? Access<",
+        "                  H extends keyof NonNullable<T>",
+        "                    ? NonNullable<NonNullable<T>[H]>",
+        "                    : unknown,",
+        "                  Extract<R, (string | number)[]>",
+        "                >",
+        "              : unknown",
+        "      : unknown;",
+        "",
     ];
     const byParent = new Map();
     for (const info of nestedTypes) {
@@ -334,14 +488,15 @@ const generateNestedTypesFile = (nestedTypes) => {
         lines.push(`import type { ${typeName} } from './${file}.schema.js';`);
     }
     lines.push("");
+    const buildAccessExpr = (parentType, propertyPath) => {
+        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()) {
         lines.push(`// From ${parentType}`);
         for (const info of types.sort((a, b) => a.typeName.localeCompare(b.typeName))) {
             if (info.propertyPath.length > 0) {
-                let accessExpr = parentType;
-                for (const prop of info.propertyPath) {
-                    accessExpr = `NonNullable<${accessExpr}['${prop}']>`;
-                }
+                const accessExpr = buildAccessExpr(parentType, info.propertyPath);
                 lines.push(`export type ${info.typeName} = ${accessExpr};`);
             }
         }

package/dist/esm/parsers/parseAllOf.js

@@ -1,18 +1,20 @@
 import { parseSchema } from "./parseSchema.js";
 import { half } from "../utils/half.js";
-const originalIndex = Symbol("Original index");
+const originalIndexKey = "__originalIndex";
 const ensureOriginalIndex = (arr) => {
-    let newArr = [];
+    const newArr = [];
     for (let i = 0; i < arr.length; i++) {
         const item = arr[i];
         if (typeof item === "boolean") {
-            newArr.push(item ? { [originalIndex]: i } : { [originalIndex]: i, not: {} });
+            newArr.push(item ? { [originalIndexKey]: i } : { [originalIndexKey]: i, not: {} });
         }
-        else if (originalIndex in item) {
+        else if (typeof item === "object" &&
+            item !== null &&
+            originalIndexKey in item) {
             return arr;
         }
         else {
-            newArr.push({ ...item, [originalIndex]: i });
+            newArr.push({ ...item, [originalIndexKey]: i });
         }
     }
     return newArr;
@@ -25,7 +27,11 @@ export function parseAllOf(schema, refs) {
         const item = schema.allOf[0];
         return parseSchema(item, {
             ...refs,
-            path: [...refs.path, "allOf", item[originalIndex]],
+            path: [
+                ...refs.path,
+                "allOf",
+                item[originalIndexKey] ?? 0,
+            ],
         });
     }
     else {

package/dist/esm/parsers/parseBoolean.js

@@ -1,3 +1 @@
-export const parseBoolean = (_schema) => {
-    return "z.boolean()";
-};
+export const parseBoolean = () => "z.boolean()";

package/dist/esm/parsers/parseIfThenElse.js

@@ -14,8 +14,8 @@ export const parseIfThenElse = (schema, refs) => {
     ? ${$then}.safeParse(value)
     : ${$else}.safeParse(value);
   if (!result.success) {
-    const issues = result.error.issues ?? result.error.errors ?? [];
-    issues.forEach((issue) => ctx.addIssue(issue))
+    const issues = result.error.issues;
+    issues.forEach((issue) => ctx.addIssue({ ...issue }))
   }
 })`;
     // Store original if/then/else for JSON Schema round-trip

package/dist/esm/parsers/parseNull.js

@@ -1,3 +1 @@
-export const parseNull = (_schema) => {
-    return "z.null()";
-};
+export const parseNull = () => "z.null()";

package/dist/esm/parsers/parseObject.js

@@ -197,6 +197,7 @@ export function parseObject(objectSchema, refs) {
         output += `.and(${parseAnyOf({
             ...objectSchema,
             anyOf: objectSchema.anyOf.map((x) => typeof x === "object" &&
+                x !== null &&
                 !x.type &&
                 (x.properties || x.additionalProperties || x.patternProperties)
                 ? { ...x, type: "object" }
@@ -207,6 +208,7 @@ export function parseObject(objectSchema, refs) {
         output += `.and(${parseOneOf({
             ...objectSchema,
             oneOf: objectSchema.oneOf.map((x) => typeof x === "object" &&
+                x !== null &&
                 !x.type &&
                 (x.properties || x.additionalProperties || x.patternProperties)
                 ? { ...x, type: "object" }
@@ -217,6 +219,7 @@ export function parseObject(objectSchema, refs) {
         output += `.and(${parseAllOf({
             ...objectSchema,
             allOf: objectSchema.allOf.map((x) => typeof x === "object" &&
+                x !== null &&
                 !x.type &&
                 (x.properties || x.additionalProperties || x.patternProperties)
                 ? { ...x, type: "object" }
@@ -230,6 +233,7 @@ export function parseObject(objectSchema, refs) {
     // propertyNames
     if (objectSchema.propertyNames) {
         const normalizedPropNames = typeof objectSchema.propertyNames === "object" &&
+            objectSchema.propertyNames !== null &&
             !objectSchema.propertyNames.type &&
             objectSchema.propertyNames.pattern
             ? { ...objectSchema.propertyNames, type: "string" }
@@ -258,12 +262,12 @@ export function parseObject(objectSchema, refs) {
         if (entries.length) {
             output += `.superRefine((obj, ctx) => {
   ${entries
-                .map(([key, schema], idx) => {
+                .map(([key, schema]) => {
                 const parsed = parseSchema(schema, { ...refs, path: [...refs.path, "dependentSchemas", key] });
                 return `if (Object.prototype.hasOwnProperty.call(obj, ${JSON.stringify(key)})) {
     const result = ${parsed}.safeParse(obj);
     if (!result.success) {
-      ctx.addIssue({ code: "custom", message: "Dependent schema failed", path: [], params: { issues: result.error.issues } });
+      ctx.addIssue({ code: "custom", message: ${objectSchema.errorMessage?.dependentSchemas ?? JSON.stringify("Dependent schema failed")}, path: [], params: { issues: result.error.issues } });
     }
   }`;
             })
@@ -275,7 +279,8 @@ export function parseObject(objectSchema, refs) {
     if (objectSchema.dependentRequired && typeof objectSchema.dependentRequired === "object") {
         const entries = Object.entries(objectSchema.dependentRequired);
         if (entries.length) {
-            const depRequiredMessage = objectSchema.errorMessage?.dependentRequired ?? "Dependent required properties missing";
+            const depRequiredMessage = objectSchema.errorMessage?.dependentRequired ??
+                "Dependent required properties missing";
             output += `.superRefine((obj, ctx) => {
   ${entries
                 .map(([prop, deps]) => {
@@ -303,5 +308,8 @@ const shouldUseGetter = (parsed, refs) => {
     if (refs.currentSchemaName && parsed.includes(refs.currentSchemaName)) {
         return true;
     }
+    if (refs.cycleRefNames?.has(parsed)) {
+        return true;
+    }
     return Boolean(refs.inProgress && refs.inProgress.has(parsed));
 };

package/dist/esm/parsers/parseSchema.js

@@ -30,9 +30,7 @@ export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockM
     if (typeof schema !== "object")
         return schema ? anyOrUnknown(refs) : "z.never()";
     const parentBase = refs.currentBaseUri ?? refs.rootBaseUri ?? "root:///";
-    const baseUri = typeof schema.$id === "string"
-        ? resolveUri(parentBase, schema.$id)
-        : parentBase;
+    const baseUri = typeof schema.$id === "string" ? resolveUri(parentBase, schema.$id) : parentBase;
     const dynamicAnchors = Array.isArray(refs.dynamicAnchors) ? [...refs.dynamicAnchors] : [];
     if (typeof schema.$dynamicAnchor === "string") {
         dynamicAnchors.push({
@@ -81,6 +79,9 @@ export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockM
 };
 const parseRef = (schema, refs) => {
     const refValue = schema.$dynamicRef ?? schema.$ref;
+    if (typeof refValue !== "string") {
+        return anyOrUnknown(refs);
+    }
     const resolved = resolveRef(schema, refValue, refs);
     if (!resolved) {
         refs.onUnresolvedRef?.(refValue, refs.path);
@@ -119,6 +120,14 @@ const parseRef = (schema, refs) => {
     // (or is currently being resolved). This avoids TDZ on true cycles while
     // letting ordered, acyclic refs stay direct.
     if (isSameCycle || refs.inProgress.has(refName)) {
+        const inObjectProperty = refs.path.includes("properties") ||
+            refs.path.includes("patternProperties") ||
+            refs.path.includes("additionalProperties");
+        if (inObjectProperty && refName === refs.currentSchemaName) {
+            // Getter properties defer evaluation, so a direct reference avoids extra lazies
+            // for self-recursion.
+            return refName;
+        }
         return `z.lazy(() => ${refName})`;
     }
     return refName;
@@ -190,7 +199,10 @@ const resolveRef = (schemaNode, ref, refs) => {
         const loaded = refs.resolveExternalRef(extBase);
         if (loaded) {
             // If async resolver is used synchronously here, it will be ignored; keep simple sync for now
-            const schema = loaded.then ? undefined : loaded;
+            const maybePromise = 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));
@@ -338,10 +350,10 @@ const selectParser = (schema, refs) => {
         return parseNumber(schema);
     }
     else if (its.a.primitive(schema, "boolean")) {
-        return parseBoolean(schema);
+        return parseBoolean();
     }
     else if (its.a.primitive(schema, "null")) {
-        return parseNull(schema);
+        return parseNull();
     }
     else if (its.a.conditional(schema)) {
         return parseIfThenElse(schema, refs);

package/dist/esm/parsers/parseString.js

@@ -286,7 +286,7 @@ export const parseString = (schema, refs) => {
     if (contentMediaType != "") {
         r += contentMediaType;
         r += withMessage(schema, "contentSchema", ({ value }) => {
-            if (value && value instanceof Object) {
+            if (value && typeof value === "object") {
                 return {
                     opener: `.pipe(${parseSchema(value, refContext)}`,
                     closer: ")",

package/dist/esm/utils/buildRefRegistry.js

@@ -1,5 +1,5 @@
 import { resolveUri } from "./resolveUri.js";
-export const buildRefRegistry = (schema, rootBaseUri = "root:///", opts = {}) => {
+export const buildRefRegistry = (schema, rootBaseUri = "root:///") => {
     const registry = new Map();
     const walk = (node, baseUri, path) => {
         if (typeof node !== "object" || node === null)