@toolproof-core/genesis 1.0.48 → 1.0.50

package/src/utils/zodCodegen.ts

@@ -1,549 +1,549 @@
-import { normalizeAllOfSiblingObjectKeywords } from './schemaObjectNormalization.js';
-
-export type JsonSchema = any;
-
-export type JsonSchemaToZodWarning = {
-  path: string;
-  message: string;
-};
-
-export type JsonSchemaToZodResult = {
-  expressionsByName: Record<string, string>;
-  warnings: JsonSchemaToZodWarning[];
-};
-
-type Ctx = {
-  defNames: Set<string>;
-  defsByName: Record<string, any>;
-  anchorToDefName: Record<string, string>;
-  warnings: JsonSchemaToZodWarning[];
-};
-
-function isObject(v: any): v is Record<string, any> {
-  return v !== null && typeof v === 'object' && !Array.isArray(v);
-}
-
-function pathJoin(base: string, key: string | number): string {
-  if (!base) return String(key);
-  if (typeof key === 'number') return `${base}[${key}]`;
-  return `${base}.${key}`;
-}
-
-function warn(ctx: Ctx, path: string, message: string) {
-  ctx.warnings.push({ path, message });
-}
-
-function asDefSchemaRef(defName: string): string {
-  return `${defName}Schema`;
-}
-
-function extractPointerDefName(ref: string): string | null {
-  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 defName = parts[1];
-  if (defName === undefined) return null;
-  const name = defName.replace(/~1/g, '/').replace(/~0/g, '~');
-  return name;
-}
-
-function resolveLocalRef(ref: string, ctx: Ctx): string | null {
-  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: unknown): string {
-  return JSON.stringify(value);
-}
-
-function emitRegex(pattern: string): string {
-  return `new RegExp(${jsonString(pattern)})`;
-}
-
-function hasOwn(obj: any, key: string): boolean {
-  return Object.prototype.hasOwnProperty.call(obj, key);
-}
-
-function isBooleanSchema(node: any): node is boolean {
-  return typeof node === 'boolean';
-}
-
-function isRecordLikeObjectSchema(node: any): boolean {
-  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 emitRecordLikeObjectSchema(node: any, ctx: Ctx, path: string): string {
-  const valueSchemaNode = node.additionalProperties;
-  const valueExpr = emitSchema(valueSchemaNode, ctx, pathJoin(path, 'additionalProperties'));
-
-  const pn = node.propertyNames;
-  let keyPattern: string | undefined;
-  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: string[] = [];
-  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: any, ctx: Ctx): any {
-  if (isObject(node) && typeof node.$ref === 'string') {
-    const defName = resolveLocalRef(node.$ref, ctx);
-    if (defName) return ctx.defsByName[defName];
-  }
-  return node;
-}
-
-function isDirectObjectishSchema(node: any): boolean {
-  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: any, ctx: Ctx, path: string, seen: Set<any>): any[] | null {
-  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 as any).allOf) && (resolved as any).allOf.length > 0) {
-    const out: any[] = [];
-    for (let i = 0; i < (resolved as any).allOf.length; i++) {
-      const child = (resolved as any).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: any, b: any): any {
-  if (a === undefined) return b;
-  if (b === undefined) return a;
-  return { allOf: [a, b] };
-}
-
-function mergeAllOfObjectSchemas(allOfSchemas: any[], ctx: Ctx, path: string): any | null {
-  const flattened: any[] = [];
-  const seen = new Set<any>();
-  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: any = { type: 'object', properties: {} as Record<string, any> };
-  const required = new Set<string>();
-  let additionalProperties: any = undefined;
-  let unevaluatedProperties: any = undefined;
-
-  for (let i = 0; i < flattened.length; i++) {
-    const schema = flattened[i];
-    const schemaPath = pathJoin(pathJoin(path, 'allOfFlattened'), i);
-    if (!isObject(schema)) continue;
-
-    if (isObject(schema.properties)) {
-      for (const [key, value] of Object.entries(schema.properties)) {
-        merged.properties[key] = mergePropertySchemas(merged.properties[key], value);
-      }
-    }
-
-    if (Array.isArray(schema.required)) {
-      for (const requiredKey of schema.required) if (typeof requiredKey === 'string') required.add(requiredKey);
-    }
-
-    if (hasOwn(schema, 'additionalProperties')) {
-      if (additionalProperties === undefined) {
-        additionalProperties = (schema as any).additionalProperties;
-      } else if (additionalProperties === false || (schema as any).additionalProperties === false) {
-        additionalProperties = false;
-      } else if (isObject(additionalProperties) && isObject((schema as any).additionalProperties)) {
-        additionalProperties = { allOf: [additionalProperties, (schema as any).additionalProperties] };
-      } else {
-        additionalProperties = isObject(additionalProperties)
-          ? additionalProperties
-          : (isObject((schema as any).additionalProperties) ? (schema as any).additionalProperties : true);
-      }
-    }
-
-    if ((schema as any).unevaluatedProperties === false) {
-      unevaluatedProperties = false;
-    } else if (hasOwn(schema, 'unevaluatedProperties')) {
-      warn(ctx, pathJoin(schemaPath, 'unevaluatedProperties'), 'Unsupported unevaluatedProperties value; ignoring.');
-    }
-
-    if (hasOwn(schema, 'propertyNames') && !hasOwn(merged, 'propertyNames')) merged.propertyNames = (schema as any).propertyNames;
-    if (hasOwn(schema, 'patternProperties') && !hasOwn(merged, 'patternProperties')) merged.patternProperties = (schema as any).patternProperties;
-    if (hasOwn(schema, 'dependentRequired') && !hasOwn(merged, 'dependentRequired')) merged.dependentRequired = (schema as any).dependentRequired;
-    if (hasOwn(schema, 'dependentSchemas') && !hasOwn(merged, 'dependentSchemas')) merged.dependentSchemas = (schema as any).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: any, ctx: Ctx, path: string): string {
-  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((schema: any, index: number) => emitSchema(schema, ctx, pathJoin(pathJoin(path, 'allOf'), index)));
-  const firstPart = parts[0];
-  if (firstPart === undefined) {
-    warn(ctx, pathJoin(path, 'allOf'), 'Expected non-empty allOf array; treating as z.any().');
-    return 'z.any()';
-  }
-  let out = firstPart;
-  for (let i = 1; i < parts.length; i++) {
-    const part = parts[i];
-    if (part === undefined) continue;
-    out = `z.intersection(${out}, ${part})`;
-  }
-  return out;
-}
-
-function emitAnyOfUnion(kind: 'anyOf' | 'oneOf', node: any, ctx: Ctx, path: string): string {
-  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((schema: any, index: number) => emitSchema(schema, ctx, pathJoin(pathJoin(path, kind), index)));
-  return `z.union([${parts.join(', ')}])`;
-}
-
-function emitEnum(node: any, ctx: Ctx, path: string): string {
-  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((value: any) => `z.literal(${jsonString(value)})`);
-  return `z.union([${literals.join(', ')}])`;
-}
-
-function emitType(typeValue: any, node: any, ctx: Ctx, path: string): string {
-  const types = Array.isArray(typeValue) ? typeValue : [typeValue];
-  const expressions: string[] = [];
-
-  for (const typeName of types) {
-    if (typeName === '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') {
-        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).`);
-        }
-      }
-      expressions.push(s);
-    } else if (typeName === '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})`;
-      expressions.push(n);
-    } else if (typeName === '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})`;
-      expressions.push(n);
-    } else if (typeName === 'boolean') {
-      expressions.push('z.boolean()');
-    } else if (typeName === 'null') {
-      expressions.push('z.null()');
-    } else if (typeName === '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.');
-      }
-      expressions.push(a);
-    } else if (typeName === 'object') {
-      expressions.push(emitObject(node, ctx, path));
-    } else {
-      warn(ctx, pathJoin(path, 'type'), `Unsupported type '${String(typeName)}'; treating as z.any().`);
-      expressions.push('z.any()');
-    }
-  }
-
-  if (expressions.length === 1) {
-    const firstExpression = expressions[0];
-    if (firstExpression !== undefined) return firstExpression;
-  }
-  return `z.union([${expressions.join(', ')}])`;
-}
-
-function emitObject(node: any, ctx: Ctx, path: string): string {
-  if (isRecordLikeObjectSchema(node)) {
-    return emitRecordLikeObjectSchema(node, ctx, path);
-  }
-
-  const props: Record<string, any> = isObject(node.properties) ? node.properties : {};
-  const required = Array.isArray(node.required) ? new Set(node.required.filter((x: any) => typeof x === 'string')) : new Set<string>();
-
-  const propEntries: string[] = [];
-  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) {
-      out += '.passthrough()';
-    } else if (additional !== false) {
-      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)) {
-      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)) {
-    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: any, ctx: Ctx, path: string): string {
-  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);
-  }
-
-  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: Record<string, any>): Record<string, string> {
-  const map: Record<string, string> = {};
-  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 as any).valueSchema;
-    if (isObject(nested) && typeof nested.$anchor === 'string' && nested.$anchor) {
-      map[nested.$anchor] = defName;
-    }
-  }
-  return map;
-}
-
-function deepClone<T>(value: T): T {
-  if (Array.isArray(value)) return value.map((item) => deepClone(item)) as any;
-  if (isObject(value)) {
-    const out: Record<string, any> = {};
-    for (const key of Object.keys(value)) out[key] = deepClone((value as any)[key]);
-    return out as any;
-  }
-  return value;
-}
-
-function normalizeSchemaForEmitter(schema: any): any {
-  return normalizeAllOfSiblingObjectKeywords(schema);
-}
-
-export function jsonSchemaToZodExpressions(standaloneSchema: JsonSchema, rootName: string): JsonSchemaToZodResult {
-  const normalized = normalizeSchemaForEmitter(deepClone(standaloneSchema));
-  const defs: Record<string, any> = isObject(normalized?.$defs) ? normalized.$defs : {};
-  const defNames = new Set(Object.keys(defs));
-  const ctx: Ctx = {
-    defNames,
-    defsByName: defs,
-    anchorToDefName: buildAnchorMap(defs),
-    warnings: []
-  };
-
-  const expressionsByName: Record<string, string> = {};
-
-  for (const defName of Object.keys(defs)) {
-    expressionsByName[defName] = emitSchema(defs[defName], ctx, `$defs.${defName}`);
-  }
-
-  expressionsByName[rootName] = emitSchema(normalized, ctx, rootName);
-
-  return { expressionsByName, warnings: ctx.warnings };
+import { normalizeAllOfSiblingObjectKeywords } from './schemaObjectNormalization.js';
+
+export type JsonSchema = any;
+
+export type JsonSchemaToZodWarning = {
+  path: string;
+  message: string;
+};
+
+export type JsonSchemaToZodResult = {
+  expressionsByName: Record<string, string>;
+  warnings: JsonSchemaToZodWarning[];
+};
+
+type Ctx = {
+  defNames: Set<string>;
+  defsByName: Record<string, any>;
+  anchorToDefName: Record<string, string>;
+  warnings: JsonSchemaToZodWarning[];
+};
+
+function isObject(v: any): v is Record<string, any> {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function pathJoin(base: string, key: string | number): string {
+  if (!base) return String(key);
+  if (typeof key === 'number') return `${base}[${key}]`;
+  return `${base}.${key}`;
+}
+
+function warn(ctx: Ctx, path: string, message: string) {
+  ctx.warnings.push({ path, message });
+}
+
+function asDefSchemaRef(defName: string): string {
+  return `${defName}Schema`;
+}
+
+function extractPointerDefName(ref: string): string | null {
+  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 defName = parts[1];
+  if (defName === undefined) return null;
+  const name = defName.replace(/~1/g, '/').replace(/~0/g, '~');
+  return name;
+}
+
+function resolveLocalRef(ref: string, ctx: Ctx): string | null {
+  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: unknown): string {
+  return JSON.stringify(value);
+}
+
+function emitRegex(pattern: string): string {
+  return `new RegExp(${jsonString(pattern)})`;
+}
+
+function hasOwn(obj: any, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function isBooleanSchema(node: any): node is boolean {
+  return typeof node === 'boolean';
+}
+
+function isRecordLikeObjectSchema(node: any): boolean {
+  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 emitRecordLikeObjectSchema(node: any, ctx: Ctx, path: string): string {
+  const projectionSchemaNode = node.additionalProperties;
+  const valueExpr = emitSchema(projectionSchemaNode, ctx, pathJoin(path, 'additionalProperties'));
+
+  const pn = node.propertyNames;
+  let keyPattern: string | undefined;
+  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: string[] = [];
+  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: any, ctx: Ctx): any {
+  if (isObject(node) && typeof node.$ref === 'string') {
+    const defName = resolveLocalRef(node.$ref, ctx);
+    if (defName) return ctx.defsByName[defName];
+  }
+  return node;
+}
+
+function isDirectObjectishSchema(node: any): boolean {
+  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: any, ctx: Ctx, path: string, seen: Set<any>): any[] | null {
+  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 as any).allOf) && (resolved as any).allOf.length > 0) {
+    const out: any[] = [];
+    for (let i = 0; i < (resolved as any).allOf.length; i++) {
+      const child = (resolved as any).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: any, b: any): any {
+  if (a === undefined) return b;
+  if (b === undefined) return a;
+  return { allOf: [a, b] };
+}
+
+function mergeAllOfObjectSchemas(allOfSchemas: any[], ctx: Ctx, path: string): any | null {
+  const flattened: any[] = [];
+  const seen = new Set<any>();
+  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: any = { type: 'object', properties: {} as Record<string, any> };
+  const required = new Set<string>();
+  let additionalProperties: any = undefined;
+  let unevaluatedProperties: any = undefined;
+
+  for (let i = 0; i < flattened.length; i++) {
+    const schema = flattened[i];
+    const schemaPath = pathJoin(pathJoin(path, 'allOfFlattened'), i);
+    if (!isObject(schema)) continue;
+
+    if (isObject(schema.properties)) {
+      for (const [key, value] of Object.entries(schema.properties)) {
+        merged.properties[key] = mergePropertySchemas(merged.properties[key], value);
+      }
+    }
+
+    if (Array.isArray(schema.required)) {
+      for (const requiredKey of schema.required) if (typeof requiredKey === 'string') required.add(requiredKey);
+    }
+
+    if (hasOwn(schema, 'additionalProperties')) {
+      if (additionalProperties === undefined) {
+        additionalProperties = (schema as any).additionalProperties;
+      } else if (additionalProperties === false || (schema as any).additionalProperties === false) {
+        additionalProperties = false;
+      } else if (isObject(additionalProperties) && isObject((schema as any).additionalProperties)) {
+        additionalProperties = { allOf: [additionalProperties, (schema as any).additionalProperties] };
+      } else {
+        additionalProperties = isObject(additionalProperties)
+          ? additionalProperties
+          : (isObject((schema as any).additionalProperties) ? (schema as any).additionalProperties : true);
+      }
+    }
+
+    if ((schema as any).unevaluatedProperties === false) {
+      unevaluatedProperties = false;
+    } else if (hasOwn(schema, 'unevaluatedProperties')) {
+      warn(ctx, pathJoin(schemaPath, 'unevaluatedProperties'), 'Unsupported unevaluatedProperties value; ignoring.');
+    }
+
+    if (hasOwn(schema, 'propertyNames') && !hasOwn(merged, 'propertyNames')) merged.propertyNames = (schema as any).propertyNames;
+    if (hasOwn(schema, 'patternProperties') && !hasOwn(merged, 'patternProperties')) merged.patternProperties = (schema as any).patternProperties;
+    if (hasOwn(schema, 'dependentRequired') && !hasOwn(merged, 'dependentRequired')) merged.dependentRequired = (schema as any).dependentRequired;
+    if (hasOwn(schema, 'dependentSchemas') && !hasOwn(merged, 'dependentSchemas')) merged.dependentSchemas = (schema as any).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: any, ctx: Ctx, path: string): string {
+  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((schema: any, index: number) => emitSchema(schema, ctx, pathJoin(pathJoin(path, 'allOf'), index)));
+  const firstPart = parts[0];
+  if (firstPart === undefined) {
+    warn(ctx, pathJoin(path, 'allOf'), 'Expected non-empty allOf array; treating as z.any().');
+    return 'z.any()';
+  }
+  let out = firstPart;
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === undefined) continue;
+    out = `z.intersection(${out}, ${part})`;
+  }
+  return out;
+}
+
+function emitAnyOfUnion(kind: 'anyOf' | 'oneOf', node: any, ctx: Ctx, path: string): string {
+  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((schema: any, index: number) => emitSchema(schema, ctx, pathJoin(pathJoin(path, kind), index)));
+  return `z.union([${parts.join(', ')}])`;
+}
+
+function emitEnum(node: any, ctx: Ctx, path: string): string {
+  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((value: any) => `z.literal(${jsonString(value)})`);
+  return `z.union([${literals.join(', ')}])`;
+}
+
+function emitType(typeValue: any, node: any, ctx: Ctx, path: string): string {
+  const types = Array.isArray(typeValue) ? typeValue : [typeValue];
+  const expressions: string[] = [];
+
+  for (const typeName of types) {
+    if (typeName === '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') {
+        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).`);
+        }
+      }
+      expressions.push(s);
+    } else if (typeName === '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})`;
+      expressions.push(n);
+    } else if (typeName === '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})`;
+      expressions.push(n);
+    } else if (typeName === 'boolean') {
+      expressions.push('z.boolean()');
+    } else if (typeName === 'null') {
+      expressions.push('z.null()');
+    } else if (typeName === '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.');
+      }
+      expressions.push(a);
+    } else if (typeName === 'object') {
+      expressions.push(emitObject(node, ctx, path));
+    } else {
+      warn(ctx, pathJoin(path, 'type'), `Unsupported type '${String(typeName)}'; treating as z.any().`);
+      expressions.push('z.any()');
+    }
+  }
+
+  if (expressions.length === 1) {
+    const firstExpression = expressions[0];
+    if (firstExpression !== undefined) return firstExpression;
+  }
+  return `z.union([${expressions.join(', ')}])`;
+}
+
+function emitObject(node: any, ctx: Ctx, path: string): string {
+  if (isRecordLikeObjectSchema(node)) {
+    return emitRecordLikeObjectSchema(node, ctx, path);
+  }
+
+  const props: Record<string, any> = isObject(node.properties) ? node.properties : {};
+  const required = Array.isArray(node.required) ? new Set(node.required.filter((x: any) => typeof x === 'string')) : new Set<string>();
+
+  const propEntries: string[] = [];
+  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) {
+      out += '.passthrough()';
+    } else if (additional !== false) {
+      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)) {
+      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)) {
+    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: any, ctx: Ctx, path: string): string {
+  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);
+  }
+
+  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: Record<string, any>): Record<string, string> {
+  const map: Record<string, string> = {};
+  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 as any).projectionSchema;
+    if (isObject(nested) && typeof nested.$anchor === 'string' && nested.$anchor) {
+      map[nested.$anchor] = defName;
+    }
+  }
+  return map;
+}
+
+function deepClone<T>(value: T): T {
+  if (Array.isArray(value)) return value.map((item) => deepClone(item)) as any;
+  if (isObject(value)) {
+    const out: Record<string, any> = {};
+    for (const key of Object.keys(value)) out[key] = deepClone((value as any)[key]);
+    return out as any;
+  }
+  return value;
+}
+
+function normalizeSchemaForEmitter(schema: any): any {
+  return normalizeAllOfSiblingObjectKeywords(schema);
+}
+
+export function jsonSchemaToZodExpressions(standaloneSchema: JsonSchema, rootName: string): JsonSchemaToZodResult {
+  const normalized = normalizeSchemaForEmitter(deepClone(standaloneSchema));
+  const defs: Record<string, any> = isObject(normalized?.$defs) ? normalized.$defs : {};
+  const defNames = new Set(Object.keys(defs));
+  const ctx: Ctx = {
+    defNames,
+    defsByName: defs,
+    anchorToDefName: buildAnchorMap(defs),
+    warnings: []
+  };
+
+  const expressionsByName: Record<string, string> = {};
+
+  for (const defName of Object.keys(defs)) {
+    expressionsByName[defName] = emitSchema(defs[defName], ctx, `$defs.${defName}`);
+  }
+
+  expressionsByName[rootName] = emitSchema(normalized, ctx, rootName);
+
+  return { expressionsByName, warnings: ctx.warnings };
 }