@toolproof-core/schema 1.0.16 → 1.0.18

package/dist/scripts/_lib/utils/jsonSchemaToZod.js

@@ -0,0 +1,607 @@
+/*
+ * Best-effort JSON Schema (draft 2020-12-ish) -> Zod v4 code generator.
+ *
+ * Intent:
+ * - Convert ToolProof standalone schemas (generated by generateStandaloneSchema.ts)
+ *   into runtime validators usable by consumers.
+ * - Be explicit about approximations: return warnings for keywords we ignore or
+ *   cannot faithfully map.
+ */
+function isObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+function pathJoin(base, key) {
+    if (!base)
+        return String(key);
+    if (typeof key === 'number')
+        return `${base}[${key}]`;
+    return `${base}.${key}`;
+}
+function warn(ctx, path, message) {
+    ctx.warnings.push({ path, message });
+}
+function asDefSchemaRef(defName) {
+    return `${defName}Schema`;
+}
+function extractPointerDefName(ref) {
+    if (!ref || typeof ref !== 'string')
+        return null;
+    if (!ref.startsWith('#/'))
+        return null;
+    const parts = ref.slice(2).split('/');
+    if (parts.length !== 2)
+        return null;
+    if (parts[0] !== '$defs')
+        return null;
+    const name = parts[1].replace(/~1/g, '/').replace(/~0/g, '~');
+    return name;
+}
+function resolveLocalRef(ref, ctx) {
+    const byPointer = extractPointerDefName(ref);
+    if (byPointer && ctx.defNames.has(byPointer))
+        return byPointer;
+    if (ref.startsWith('#') && !ref.startsWith('#/')) {
+        const anchor = ref.slice(1);
+        const defName = ctx.anchorToDefName[anchor];
+        if (defName)
+            return defName;
+    }
+    return null;
+}
+function jsonString(value) {
+    return JSON.stringify(value);
+}
+function emitRegex(pattern) {
+    return `new RegExp(${jsonString(pattern)})`;
+}
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function isBooleanSchema(node) {
+    return typeof node === 'boolean';
+}
+function isDictLikeObjectSchema(node) {
+    if (!isObject(node))
+        return false;
+    if (node.type !== 'object')
+        return false;
+    const hasFixedProps = hasOwn(node, 'properties') && isObject(node.properties) && Object.keys(node.properties).length > 0;
+    const hasPropertyNames = isObject(node.propertyNames);
+    const hasAdditionalSchema = isObject(node.additionalProperties) || isBooleanSchema(node.additionalProperties);
+    return !hasFixedProps && hasPropertyNames && hasAdditionalSchema;
+}
+function emitDictLikeObjectSchema(node, ctx, path) {
+    const valueSchemaNode = node.additionalProperties;
+    const valueExpr = emitSchema(valueSchemaNode, ctx, pathJoin(path, 'additionalProperties'));
+    const pn = node.propertyNames;
+    let keyPattern;
+    if (isObject(pn)) {
+        if (typeof pn.pattern === 'string') {
+            keyPattern = pn.pattern;
+        }
+        else if (typeof pn.$ref === 'string') {
+            const defName = resolveLocalRef(pn.$ref, ctx);
+            const resolved = defName ? ctx.defsByName[defName] : undefined;
+            if (isObject(resolved) && typeof resolved.pattern === 'string') {
+                keyPattern = resolved.pattern;
+            }
+            else {
+                warn(ctx, pathJoin(path, 'propertyNames'), 'Unsupported propertyNames $ref target; keys will not be validated.');
+            }
+        }
+        else {
+            warn(ctx, pathJoin(path, 'propertyNames'), 'Unsupported propertyNames shape; keys will not be validated.');
+        }
+    }
+    else {
+        warn(ctx, pathJoin(path, 'propertyNames'), 'Unsupported propertyNames shape; keys will not be validated.');
+    }
+    const minProps = typeof node.minProperties === 'number' ? node.minProperties : undefined;
+    const maxProps = typeof node.maxProperties === 'number' ? node.maxProperties : undefined;
+    const checks = [];
+    if (keyPattern) {
+        checks.push(`for (const k of Object.keys(obj)) { if (!${emitRegex(keyPattern)}.test(k)) ctx.addIssue({ code: 'custom', message: 'Invalid key: ' + k }); }`);
+    }
+    if (minProps !== undefined) {
+        checks.push(`if (Object.keys(obj).length < ${minProps}) ctx.addIssue({ code: 'custom', message: 'Expected at least ${minProps} properties' });`);
+    }
+    if (maxProps !== undefined) {
+        checks.push(`if (Object.keys(obj).length > ${maxProps}) ctx.addIssue({ code: 'custom', message: 'Expected at most ${maxProps} properties' });`);
+    }
+    if (checks.length === 0) {
+        return `z.record(z.string(), ${valueExpr})`;
+    }
+    return `z.record(z.string(), ${valueExpr}).superRefine((obj, ctx) => { ${checks.join(' ')} })`;
+}
+function resolveSchemaIfRef(node, ctx) {
+    if (isObject(node) && typeof node.$ref === 'string') {
+        const defName = resolveLocalRef(node.$ref, ctx);
+        if (defName)
+            return ctx.defsByName[defName];
+    }
+    return node;
+}
+function isDirectObjectishSchema(node) {
+    if (!isObject(node))
+        return false;
+    if (node.type === 'object')
+        return true;
+    return (hasOwn(node, 'properties') ||
+        hasOwn(node, 'required') ||
+        hasOwn(node, 'additionalProperties') ||
+        hasOwn(node, 'unevaluatedProperties') ||
+        hasOwn(node, 'propertyNames') ||
+        hasOwn(node, 'patternProperties') ||
+        hasOwn(node, 'dependentRequired') ||
+        hasOwn(node, 'dependentSchemas'));
+}
+function expandAllOfObjectishSchemas(node, ctx, path, seen) {
+    const resolved = resolveSchemaIfRef(node, ctx);
+    if (!isObject(resolved))
+        return null;
+    if (seen.has(resolved))
+        return null;
+    seen.add(resolved);
+    if (isDirectObjectishSchema(resolved))
+        return [resolved];
+    if (Array.isArray(resolved.allOf) && resolved.allOf.length > 0) {
+        const out = [];
+        for (let i = 0; i < resolved.allOf.length; i++) {
+            const child = resolved.allOf[i];
+            const expanded = expandAllOfObjectishSchemas(child, ctx, pathJoin(pathJoin(path, 'allOf'), i), seen);
+            if (!expanded)
+                return null;
+            out.push(...expanded);
+        }
+        return out;
+    }
+    return null;
+}
+function mergePropertySchemas(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    return { allOf: [a, b] };
+}
+function mergeAllOfObjectSchemas(allOfSchemas, ctx, path) {
+    const flattened = [];
+    const seen = new Set();
+    for (let i = 0; i < allOfSchemas.length; i++) {
+        const expanded = expandAllOfObjectishSchemas(allOfSchemas[i], ctx, pathJoin(pathJoin(path, 'allOf'), i), seen);
+        if (!expanded)
+            return null;
+        flattened.push(...expanded);
+    }
+    const merged = { type: 'object', properties: {} };
+    const required = new Set();
+    let additionalProperties = undefined;
+    let unevaluatedProperties = undefined;
+    for (let i = 0; i < flattened.length; i++) {
+        const s = flattened[i];
+        const p = pathJoin(pathJoin(path, 'allOfFlattened'), i);
+        if (!isObject(s))
+            continue;
+        if (isObject(s.properties)) {
+            for (const [k, v] of Object.entries(s.properties)) {
+                merged.properties[k] = mergePropertySchemas(merged.properties[k], v);
+            }
+        }
+        if (Array.isArray(s.required)) {
+            for (const r of s.required)
+                if (typeof r === 'string')
+                    required.add(r);
+        }
+        if (hasOwn(s, 'additionalProperties')) {
+            if (additionalProperties === undefined) {
+                additionalProperties = s.additionalProperties;
+            }
+            else {
+                if (additionalProperties === false || s.additionalProperties === false) {
+                    additionalProperties = false;
+                }
+                else if (isObject(additionalProperties) && isObject(s.additionalProperties)) {
+                    additionalProperties = { allOf: [additionalProperties, s.additionalProperties] };
+                }
+                else {
+                    additionalProperties = isObject(additionalProperties)
+                        ? additionalProperties
+                        : (isObject(s.additionalProperties) ? s.additionalProperties : true);
+                }
+            }
+        }
+        if (s.unevaluatedProperties === false) {
+            // Preserve the flag on the merged schema; it can be enforced once the
+            // object facets are merged into a single z.object(...).
+            unevaluatedProperties = false;
+        }
+        else if (hasOwn(s, 'unevaluatedProperties')) {
+            warn(ctx, pathJoin(p, 'unevaluatedProperties'), 'Unsupported unevaluatedProperties value; ignoring.');
+        }
+        if (hasOwn(s, 'propertyNames') && !hasOwn(merged, 'propertyNames'))
+            merged.propertyNames = s.propertyNames;
+        if (hasOwn(s, 'patternProperties') && !hasOwn(merged, 'patternProperties'))
+            merged.patternProperties = s.patternProperties;
+        if (hasOwn(s, 'dependentRequired') && !hasOwn(merged, 'dependentRequired'))
+            merged.dependentRequired = s.dependentRequired;
+        if (hasOwn(s, 'dependentSchemas') && !hasOwn(merged, 'dependentSchemas'))
+            merged.dependentSchemas = s.dependentSchemas;
+    }
+    if (Object.keys(merged.properties).length === 0)
+        delete merged.properties;
+    if (required.size > 0)
+        merged.required = Array.from(required);
+    if (additionalProperties !== undefined)
+        merged.additionalProperties = additionalProperties;
+    if (unevaluatedProperties === false)
+        merged.unevaluatedProperties = false;
+    return merged;
+}
+function emitAllOf(node, ctx, path) {
+    const arr = node.allOf;
+    if (!Array.isArray(arr) || arr.length === 0) {
+        warn(ctx, pathJoin(path, 'allOf'), 'Expected non-empty allOf array; treating as z.any().');
+        return 'z.any()';
+    }
+    const mergedObject = mergeAllOfObjectSchemas(arr, ctx, path);
+    if (mergedObject) {
+        return emitSchema(mergedObject, ctx, pathJoin(path, 'allOfMerged'));
+    }
+    const parts = arr.map((s, i) => emitSchema(s, ctx, pathJoin(pathJoin(path, 'allOf'), i)));
+    let out = parts[0];
+    for (let i = 1; i < parts.length; i++) {
+        out = `z.intersection(${out}, ${parts[i]})`;
+    }
+    return out;
+}
+function emitAnyOfUnion(kind, node, ctx, path) {
+    const arr = node[kind];
+    if (!Array.isArray(arr) || arr.length === 0) {
+        warn(ctx, pathJoin(path, kind), `Expected non-empty ${kind} array; treating as z.any().`);
+        return 'z.any()';
+    }
+    const parts = arr.map((s, i) => emitSchema(s, ctx, pathJoin(pathJoin(path, kind), i)));
+    return `z.union([${parts.join(', ')}])`;
+}
+function emitEnum(node, ctx, path) {
+    const values = node.enum;
+    if (!Array.isArray(values) || values.length === 0) {
+        warn(ctx, pathJoin(path, 'enum'), 'Expected non-empty enum array; treating as z.any().');
+        return 'z.any()';
+    }
+    const literals = values.map((v) => `z.literal(${jsonString(v)})`);
+    return `z.union([${literals.join(', ')}])`;
+}
+function emitType(typeValue, node, ctx, path) {
+    const types = Array.isArray(typeValue) ? typeValue : [typeValue];
+    const exprs = [];
+    for (const t of types) {
+        if (t === 'string') {
+            let s = 'z.string()';
+            if (typeof node.minLength === 'number')
+                s += `.min(${node.minLength})`;
+            if (typeof node.maxLength === 'number')
+                s += `.max(${node.maxLength})`;
+            if (typeof node.pattern === 'string')
+                s += `.regex(${emitRegex(node.pattern)})`;
+            if (typeof node.format === 'string') {
+                // Enforce only a small subset where Zod semantics are reasonably aligned.
+                if (node.format === 'uri') {
+                    s += '.url()';
+                }
+                else if (node.format === 'date-time') {
+                    s += '.datetime()';
+                }
+                else if (node.format === 'uuid') {
+                    s += '.uuid()';
+                }
+                else {
+                    warn(ctx, pathJoin(path, 'format'), `Ignoring format '${node.format}' (not enforced by generated Zod).`);
+                }
+            }
+            exprs.push(s);
+        }
+        else if (t === 'number') {
+            let n = 'z.number()';
+            if (typeof node.minimum === 'number')
+                n += `.min(${node.minimum})`;
+            if (typeof node.maximum === 'number')
+                n += `.max(${node.maximum})`;
+            if (typeof node.exclusiveMinimum === 'number')
+                n += `.gt(${node.exclusiveMinimum})`;
+            if (typeof node.exclusiveMaximum === 'number')
+                n += `.lt(${node.exclusiveMaximum})`;
+            if (typeof node.multipleOf === 'number')
+                n += `.multipleOf(${node.multipleOf})`;
+            exprs.push(n);
+        }
+        else if (t === 'integer') {
+            let n = 'z.number().int()';
+            if (typeof node.minimum === 'number')
+                n += `.min(${node.minimum})`;
+            if (typeof node.maximum === 'number')
+                n += `.max(${node.maximum})`;
+            if (typeof node.exclusiveMinimum === 'number')
+                n += `.gt(${node.exclusiveMinimum})`;
+            if (typeof node.exclusiveMaximum === 'number')
+                n += `.lt(${node.exclusiveMaximum})`;
+            if (typeof node.multipleOf === 'number')
+                n += `.multipleOf(${node.multipleOf})`;
+            exprs.push(n);
+        }
+        else if (t === 'boolean') {
+            exprs.push('z.boolean()');
+        }
+        else if (t === 'null') {
+            exprs.push('z.null()');
+        }
+        else if (t === 'array') {
+            const itemsExpr = hasOwn(node, 'items') ? emitSchema(node.items, ctx, pathJoin(path, 'items')) : 'z.any()';
+            let a = `z.array(${itemsExpr})`;
+            if (typeof node.minItems === 'number')
+                a += `.min(${node.minItems})`;
+            if (typeof node.maxItems === 'number')
+                a += `.max(${node.maxItems})`;
+            if (node.uniqueItems === true) {
+                warn(ctx, pathJoin(path, 'uniqueItems'), 'uniqueItems not enforced by generated Zod.');
+            }
+            exprs.push(a);
+        }
+        else if (t === 'object') {
+            exprs.push(emitObject(node, ctx, path));
+        }
+        else {
+            warn(ctx, pathJoin(path, 'type'), `Unsupported type '${String(t)}'; treating as z.any().`);
+            exprs.push('z.any()');
+        }
+    }
+    if (exprs.length === 1)
+        return exprs[0];
+    return `z.union([${exprs.join(', ')}])`;
+}
+function emitObject(node, ctx, path) {
+    if (isDictLikeObjectSchema(node)) {
+        return emitDictLikeObjectSchema(node, ctx, path);
+    }
+    const props = isObject(node.properties) ? node.properties : {};
+    const required = Array.isArray(node.required) ? new Set(node.required.filter((x) => typeof x === 'string')) : new Set();
+    const propEntries = [];
+    for (const [key, schemaNode] of Object.entries(props)) {
+        const expr = emitSchema(schemaNode, ctx, pathJoin(pathJoin(path, 'properties'), key));
+        const withOptional = required.has(key) ? expr : `${expr}.optional()`;
+        propEntries.push(`${jsonString(key)}: ${withOptional}`);
+    }
+    let out = `z.object({ ${propEntries.join(', ')} })`;
+    const hasAllOf = Array.isArray(node.allOf) && node.allOf.length > 0;
+    const additional = node.additionalProperties;
+    const unevaluated = node.unevaluatedProperties;
+    const hasPatternProperties = isObject(node.patternProperties);
+    if (additional === false) {
+        if (hasAllOf) {
+            warn(ctx, pathJoin(path, 'additionalProperties'), 'additionalProperties:false with allOf is approximated; not emitting .strict().');
+        }
+        else {
+            out += '.strict()';
+        }
+    }
+    else if (isObject(additional) || isBooleanSchema(additional)) {
+        if (additional === true) {
+            // passthrough is closest to allowing extras without validation
+            out += '.passthrough()';
+        }
+        else if (additional === false) {
+            // handled above
+        }
+        else {
+            const catchallExpr = emitSchema(additional, ctx, pathJoin(path, 'additionalProperties'));
+            out += `.catchall(${catchallExpr})`;
+        }
+    }
+    if (unevaluated === false) {
+        if (hasAllOf) {
+            warn(ctx, pathJoin(path, 'unevaluatedProperties'), 'unevaluatedProperties:false with allOf is approximated; not emitting .strict().');
+        }
+        else if (hasPatternProperties) {
+            warn(ctx, pathJoin(path, 'unevaluatedProperties'), 'unevaluatedProperties:false with patternProperties is approximated; not emitting .strict().');
+        }
+        else if (hasOwn(node, 'additionalProperties') && additional !== false) {
+            // additionalProperties evaluates extra keys; unevaluatedProperties:false doesn't
+            // further restrict them, so .strict() would be incorrect.
+        }
+        else {
+            out += '.strict()';
+        }
+    }
+    else if (unevaluated !== undefined) {
+        warn(ctx, pathJoin(path, 'unevaluatedProperties'), 'Unsupported unevaluatedProperties value; ignoring.');
+    }
+    if (typeof node.minProperties === 'number') {
+        out += `.refine((o) => Object.keys(o).length >= ${node.minProperties}, { message: 'Expected at least ${node.minProperties} properties' })`;
+    }
+    if (typeof node.maxProperties === 'number') {
+        out += `.refine((o) => Object.keys(o).length <= ${node.maxProperties}, { message: 'Expected at most ${node.maxProperties} properties' })`;
+    }
+    if (isObject(node.propertyNames)) {
+        // Zod doesn't support propertyNames on object schemas directly; warn.
+        warn(ctx, pathJoin(path, 'propertyNames'), 'propertyNames on fixed-shape object not enforced by generated Zod.');
+    }
+    if (hasPatternProperties) {
+        warn(ctx, pathJoin(path, 'patternProperties'), 'patternProperties not enforced by generated Zod.');
+    }
+    if (isObject(node.dependentRequired) || isObject(node.dependentSchemas)) {
+        warn(ctx, pathJoin(path, 'dependentRequired'), 'dependentRequired/dependentSchemas not enforced by generated Zod.');
+    }
+    return out;
+}
+function emitSchema(node, ctx, path) {
+    if (isBooleanSchema(node)) {
+        return node ? 'z.any()' : 'z.never()';
+    }
+    if (!isObject(node)) {
+        warn(ctx, path, 'Expected schema object/boolean; treating as z.any().');
+        return 'z.any()';
+    }
+    if (typeof node.$ref === 'string') {
+        const defName = resolveLocalRef(node.$ref, ctx);
+        if (defName)
+            return asDefSchemaRef(defName);
+        warn(ctx, pathJoin(path, '$ref'), `Unsupported $ref '${node.$ref}'; treating as z.any().`);
+        return 'z.any()';
+    }
+    if (hasOwn(node, 'const')) {
+        return `z.literal(${jsonString(node.const)})`;
+    }
+    if (hasOwn(node, 'enum')) {
+        return emitEnum(node, ctx, path);
+    }
+    if (Array.isArray(node.allOf) && node.allOf.length > 0) {
+        return emitAllOf(node, ctx, path);
+    }
+    if (Array.isArray(node.oneOf) && node.oneOf.length > 0) {
+        return emitAnyOfUnion('oneOf', node, ctx, path);
+    }
+    if (Array.isArray(node.anyOf) && node.anyOf.length > 0) {
+        return emitAnyOfUnion('anyOf', node, ctx, path);
+    }
+    if (hasOwn(node, 'type')) {
+        return emitType(node.type, node, ctx, path);
+    }
+    // Heuristics: object-ish schemas without explicit type.
+    if (hasOwn(node, 'properties') || hasOwn(node, 'required') || hasOwn(node, 'additionalProperties') || hasOwn(node, 'unevaluatedProperties')) {
+        return emitObject({ ...node, type: 'object' }, ctx, path);
+    }
+    if (hasOwn(node, 'items')) {
+        return emitType('array', node, ctx, path);
+    }
+    if (hasOwn(node, 'not')) {
+        warn(ctx, pathJoin(path, 'not'), 'Keyword `not` is not supported; treating as z.any().');
+        return 'z.any()';
+    }
+    if (hasOwn(node, 'semanticValidation')) {
+        warn(ctx, pathJoin(path, 'semanticValidation'), 'Ajv custom keyword semanticValidation is not enforced by generated Zod.');
+    }
+    return 'z.any()';
+}
+function buildAnchorMap(defs) {
+    const map = {};
+    for (const [defName, defSchema] of Object.entries(defs)) {
+        if (!isObject(defSchema))
+            continue;
+        const top = defSchema.$anchor;
+        if (typeof top === 'string' && top)
+            map[top] = defName;
+        const nested = defSchema.nucleusSchema;
+        if (isObject(nested) && typeof nested.$anchor === 'string' && nested.$anchor) {
+            map[nested.$anchor] = defName;
+        }
+    }
+    return map;
+}
+// PURE: Deep-clone JSON-ish values (no mutation of input).
+function deepClone(v) {
+    if (Array.isArray(v))
+        return v.map((x) => deepClone(x));
+    if (isObject(v)) {
+        const out = {};
+        for (const k of Object.keys(v))
+            out[k] = deepClone(v[k]);
+        return out;
+    }
+    return v;
+}
+// PURE: Move sibling object keywords into `allOf` overlays (returns a new tree; does not mutate inputs).
+// Genesis frequently uses `allOf` alongside sibling `properties` and `required`.
+function normalizeAllOfSiblingObjectKeywords(node) {
+    if (Array.isArray(node)) {
+        let changed = false;
+        const out = node.map((item) => {
+            const next = normalizeAllOfSiblingObjectKeywords(item);
+            if (next !== item)
+                changed = true;
+            return next;
+        });
+        return changed ? out : node;
+    }
+    if (!node || typeof node !== 'object')
+        return node;
+    const hasAllOf = Array.isArray(node.allOf) && node.allOf.length > 0;
+    const looksLikeObjectSchema = node.type === 'object' ||
+        node.properties !== undefined ||
+        node.required !== undefined ||
+        node.unevaluatedProperties !== undefined ||
+        node.additionalProperties !== undefined ||
+        node.propertyNames !== undefined;
+    const siblingKeys = [
+        'type',
+        'properties',
+        'required',
+        'additionalProperties',
+        'unevaluatedProperties',
+        'propertyNames',
+        'patternProperties',
+        'dependentRequired',
+        'dependentSchemas',
+        'minProperties',
+        'maxProperties'
+    ];
+    let localNode = node;
+    if (hasAllOf && looksLikeObjectSchema) {
+        const hasSiblingObjectKeywords = siblingKeys.some((k) => k in localNode);
+        if (hasSiblingObjectKeywords) {
+            const overlay = {};
+            const nextNode = { ...localNode };
+            for (const k of siblingKeys) {
+                if (k in nextNode) {
+                    overlay[k] = nextNode[k];
+                    delete nextNode[k];
+                }
+            }
+            nextNode.allOf = [overlay, ...nextNode.allOf];
+            localNode = nextNode;
+        }
+    }
+    let changed = localNode !== node;
+    const out = localNode === node ? {} : { ...localNode };
+    for (const [k, v] of Object.entries(localNode)) {
+        const next = normalizeAllOfSiblingObjectKeywords(v);
+        if (next !== v) {
+            if (!changed) {
+                changed = true;
+                Object.assign(out, localNode);
+            }
+            out[k] = next;
+        }
+        else if (changed) {
+            out[k] = v;
+        }
+    }
+    return changed ? out : node;
+}
+function normalizeSchemaForEmitter(schema) {
+    return normalizeAllOfSiblingObjectKeywords(schema);
+}
+/**
+ * Convert a standalone schema JSON into a set of named Zod expressions.
+ *
+ * The output intentionally returns *expressions* (no imports/exports), so the
+ * caller can decide on file/module layout.
+ */
+export function jsonSchemaToZodExpressions(standaloneSchema, rootName) {
+    const normalized = normalizeSchemaForEmitter(deepClone(standaloneSchema));
+    const defs = isObject(normalized?.$defs) ? normalized.$defs : {};
+    const defNames = new Set(Object.keys(defs));
+    const ctx = {
+        defNames,
+        defsByName: defs,
+        anchorToDefName: buildAnchorMap(defs),
+        warnings: []
+    };
+    const expressionsByName = {};
+    // Emit defs first (order does not matter if caller wraps in z.lazy).
+    for (const defName of Object.keys(defs)) {
+        expressionsByName[defName] = emitSchema(defs[defName], ctx, `$defs.${defName}`);
+    }
+    // Root schema expression.
+    expressionsByName[rootName] = emitSchema(normalized, ctx, rootName);
+    return { expressionsByName, warnings: ctx.warnings };
+}

package/dist/scripts/generateStandaloneZodSchema.d.ts

@@ -0,0 +1 @@
+export {};