schemantic 0.3.0 → 0.4.1

package/dist/plugins/zod-validation.js

@@ -18,15 +18,17 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.zodValidationPlugin = void 0;
+exports.buildZodSchema = buildZodSchema;
 exports.memoizedValidation = memoizedValidation;
 exports.getZodValidationPerformanceStats = getZodValidationPerformanceStats;
 exports.clearZodValidationCaches = clearZodValidationCaches;
 exports.getValidationCacheStats = getValidationCacheStats;
 const schema_1 = require("../types/schema");
+const schema_type_1 = require("../generators/schema-type");
 /**
  * Schema cache for performance optimization
  */
-const schemaCache = new Map();
+let schemaCaches = new WeakMap();
 /**
  * Memoized schema transformation for performance
  */
@@ -60,21 +62,20 @@ exports.zodValidationPlugin = {
         const startTime = performance.now();
         try {
             const options = getPluginOptions(context);
-            const schemaKey = generateSchemaKey(schema);
+            const sourceKey = generateSchemaKey(schema);
+            const schemaKey = sourceKey === undefined ? undefined : JSON.stringify(options) + sourceKey;
             // Use memoized transformation for performance
-            if (options.cacheSchemas && memoizedSchemaTransform.has(schemaKey)) {
+            if (options.cacheSchemas && schemaKey !== undefined && memoizedSchemaTransform.has(schemaKey)) {
                 return memoizedSchemaTransform.get(schemaKey);
             }
             const transformedSchema = transformSchemaForZod(schema, options);
-            if (options.cacheSchemas) {
+            if (options.cacheSchemas && schemaKey !== undefined) {
+                if (memoizedSchemaTransform.size >= 1000)
+                    memoizedSchemaTransform.delete(memoizedSchemaTransform.keys().next().value);
                 memoizedSchemaTransform.set(schemaKey, transformedSchema);
             }
             return transformedSchema;
         }
-        catch (error) {
-            console.warn(`Zod validation plugin transformSchema failed:`, error);
-            return schema;
-        }
         finally {
             const endTime = performance.now();
             recordPerformanceMetric("transformSchema", endTime - startTime);
@@ -113,7 +114,7 @@ exports.zodValidationPlugin = {
             generatedType.dependencies.push("zod");
             // Add branded type exports if enabled
             if (options.generateBrandedTypes) {
-                generatedType.exports.push(`Branded${typeName}`);
+                generatedType.exports.push(`Branded${typeName}`, `createBranded${typeName}`);
             }
             // Add validation exports
             generatedType.exports.push(`${typeName}Schema`, `validate${typeName}`, `parse${typeName}`);
@@ -121,9 +122,6 @@ exports.zodValidationPlugin = {
                 generatedType.exports.push(`is${typeName}`);
             }
         }
-        catch (error) {
-            console.warn(`Zod validation plugin afterTypeGeneration failed for ${typeName}:`, error);
-        }
         finally {
             const endTime = performance.now();
             recordPerformanceMetric("afterTypeGeneration", endTime - startTime);
@@ -136,8 +134,9 @@ exports.zodValidationPlugin = {
         const startTime = performance.now();
         try {
             const options = getPluginOptions(context);
+            const validationErrorName = chooseValidationErrorName(generatedClient, context);
             // Add validation middleware to client
-            const validationMiddleware = generateValidationMiddleware(generatedClient, context, options);
+            const validationMiddleware = generateValidationMiddleware(generatedClient, context, options, validationErrorName);
             // Add request/response validation helpers
             const validationHelpers = generateValidationHelpers(options);
             // Update client content with validation integration
@@ -171,10 +170,7 @@ exports.zodValidationPlugin = {
                 generatedClient.dependencies.push("zod");
             }
             // Add validation exports
-            generatedClient.exports.push("validateRequest", "validateResponse", "ValidationError");
-        }
-        catch (error) {
-            console.warn(`Zod validation plugin afterClientGeneration failed:`, error);
+            generatedClient.exports.push("validateRequest", "validateResponse", validationErrorName, "createValidationPipeline", "createLazyValidator");
         }
         finally {
             const endTime = performance.now();
@@ -186,7 +182,7 @@ exports.zodValidationPlugin = {
  * Get plugin options from generation context
  */
 function getPluginOptions(context) {
-    const pluginConfig = context.config.plugins?.find((p) => p.name === "zod-validation");
+    const pluginConfig = context.config.plugins?.find((p) => p.enabled && (p.name === "zod-validation" || p.name === "validation"));
     return {
         strictMode: true,
         cacheSchemas: true,
@@ -201,16 +197,29 @@ function getPluginOptions(context) {
  * Generate a unique key for schema caching
  */
 function generateSchemaKey(schema) {
-    return JSON.stringify(schema);
+    // Circular in-memory schema graphs have no JSON cache identity. Bypass caching
+    // instead of inventing a sentinel shared by unrelated recursive graphs.
+    try {
+        return JSON.stringify(schema);
+    }
+    catch (error) {
+        if (error instanceof TypeError && /circular/i.test(error.message))
+            return undefined;
+        throw error;
+    }
 }
 /**
  * Transform schema to include Zod validation metadata
  */
-function transformSchemaForZod(schema, options) {
+function transformSchemaForZod(schema, options, seen = new WeakMap()) {
     if (!(0, schema_1.isOpenAPISchemaObject)(schema)) {
         return schema;
     }
+    const existing = seen.get(schema);
+    if (existing)
+        return existing;
     const transformedSchema = { ...schema };
+    seen.set(schema, transformedSchema);
     // Add Zod validation metadata
     transformedSchema._zodValidation = {
         strictMode: options.strictMode,
@@ -220,9 +229,9 @@ function transformSchemaForZod(schema, options) {
     // Process properties recursively
     if (schema.properties) {
         transformedSchema.properties = {};
-        for (const [propName, propSchema] of Object.entries(schema.properties)) {
+        for (const [propName, propSchema] of Object.entries(schema.properties ?? {})) {
             if (typeof propSchema === "object" && propSchema !== null) {
-                transformedSchema.properties[propName] = transformSchemaForZod(propSchema, options);
+                transformedSchema.properties[propName] = transformSchemaForZod(propSchema, options, seen);
             }
             else {
                 transformedSchema.properties[propName] = propSchema;
@@ -235,13 +244,18 @@ function transformSchemaForZod(schema, options) {
  * Generate Zod schema for a type
  */
 async function generateZodSchema(typeName, schema, options, context) {
-    const cacheKey = `${typeName}-${generateSchemaKey(schema)}`;
-    if (options.cacheSchemas && schemaCache.has(cacheKey)) {
-        return schemaCache.get(cacheKey);
-    }
+    const sourceKey = generateSchemaKey(schema);
+    const cacheKey = sourceKey === undefined ? undefined : JSON.stringify([typeName, context?.config.typePrefix, context?.config.typeSuffix, options, sourceKey]);
+    let cache = context ? schemaCaches.get(context) : undefined;
+    if (context && !cache) {
+        cache = new Map();
+        schemaCaches.set(context, cache);
+    }
+    if (options.cacheSchemas && cacheKey !== undefined && cache?.has(cacheKey))
+        return cache.get(cacheKey);
     const zodSchema = buildZodSchema(schema, options, 0, context);
-    if (options.cacheSchemas) {
-        schemaCache.set(cacheKey, zodSchema);
+    if (options.cacheSchemas && cacheKey !== undefined) {
+        cache?.set(cacheKey, zodSchema);
     }
     return zodSchema;
 }
@@ -249,62 +263,153 @@ async function generateZodSchema(typeName, schema, options, context) {
  * Build Zod schema from OpenAPI schema
  */
 function buildZodSchema(schema, options, depth = 0, context) {
-    // Handle oneOf/discriminated unions early
-    if ((0, schema_1.isOpenAPISchemaObject)(schema)) {
-        const obj = schema;
-        if (Array.isArray(obj.oneOf) && obj.oneOf.length > 0) {
-            return buildOneOfSchema(obj, options, context);
+    if (depth > 30)
+        return "z.unknown()";
+    if (typeof schema === "object" && schema !== null && "$ref" in schema && schema.$ref) {
+        const ref = schema.$ref;
+        const siblings = Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "$ref" && !key.startsWith("_") && !["description", "title", "deprecated", "example"].includes(key)));
+        const nullable = siblings.nullable === true;
+        delete siblings.nullable;
+        const resolved = context?.schemaResolver?.(ref);
+        let referenceSchema;
+        if (Object.keys(siblings).length && resolved) {
+            const inheritedType = (0, schema_1.isOpenAPISchemaObject)(resolved) && ["string", "number", "integer", "array", "boolean"].includes(String(resolved.type)) ? { type: resolved.type } : {};
+            referenceSchema = `z.intersection(${buildZodSchema(resolved, { ...options, strictMode: false }, depth + 1, context)}, ${buildZodSchema({ ...inheritedType, ...siblings }, { ...options, strictMode: false }, depth + 1, context)})`;
         }
+        else if (/^#\/components\/schemas\/[^/]+$/.test(ref)) {
+            referenceSchema = `z.lazy(() => ${formatTypeNameWithContext((0, schema_type_1.referenceName)(ref), context)}Schema)`;
+        }
+        else {
+            referenceSchema = resolved ? buildZodSchema(resolved, options, depth + 1, context) : "z.unknown()";
+        }
+        return nullable ? `${referenceSchema}.nullable()` : referenceSchema;
     }
-    // Handle schema references first
-    if (typeof schema === "object" &&
-        schema !== null &&
-        "$ref" in schema &&
-        schema.$ref) {
-        // Extract type name from reference and generate schema reference
-        const refPath = schema.$ref;
-        const typeName = refPath.split("/").pop();
-        // Try to resolve and inline if it's a union (oneOf)
-        if (context?.schemaResolver) {
-            const resolved = context.schemaResolver(refPath);
-            if (resolved && (0, schema_1.isOpenAPISchemaObject)(resolved)) {
-                const obj = resolved;
-                if (Array.isArray(obj.oneOf) && obj.oneOf.length > 0) {
-                    return buildOneOfSchema(obj, options, context);
+    if (!(0, schema_1.isOpenAPISchemaObject)(schema))
+        return "z.unknown()";
+    if (schema["x-schemantic-binary"] === true)
+        return "z.instanceof(globalThis.Blob)";
+    const build = (part) => buildZodSchema(part, options, depth + 1, context);
+    let result;
+    if (schema.enum?.length) {
+        const literals = schema.enum.map(value => `z.literal(${JSON.stringify(value)})`);
+        const literalSchema = literals.length === 1 ? literals[0] : `z.union([${literals.join(", ")}])`;
+        const own = { ...schema };
+        delete own.enum;
+        result = `z.intersection(${literalSchema}, ${build(own)})`;
+    }
+    else if (schema.const !== undefined) {
+        const own = { ...schema };
+        delete own.const;
+        result = `z.intersection(z.literal(${JSON.stringify(schema.const)}), ${build(own)})`;
+    }
+    else if (schema.oneOf?.length || schema.anyOf?.length || schema.allOf?.length) {
+        // A composition and its sibling constraints apply together. Implicit strict
+        // mode must not reject fields contributed by another intersected schema;
+        // explicit additionalProperties:false still applies within each branch.
+        const compositionOptions = { ...options, strictMode: false };
+        const hasSiblingFields = !!schema.properties || !!schema.required?.length || schema.additionalProperties !== undefined;
+        const compositionCount = [schema.oneOf, schema.anyOf, schema.allOf].filter(parts => parts?.length).length;
+        const intersectsFields = hasSiblingFields || compositionCount > 1;
+        const unionOptions = intersectsFields ? compositionOptions : options;
+        const buildPart = (part, partOptions = compositionOptions, inlineReference = true) => {
+            if (typeof part === "object" && part !== null && "$ref" in part && typeof part.$ref === "string") {
+                const resolved = context?.schemaResolver?.(part.$ref);
+                if (resolved && inlineReference) {
+                    const siblings = { ...part };
+                    delete siblings.$ref;
+                    const nullable = siblings.nullable === true;
+                    delete siblings.nullable;
+                    // Retain the entire reference expression instead of substituting only
+                    // its target and losing minLength/properties/required beside $ref.
+                    return buildZodSchema({ allOf: [resolved, siblings], ...(nullable ? { nullable: true } : {}) }, partOptions, depth + 1, context);
                 }
             }
+            return buildZodSchema(part, partOptions, depth + 1, context);
+        };
+        const parts = [];
+        if (schema.oneOf?.length) {
+            const variants = schema.oneOf.map(part => buildPart(part, unionOptions, intersectsFields));
+            const union = variants.length === 1 ? variants[0] : `z.union([${variants.join(", ")}])`;
+            parts.push(`${union}.refine((value: unknown) => [${variants.join(", ")}].filter(variant => variant.safeParse(value).success).length === 1, { message: "Expected exactly one matching schema" })`);
+        }
+        if (schema.anyOf?.length) {
+            const variants = schema.anyOf.map(part => buildPart(part, unionOptions, intersectsFields));
+            parts.push(variants.length === 1 ? variants[0] : `z.union([${variants.join(", ")}])`);
         }
-        if (typeName) {
-            const formattedTypeName = formatTypeNameWithContext(typeName, context);
-            return `${formattedTypeName}Schema`;
+        if (schema.allOf?.length)
+            parts.push(...schema.allOf.map(part => buildPart(part)));
+        const own = { ...schema };
+        delete own.oneOf;
+        delete own.anyOf;
+        delete own.allOf;
+        delete own.nullable;
+        delete own.not;
+        const siblingValidator = buildZodSchema(own, compositionOptions, depth + 1, context);
+        if (siblingValidator !== "z.unknown()")
+            parts.push(siblingValidator);
+        result = parts.reduce((left, right) => `z.intersection(${left}, ${right})`);
+    }
+    else if (Array.isArray(schema.type)) {
+        const parts = schema.type.map(type => build({ ...schema, type, nullable: false }));
+        result = parts.length === 1 ? parts[0] : `z.union([${parts.join(", ")}])`;
+    }
+    else {
+        switch (schema.type) {
+            case "string":
+                result = buildStringSchema(schema, options);
+                break;
+            case "number":
+            case "integer":
+                result = buildNumberSchema(schema, options);
+                break;
+            case "boolean":
+                result = "z.boolean()";
+                break;
+            case "null":
+                result = "z.null()";
+                break;
+            case "array":
+                result = `z.array(${schema.items ? build(schema.items) : "z.unknown()"})`;
+                if (schema.minItems !== undefined)
+                    result += `.min(${schema.minItems})`;
+                if (schema.maxItems !== undefined)
+                    result += `.max(${schema.maxItems})`;
+                if (schema.uniqueItems)
+                    result += `.refine((items: unknown[]) => items.every((item, index) => items.findIndex(other => { const canonical = (value: unknown): string => Array.isArray(value) ? '[' + value.map(canonical).join(',') + ']' : value !== null && typeof value === 'object' ? '{' + Object.keys(value).sort().map(key => JSON.stringify(key) + ':' + canonical((value as Record<string, unknown>)[key])).join(',') + '}' : JSON.stringify(value) ?? 'undefined'; return canonical(other) === canonical(item); }) === index), { message: "Array items must be unique" })`;
+                break;
+            case "object":
+                result = buildObjectSchema(schema, options, depth, context);
+                break;
+            default: result = schema.properties || schema.required || schema.additionalProperties !== undefined
+                ? buildObjectSchema(schema, options, depth, context) : buildUntypedConstraintSchema(schema, options, depth, context);
         }
     }
-    if (!(0, schema_1.isOpenAPISchemaObject)(schema)) {
-        return "z.unknown()";
+    if (schema.not)
+        result += `.refine((value: unknown) => !(${build(schema.not)}).safeParse(value).success, { message: "Value matches prohibited schema" })`;
+    return schema.nullable ? `${result}.nullable()` : result;
+}
+/** Validate applicable keywords even when a sibling schema does not declare type. */
+function buildUntypedConstraintSchema(schema, options, depth, context) {
+    let result = "z.unknown()";
+    const check = (applies, validator) => {
+        result += `.refine((value: unknown) => !(${applies}) || (${validator}).safeParse(value).success)`;
+    };
+    if (schema.minLength !== undefined || schema.maxLength !== undefined || schema.pattern || schema.format) {
+        check("typeof value === 'string'", buildStringSchema({ ...schema, type: "string" }, options));
     }
-    // Prevent infinite recursion
-    if (depth > 10) {
-        return "z.unknown()";
+    if (schema.minimum !== undefined || schema.maximum !== undefined || schema.exclusiveMinimum !== undefined || schema.exclusiveMaximum !== undefined || schema.multipleOf !== undefined) {
+        check("typeof value === 'number'", buildNumberSchema({ ...schema, type: "number" }, options));
     }
-    switch (schema.type) {
-        case "string":
-            return buildStringSchema(schema, options);
-        case "number":
-        case "integer":
-            return buildNumberSchema(schema, options);
-        case "boolean":
-            return "z.boolean()";
-        case "array": {
-            const itemSchema = schema.items
-                ? buildZodSchema(schema.items, options, depth + 1, context)
-                : "z.unknown()";
-            return `z.array(${itemSchema})`;
-        }
-        case "object":
-            return buildObjectSchema(schema, options, depth, context);
-        default:
-            return "z.unknown()";
+    if (schema.minProperties !== undefined || schema.maxProperties !== undefined) {
+        check("typeof value === 'object' && value !== null && !Array.isArray(value)", appendObjectPropertyConstraints("z.record(z.string(), z.unknown())", schema));
+    }
+    if (schema.items || schema.minItems !== undefined || schema.maxItems !== undefined || schema.uniqueItems) {
+        const arraySchema = { ...schema, type: "array" };
+        delete arraySchema.not;
+        delete arraySchema.nullable;
+        check("Array.isArray(value)", buildZodSchema(arraySchema, options, depth + 1, context));
     }
+    return result;
 }
 /**
  * Helper function to format type names consistently
@@ -314,13 +419,7 @@ function buildZodSchema(schema, options, depth = 0, context) {
  * Format a type name using optional generation context to apply prefix/suffix.
  */
 function formatTypeNameWithContext(name, context) {
-    const tokens = name.split(/[-_\s]+/).filter(Boolean);
-    const pascalCase = tokens
-        .map((word) => (word ? word.charAt(0).toUpperCase() + word.slice(1) : ""))
-        .join("");
-    const prefix = context?.config?.typePrefix ?? "";
-    const suffix = context?.config?.typeSuffix ?? "";
-    return `${prefix || ""}${pascalCase}${suffix || ""}`;
+    return (0, schema_type_1.typeName)(name, context?.config.typePrefix, context?.config.typeSuffix);
 }
 /**
  * Build Zod string schema with validation rules
@@ -334,7 +433,7 @@ function buildStringSchema(schema, _options) {
         zodSchema += `.max(${schema.maxLength})`;
     }
     if (schema.pattern) {
-        zodSchema += `.regex(/${schema.pattern}/)`;
+        zodSchema += `.regex(new RegExp(${JSON.stringify(schema.pattern)}))`;
     }
     if (schema.format) {
         switch (schema.format) {
@@ -368,7 +467,7 @@ function buildStringSchema(schema, _options) {
     if (_options.customErrorMessages && schema.description) {
         const customMessage = _options.customErrorMessages[schema.description];
         if (customMessage) {
-            zodSchema += `.describe("${customMessage}")`;
+            zodSchema += `.describe(${JSON.stringify(customMessage)})`;
         }
     }
     return zodSchema;
@@ -384,6 +483,16 @@ function buildNumberSchema(schema, _options) {
     if (schema.maximum !== undefined) {
         zodSchema += `.max(${schema.maximum})`;
     }
+    if (schema.exclusiveMinimum !== undefined) {
+        const bound = typeof schema.exclusiveMinimum === "number" ? schema.exclusiveMinimum : schema.exclusiveMinimum ? schema.minimum : undefined;
+        if (bound !== undefined)
+            zodSchema += `.gt(${bound})`;
+    }
+    if (schema.exclusiveMaximum !== undefined) {
+        const bound = typeof schema.exclusiveMaximum === "number" ? schema.exclusiveMaximum : schema.exclusiveMaximum ? schema.maximum : undefined;
+        if (bound !== undefined)
+            zodSchema += `.lt(${bound})`;
+    }
     if (schema.multipleOf !== undefined) {
         zodSchema += `.multipleOf(${schema.multipleOf})`;
     }
@@ -393,161 +502,156 @@ function buildNumberSchema(schema, _options) {
  * Build Zod object schema
  */
 function buildObjectSchema(schema, options, depth, context) {
-    if (!schema.properties) {
-        return "z.object({})";
+    if (!schema.properties && !schema.required?.length) {
+        const values = typeof schema.additionalProperties === "object"
+            ? buildZodSchema(schema.additionalProperties, options, depth + 1, context) : "z.unknown()";
+        const base = schema.additionalProperties === false ? "z.object({}).strict()" : `z.record(z.string(), ${values})`;
+        return appendObjectPropertyConstraints(base, schema);
     }
     const properties = [];
     const required = schema.required || [];
-    const transformPairs = [];
-    const wantsCamel = context?.config?.namingConvention === "camelCase";
-    // Helper: convert prop name to camelCase similar to generator
-    const toCamel = (str) => {
-        if (!str)
-            return str;
-        // sanitize: collapse non-alnum into underscore, trim
-        const sanitized = str
-            .replace(/[^A-Za-z0-9]+/g, "_")
-            .replace(/^_+|_+$/g, "")
-            .replace(/_+/g, "_");
-        const parts = sanitized.split(/_+/).filter(Boolean);
-        if (parts.length === 0)
-            return "";
-        const head = parts[0] ?? "";
-        const tail = parts.slice(1);
-        const camelHead = head ? head.charAt(0).toLowerCase() + head.slice(1) : "";
-        const camelTail = tail.map((p) => p ? p.charAt(0).toUpperCase() + p.slice(1) : "");
-        return camelHead + camelTail.join("");
-    };
-    for (const [propName, propSchema] of Object.entries(schema.properties)) {
+    for (const [propName, propSchema] of Object.entries(schema.properties ?? {})) {
         if (typeof propSchema === "object" && propSchema !== null) {
             let propZodSchema = buildZodSchema(propSchema, options, depth + 1, context);
             if (!required.includes(propName)) {
                 propZodSchema += ".optional()";
             }
-            properties.push(`  ${propName}: ${propZodSchema}`);
-            if (wantsCamel) {
-                const camel = toCamel(propName);
-                if (camel !== propName) {
-                    transformPairs.push(`  ${camel}: val[${JSON.stringify(propName)}]`);
-                }
-            }
+            properties.push(`  ${(0, schema_type_1.propertyKey)(propName)}: ${propZodSchema}`);
         }
     }
-    const strictMode = options.strictMode ? ".strict()" : "";
+    for (const name of required)
+        if (!schema.properties?.[name])
+            properties.push(`  ${(0, schema_type_1.propertyKey)(name)}: z.unknown().refine((value: unknown) => value !== undefined, { message: "Required property" })`);
+    const strictMode = schema.additionalProperties === true ? ".passthrough()"
+        : typeof schema.additionalProperties === "object" ? `.catchall(${buildZodSchema(schema.additionalProperties, options, depth + 1, context)})`
+            : options.strictMode || schema.additionalProperties === false ? ".strict()" : ".passthrough()";
     const base = `z.object({\n${properties.join(",\n")}\n})${strictMode}`;
-    if (wantsCamel && transformPairs.length > 0) {
-        // Type the transform parameter to avoid implicit any in generated code
-        return `${base}.transform((val: Record<string, unknown>) => ({\n${transformPairs.join(",\n")}\n}))`;
-    }
-    // Default: return the base schema when no transform is required
-    return base;
+    return appendObjectPropertyConstraints(base, schema);
+}
+function appendObjectPropertyConstraints(base, schema) {
+    // Zod intersections may reconcile strict-object unrecognized-key issues against
+    // sibling schemas. OpenAPI's explicit additionalProperties:false applies to
+    // this schema's own declared properties, so check the original input first.
+    const allowedKeys = JSON.stringify(Object.keys(schema.properties ?? {}));
+    let result = schema.additionalProperties === false
+        ? `z.unknown().refine((value: unknown) => value === null || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).every(key => ${allowedKeys}.includes(key)), { message: "Unexpected object property" }).pipe(${base})`
+        : base;
+    if (schema.minProperties !== undefined)
+        result += `.refine((value: Record<string, unknown>) => Object.keys(value).length >= ${schema.minProperties}, { message: "Too few properties" })`;
+    if (schema.maxProperties !== undefined)
+        result += `.refine((value: Record<string, unknown>) => Object.keys(value).length <= ${schema.maxProperties}, { message: "Too many properties" })`;
+    return result;
 }
 /**
  * Build Zod union/discriminatedUnion schema for oneOf
  */
-function buildOneOfSchema(schema, options, context) {
-    const variants = (schema.oneOf || []).map((variant) => {
-        if (typeof variant === "object" &&
-            variant !== null &&
-            "$ref" in variant) {
-            const refPath = variant["$ref"];
-            const name = refPath.split("/").pop() || "Unknown";
-            return `${formatTypeNameWithContext(name, context)}Schema`;
-        }
-        return buildZodSchema(variant, options, 0, context);
-    });
-    const discriminator = schema.discriminator?.propertyName;
-    if (discriminator) {
-        return `z.discriminatedUnion(${JSON.stringify(discriminator)}, [${variants.join(", ")}])`;
-    }
-    return `z.union([${variants.join(", ")}])`;
-}
 /**
  * Generate branded type for compile-time safety
  */
 function generateBrandedType(typeName, _generatedType) {
-    return `
-/**
- * Branded type for ${typeName} with compile-time guarantees
- */
-export type Branded${typeName} = ${typeName} & { __brand: '${typeName}' };
-
-/**
- * Create a branded ${typeName} instance
- */
-export function createBranded${typeName}(data: ${typeName}): Branded${typeName} {
-  return data as Branded${typeName};
+    return `
+/**
+ * Branded type for ${typeName} with compile-time guarantees
+ */
+export type Branded${typeName} = ${typeName} & { __brand: '${typeName}' };
+
+/**
+ * Create a branded ${typeName} instance
+ */
+export function createBranded${typeName}(data: ${typeName}): Branded${typeName} {
+  return data as Branded${typeName};
 }`;
 }
 /**
  * Generate runtime type guard
  */
 function generateTypeGuard(typeName, _zodSchema) {
-    return `
-/**
- * Runtime type guard for ${typeName}
- */
-export function is${typeName}(value: unknown): value is ${typeName} {
-  return ${typeName}Schema.safeParse(value).success;
+    return `
+/**
+ * Runtime type guard for ${typeName}
+ */
+export function is${typeName}(value: unknown): value is ${typeName} {
+  return ${typeName}Schema.safeParse(value).success;
 }`;
 }
 /**
  * Generate Zod imports based on options
  */
-function generateZodImports(options) {
+function generateZodImports(_options) {
     const imports = ["z"];
-    if (options.generateBrandedTypes) {
-        imports.push("ZodType");
-    }
     return `import { ${imports.join(", ")} } from 'zod';`;
 }
 /**
  * Generate validation module for a type
  */
 function generateValidationModule(typeName, zodSchema, brandedType, typeGuard, _options) {
-    return `
-/**
- * Zod validation schema for ${typeName}
- */
-export const ${typeName}Schema = ${zodSchema};
-
-/**
- * Validate ${typeName} data with detailed error reporting
- */
-export function validate${typeName}(data: unknown): { success: true; data: ${typeName} } | { success: false; errors: string[] } {
-  const result = ${typeName}Schema.safeParse(data);
-
-  if (!result.success) {
-    const issues = result.error?.issues ?? [];
-    console.warn('Response validation failed:', issues);
-    // Return a structured failure result so consumers can handle errors without requiring a runtime ValidationError class
-    return {
-      success: false,
-      errors: issues.length > 0
-        ? issues.map((iss: z.core.$ZodIssue) => (iss.path && iss.path.length > 0 ? iss.path.join('.') + ': ' + iss.message : '(root): ' + iss.message))
-        : []
-    };
-  }
-
-  return { success: true, data: result.data as ${typeName} };
-}
-
-/**
- * Parse ${typeName} data with exception on validation failure
- */
-export function parse${typeName}(data: unknown): ${typeName} {
-  return ${typeName}Schema.parse(data) as ${typeName};
-}
+    return `
+/**
+ * Zod validation schema for ${typeName}
+ */
+export const ${typeName}Schema: z.ZodType = ${zodSchema};
+
+/**
+ * Validate ${typeName} data with detailed error reporting
+ */
+export function validate${typeName}(data: unknown): { success: true; data: ${typeName} } | { success: false; errors: string[] } {
+  const result = ${typeName}Schema.safeParse(data);
+
+  if (!result.success) {
+    const issues = result.error?.issues ?? [];
+    console.warn('Response validation failed:', issues);
+    // Return a structured failure result so consumers can handle errors without requiring a runtime ValidationError class
+    return {
+      success: false,
+      errors: issues.length > 0
+        ? issues.map((iss: z.core.$ZodIssue) => (iss.path && iss.path.length > 0 ? iss.path.join('.') + ': ' + iss.message : '(root): ' + iss.message))
+        : []
+    };
+  }
+
+  return { success: true, data: result.data as ${typeName} };
+}
+
+/**
+ * Parse ${typeName} data with exception on validation failure
+ */
+export function parse${typeName}(data: unknown): ${typeName} {
+  return ${typeName}Schema.parse(data) as ${typeName};
+}
 ${brandedType}${typeGuard}`;
 }
+/** Runtime helper names must be distinct across type/client exports and imported bindings. */
+function chooseValidationErrorName(client, context) {
+    const claimed = new Set(client.exports);
+    for (const type of context.generatedTypes.values()) {
+        claimed.add(type.name);
+        for (const name of type.exports)
+            claimed.add(name);
+    }
+    for (const generatedClient of context.generatedClients.values()) {
+        claimed.add(generatedClient.name);
+        for (const name of generatedClient.exports)
+            claimed.add(name);
+    }
+    // Cover imported aliases and local bindings supplied by custom client generators.
+    for (const identifier of client.content.match(/\b[A-Za-z_$][\w$]*\b/g) ?? [])
+        claimed.add(identifier);
+    if (!claimed.has("ValidationError"))
+        return "ValidationError";
+    let name = "ResponseValidationError";
+    let suffix = 0;
+    while (claimed.has(name))
+        name = `ResponseValidationError${++suffix}`;
+    return name;
+}
 /**
  * Generate validation middleware for API client
  */
-function generateValidationMiddleware(_generatedClient, _context, options) {
+function generateValidationMiddleware(_generatedClient, _context, options, errorName) {
     // Ensure z/ZodType import is present in client content
     if (!_generatedClient.content.includes("from 'zod'")) {
         _generatedClient.content =
-            `import { z, ZodType } from 'zod';\n` + _generatedClient.content;
+            `import { z } from 'zod';\nimport type { ZodType } from 'zod';\n` + _generatedClient.content;
     }
     else if (!_generatedClient.content.includes("ZodType")) {
         // Append ZodType to existing import if only z is imported
@@ -562,83 +666,85 @@ function generateValidationMiddleware(_generatedClient, _context, options) {
         });
     }
     const strictModeCode = options.strictMode
-        ? "throw new ValidationError(result.error?.issues ?? [], data);"
-        : "// In non-strict mode, return data as-is";
-    return `
-/**
- * Validation middleware for API requests and responses
- */
-export class ValidationError extends Error {
-  public issues: readonly z.core.$ZodIssue[];
-  constructor(issues: readonly z.core.$ZodIssue[], public data: unknown) {
-    const message = issues
-      .map((iss) => (iss.path && iss.path.length > 0 ? iss.path.join('.') + ': ' + iss.message : '(root): ' + iss.message))
-      .join('; ');
-    super('Validation failed: ' + message);
-    this.name = 'ValidationError';
-    this.issues = issues;
-    Object.setPrototypeOf(this, ValidationError.prototype);
-  }
-}
-
-/**
- * Validate request data before sending
- */
-export function validateRequest<T>(data: unknown, schema: ZodType<T>): T {
-  const result = schema.safeParse(data);
-
-  if (!result.success) {
-    const issues = result.error?.issues ?? [];
-    // Use Zod v4 core issue type
-    throw new ValidationError(issues as readonly z.core.$ZodIssue[], data);
-  }
-
-  return result.data;
-}
-
-/**
- * Validate response data after receiving
- */
-export function validateResponse<T>(data: unknown, schema: ZodType<T>): T {
-  const result = schema.safeParse(data);
-
-  if (!result.success) {
-    const issues = result.error?.issues ?? [];
-    console.warn('Response validation failed:', issues);
-    ${strictModeCode}
-  }
-
-  return result.data;
+        ? `throw new ${errorName}(result.error?.issues ?? [], data);`
+        : "return data as T;";
+    return `
+/**
+ * Validation middleware for API requests and responses
+ */
+export class ${errorName} extends Error {
+  public issues: readonly z.core.$ZodIssue[];
+  public data: unknown;
+  constructor(issues: readonly z.core.$ZodIssue[], data: unknown) {
+    const message = issues
+      .map((iss) => (iss.path && iss.path.length > 0 ? iss.path.join('.') + ': ' + iss.message : '(root): ' + iss.message))
+      .join('; ');
+    super('Validation failed: ' + message);
+    this.name = '${errorName}';
+    this.issues = issues;
+    this.data = data;
+    Object.setPrototypeOf(this, ${errorName}.prototype);
+  }
+}
+
+/**
+ * Validate request data before sending
+ */
+export function validateRequest<T>(data: unknown, schema: ZodType<T>): T {
+  const result = schema.safeParse(data);
+
+  if (!result.success) {
+    const issues = result.error?.issues ?? [];
+    // Use Zod v4 core issue type
+    throw new ${errorName}(issues as readonly z.core.$ZodIssue[], data);
+  }
+
+  return result.data;
+}
+
+/**
+ * Validate response data after receiving
+ */
+export function validateResponse<T>(data: unknown, schema: ZodType<T>): T {
+  const result = schema.safeParse(data);
+
+  if (!result.success) {
+    const issues = result.error?.issues ?? [];
+    console.warn('Response validation failed:', issues);
+    ${strictModeCode}
+  }
+
+  return result.data;
 }`;
 }
 /**
  * Generate validation helper functions
  */
 function generateValidationHelpers(_options) {
-    return `
-/**
- * Utility functions for validation operations
- */
-
-/**
- * Create a validation pipeline for multiple schemas
- */
-export function createValidationPipeline<T>(...schemas: ZodType<unknown>[]): ZodType<T> {
-  return schemas.reduce((acc, schema) => acc.pipe(schema)) as ZodType<T>;
-}
-
-/**
- * Lazy validation for performance optimization
- */
-export function createLazyValidator<T>(schemaFactory: () => ZodType<T>) {
-  let schema: ZodType<T> | null = null;
-  
-  return (data: unknown): T => {
-    if (!schema) {
-      schema = schemaFactory();
-    }
-    return schema.parse(data);
-  };
+    return `
+/**
+ * Utility functions for validation operations
+ */
+
+/**
+ * Create a validation pipeline for multiple schemas
+ */
+export function createValidationPipeline<T>(...schemas: ZodType<unknown>[]): ZodType<T> {
+  return schemas.reduce((acc, schema) => acc.pipe(schema)) as ZodType<T>;
+}
+
+/**
+ * Lazy validation for performance optimization
+ */
+export function createLazyValidator<T>(schemaFactory: () => ZodType<T>) {
+  let schema: ZodType<T> | null = null;
+  
+  return (data: unknown): T => {
+    if (!schema) {
+      schema = schemaFactory();
+    }
+    return schema.parse(data);
+  };
 }`;
 }
 /**
@@ -720,16 +826,34 @@ class BoundedValidationCache {
     }
 }
 const validationCache = new BoundedValidationCache();
+const validationSchemaIds = new WeakMap();
+let nextValidationSchemaId = 0;
 function memoizedValidation(data, schema, cacheKey, schemaVersion = "1.0") {
-    if (!cacheKey) {
+    // Cache primitive inputs/results only. Caller-owned objects and stateful references
+    // must be validated on every call rather than reusing mutable results.
+    if (!cacheKey || (data !== null && typeof data === "object") || typeof data === "function" || typeof data === "symbol") {
+        return schema.parse(data);
+    }
+    let schemaId = validationSchemaIds.get(schema);
+    if (schemaId === undefined) {
+        schemaId = ++nextValidationSchemaId;
+        validationSchemaIds.set(schema, schemaId);
+    }
+    let identity;
+    try {
+        identity = JSON.stringify([cacheKey, schemaId, schemaVersion, typeof data, typeof data === "number" && Object.is(data, -0) ? "-0" : String(data)]);
+    }
+    catch {
         return schema.parse(data);
     }
-    const cached = validationCache.get(cacheKey);
+    const cached = validationCache.get(identity);
     if (cached && cached.schemaVersion === schemaVersion) {
         return cached.result;
     }
     const result = schema.parse(data);
-    validationCache.set(cacheKey, {
+    if ((result !== null && typeof result === "object") || typeof result === "function" || typeof result === "symbol")
+        return result;
+    validationCache.set(identity, {
         result,
         timestamp: Date.now(),
         schemaVersion,
@@ -757,7 +881,7 @@ function getZodValidationPerformanceStats() {
  * Clear performance metrics and caches
  */
 function clearZodValidationCaches() {
-    schemaCache.clear();
+    schemaCaches = new WeakMap();
     memoizedSchemaTransform.clear();
     performanceMetrics.clear();
     validationCache.clear();