@amritk/generate-parsers 0.16.3 → 0.17.1

package/dist/generators/generate-parser-function.js

@@ -1,1340 +1,909 @@
-import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
-import { quoteJsString } from '@amritk/helpers/quote-js-string';
-import { refToName } from '@amritk/helpers/ref-to-name';
-import { resolveRef } from '@amritk/helpers/resolve-ref';
-import { safeAccessor, safeKey } from '@amritk/helpers/safe-accessor';
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasItems, hasOneOf, hasProperties, hasRef, hasRequired, hasType, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
-import { unknownKeyCheck } from '@amritk/helpers/unknown-key-check';
-import { findDiscriminator } from '../helpers/find-discriminator.js';
-import { getDefaultValue } from '../helpers/get-default-value.js';
-import { getDiscriminatorValue } from '../helpers/get-discriminator-value.js';
-import { assertNoUnsupportedKeywords } from './assert-supported-keywords.js';
-import { generateEnumCaseInsensitiveCoercion } from './generate-enum-check.js';
-import { generateContainsCheck, generateObjectKeywordChecks, generateObjectStrictAssertion, generateScalarStrictAssertion, } from './generate-strict-assertion.js';
-import { canEnforceUnion, generatePropertyTypeCheck, generateUnionCheck, getUnionBranches, hasFastPathBlockingKeyword, isInlineObjectArrayProperty, isInlineObjectProperty, shapeValidatorName, } from './generate-type-checks.js';
-import { generatePrefixItemsMap, generateValidationExpression, getPrefixItems, isCoercibleItemSchema, prefixItemsCapsLength, } from './generate-validation-expression.js';
-/**
- * Generates the parser function name from a type name.
- * Converts "UserObject" to "parseUserObject".
- */
+import { escapeRegexPattern } from "@amritk/helpers/escape-regex-pattern";
+import { quoteJsString } from "@amritk/helpers/quote-js-string";
+import { refToName } from "@amritk/helpers/ref-to-name";
+import { resolveRef } from "@amritk/helpers/resolve-ref";
+import { safeAccessor, safeKey } from "@amritk/helpers/safe-accessor";
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasItems, hasOneOf, hasProperties, hasRef, hasRequired, hasType, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { unknownKeyCheck } from "@amritk/helpers/unknown-key-check";
+import { findDiscriminator } from "../helpers/find-discriminator.js";
+import { getDefaultValue } from "../helpers/get-default-value.js";
+import { getDiscriminatorValue } from "../helpers/get-discriminator-value.js";
+import { assertNoUnsupportedKeywords } from "./assert-supported-keywords.js";
+import { generateEnumCaseInsensitiveCoercion } from "./generate-enum-check.js";
+import { generateContainsCheck, generateObjectKeywordChecks, generateObjectStrictAssertion, generateScalarStrictAssertion } from "./generate-strict-assertion.js";
+import { canEnforceUnion, generatePropertyTypeCheck, generateUnionCheck, getUnionBranches, hasFastPathBlockingKeyword, isInlineObjectArrayProperty, isInlineObjectProperty, shapeValidatorName } from "./generate-type-checks.js";
+import { generatePrefixItemsMap, generateValidationExpression, getPrefixItems, isCoercibleItemSchema, prefixItemsCapsLength } from "./generate-validation-expression.js";
 const generateParserName = (typeName) => {
-    return `parse${typeName}`;
+  return `parse${typeName}`;
 };
-/**
- * Object-literal key form that is safe for the runtime-dangerous name
- * `__proto__`. In an object literal `{ __proto__: v }` / `{ "__proto__": v }` is
- * the special prototype-setter syntax — it never creates an own property — so a
- * schema property literally named `__proto__` would silently vanish (and, for an
- * object value, reassign the result's prototype). The computed form
- * `{ ["__proto__"]: v }` creates a normal own property. Every other key keeps
- * the plain `safeKey` output, so the common path is unchanged.
- */
-const safeLiteralKey = (key) => (key === '__proto__' ? '["__proto__"]' : safeKey(key));
-/**
- * Checks if a property is required based on the schema's required array.
- */
+const safeLiteralKey = (key) => key === "__proto__" ? '["__proto__"]' : safeKey(key);
 const isPropertyRequired = (key, schema) => {
-    if (!isSchemaObject(schema)) {
-        return false;
-    }
-    if (!('required' in schema) || !Array.isArray(schema.required)) {
-        return false;
-    }
-    return schema.required.includes(key);
+  if (!isSchemaObject(schema)) {
+    return false;
+  }
+  if (!("required" in schema) || !Array.isArray(schema.required)) {
+    return false;
+  }
+  return schema.required.includes(key);
 };
-/**
- * Generates a parser call expression for a required $ref property.
- * Example: parseContact(input.contact)
- */
 const generateRequiredRefCall = (key, ref, suffix) => {
-    const acc = safeAccessor('input', key);
-    const parserName = generateParserName(refToName(ref, suffix));
-    return `${parserName}(${acc})`;
+  const acc = safeAccessor("input", key);
+  const parserName = generateParserName(refToName(ref, suffix));
+  return `${parserName}(${acc})`;
 };
-/**
- * Generates a parser call expression for an optional $ref property.
- * Example: ...(input.contact && { contact: parseContact(input.contact) })
- */
 const generateOptionalRefCall = (key, ref, suffix) => {
-    const acc = safeAccessor('input', key);
-    const parserName = generateParserName(refToName(ref, suffix));
-    // Gate on presence, not truthiness: a `&&` guard skips parsing when the value
-    // is `false`/`0`/`""`/`null`, spreading it raw. `!== undefined` still omits an
-    // absent optional property but coerces every present one, matching the main path.
-    return `...(${acc} !== undefined && { ${safeLiteralKey(key)}: ${parserName}(${acc}) })`;
+  const acc = safeAccessor("input", key);
+  const parserName = generateParserName(refToName(ref, suffix));
+  return `...(${acc} !== undefined && { ${safeLiteralKey(key)}: ${parserName}(${acc}) })`;
 };
-/**
- * Generates a validateArray call for required array properties with $ref items.
- * Example: validateArray(input.contacts, parseContact)
- */
 const generateRequiredArrayRefCall = (key, ref, suffix) => {
-    const parserName = generateParserName(refToName(ref, suffix));
-    return `validateArray(${safeAccessor('input', key)}, ${parserName})`;
+  const parserName = generateParserName(refToName(ref, suffix));
+  return `validateArray(${safeAccessor("input", key)}, ${parserName})`;
 };
-/**
- * Generates a validateArray call for optional array properties with $ref items.
- * Example: ...(input.contacts && { contacts: validateArray(input.contacts, parseContact) })
- */
 const generateOptionalArrayRefCall = (key, ref, suffix) => {
-    const parserName = generateParserName(refToName(ref, suffix));
-    const acc = safeAccessor('input', key);
-    // Presence gating (not truthiness) so a falsy-but-present value is still parsed.
-    return `...(${acc} !== undefined && { ${safeLiteralKey(key)}: validateArray(${acc}, ${parserName}) })`;
+  const parserName = generateParserName(refToName(ref, suffix));
+  const acc = safeAccessor("input", key);
+  return `...(${acc} !== undefined && { ${safeLiteralKey(key)}: validateArray(${acc}, ${parserName}) })`;
 };
-/**
- * Generates a validateRecord call for required object properties with additionalProperties $ref.
- * Example: validateRecord(input.responses, parseResponse)
- */
 const generateRequiredRecordRefCall = (key, ref, suffix) => {
-    const acc = safeAccessor('input', key);
-    const parserName = generateParserName(refToName(ref, suffix));
-    return `validateRecord(${acc}, ${parserName})`;
+  const acc = safeAccessor("input", key);
+  const parserName = generateParserName(refToName(ref, suffix));
+  return `validateRecord(${acc}, ${parserName})`;
 };
-/**
- * Generates a validateRecord call for optional object properties with additionalProperties $ref.
- * Example: ...(input.responses && { responses: validateRecord(input.responses, parseResponse) })
- */
 const generateOptionalRecordRefCall = (key, ref, suffix) => {
-    const acc = safeAccessor('input', key);
-    const parserName = generateParserName(refToName(ref, suffix));
-    // Presence gating (not truthiness) so a falsy-but-present value is still parsed.
-    return `...(${acc} !== undefined && { ${safeLiteralKey(key)}: validateRecord(${acc}, ${parserName}) })`;
+  const acc = safeAccessor("input", key);
+  const parserName = generateParserName(refToName(ref, suffix));
+  return `...(${acc} !== undefined && { ${safeLiteralKey(key)}: validateRecord(${acc}, ${parserName}) })`;
 };
-/**
- * Generates a spread entry for optional inline properties.
- * The value expression is evaluated once and omitted when undefined.
- */
 const generateOptionalInlineProperty = (key, valueExpression) => {
-    return `...((value => value === undefined ? {} : { ${safeLiteralKey(key)}: value })(${valueExpression}))`;
+  return `...((value => value === undefined ? {} : { ${safeLiteralKey(key)}: value })(${valueExpression}))`;
 };
-/**
- * Determines if a property schema should use ref imports for validation.
- */
 const shouldUseRefImport = (propSchema, useRefImports) => {
-    if (!useRefImports || !hasRef(propSchema)) {
-        return false;
-    }
-    const ref = propSchema.$ref;
-    // Skip external URI refs with property/definition fragments — these are not generated as files
-    const isUri = ref.startsWith('http://') || ref.startsWith('https://');
-    if (isUri && (ref.includes('#/properties/') || ref.includes('#/definitions/'))) {
-        return false;
-    }
-    return true;
+  if (!useRefImports || !hasRef(propSchema)) {
+    return false;
+  }
+  const ref = propSchema.$ref;
+  const isUri = ref.startsWith("http://") || ref.startsWith("https://");
+  if (isUri && (ref.includes("#/properties/") || ref.includes("#/definitions/"))) {
+    return false;
+  }
+  return true;
 };
-/**
- * Determines if an array property should use ref imports for its items.
- */
 const shouldUseArrayRefImport = (propSchema, useRefImports) => {
-    if (!useRefImports) {
-        return false;
-    }
-    if (!isSchemaObject(propSchema)) {
-        return false;
-    }
-    if (!('type' in propSchema) || propSchema.type !== 'array') {
-        return false;
-    }
-    return hasItems(propSchema) && hasRef(propSchema.items);
+  if (!useRefImports) {
+    return false;
+  }
+  if (!isSchemaObject(propSchema)) {
+    return false;
+  }
+  if (!("type" in propSchema) || propSchema.type !== "array") {
+    return false;
+  }
+  return hasItems(propSchema) && hasRef(propSchema.items);
 };
-/**
- * Determines if a property with additionalProperties should use ref imports.
- */
 const shouldUseRecordRefImport = (propSchema, useRefImports) => {
-    if (!useRefImports) {
-        return false;
-    }
-    if (!isSchemaObject(propSchema)) {
-        return false;
-    }
-    if (!('type' in propSchema) || propSchema.type !== 'object') {
-        return false;
-    }
-    if (!('additionalProperties' in propSchema)) {
-        return false;
-    }
-    const additionalProps = propSchema.additionalProperties;
-    return isSchemaObject(additionalProps) && hasRef(additionalProps);
+  if (!useRefImports) {
+    return false;
+  }
+  if (!isSchemaObject(propSchema)) {
+    return false;
+  }
+  if (!("type" in propSchema) || propSchema.type !== "object") {
+    return false;
+  }
+  if (!("additionalProperties" in propSchema)) {
+    return false;
+  }
+  const additionalProps = propSchema.additionalProperties;
+  return isSchemaObject(additionalProps) && hasRef(additionalProps);
 };
-/**
- * Generates the value expression for a property based on its schema and options.
- */
 const generatePropertyValue = (key, propSchema, isRequired, useRefImports, suffix, caseInsensitive = false) => {
-    // Handle direct $ref properties
-    if (shouldUseRefImport(propSchema, useRefImports)) {
-        const ref = propSchema.$ref;
-        return isRequired ? generateRequiredRefCall(key, ref, suffix) : generateOptionalRefCall(key, ref, suffix);
-    }
-    // Handle array properties with $ref items
-    if (shouldUseArrayRefImport(propSchema, useRefImports)) {
-        const items = propSchema.items;
-        const ref = items.$ref;
-        return isRequired ? generateRequiredArrayRefCall(key, ref, suffix) : generateOptionalArrayRefCall(key, ref, suffix);
-    }
-    // Handle object properties with additionalProperties $ref
-    if (shouldUseRecordRefImport(propSchema, useRefImports)) {
-        const additionalProps = propSchema.additionalProperties;
-        const ref = additionalProps.$ref;
-        return isRequired
-            ? generateRequiredRecordRefCall(key, ref, suffix)
-            : generateOptionalRecordRefCall(key, ref, suffix);
-    }
-    // Handle non-schema object properties (true/false)
-    if (!isSchemaObject(propSchema)) {
-        return isRequired ? 'undefined' : generateOptionalInlineProperty(key, 'undefined');
-    }
-    // Generate standard validation expression
-    const defaultValue = getDefaultValue(propSchema);
-    const valueExpression = generateValidationExpression(key, propSchema, defaultValue, isRequired, undefined, undefined, undefined, undefined, caseInsensitive);
-    return isRequired ? valueExpression : generateOptionalInlineProperty(key, valueExpression);
+  if (shouldUseRefImport(propSchema, useRefImports)) {
+    const ref = propSchema.$ref;
+    return isRequired ? generateRequiredRefCall(key, ref, suffix) : generateOptionalRefCall(key, ref, suffix);
+  }
+  if (shouldUseArrayRefImport(propSchema, useRefImports)) {
+    const items = propSchema.items;
+    const ref = items.$ref;
+    return isRequired ? generateRequiredArrayRefCall(key, ref, suffix) : generateOptionalArrayRefCall(key, ref, suffix);
+  }
+  if (shouldUseRecordRefImport(propSchema, useRefImports)) {
+    const additionalProps = propSchema.additionalProperties;
+    const ref = additionalProps.$ref;
+    return isRequired ? generateRequiredRecordRefCall(key, ref, suffix) : generateOptionalRecordRefCall(key, ref, suffix);
+  }
+  if (!isSchemaObject(propSchema)) {
+    return isRequired ? "undefined" : generateOptionalInlineProperty(key, "undefined");
+  }
+  const defaultValue = getDefaultValue(propSchema);
+  const valueExpression = generateValidationExpression(key, propSchema, defaultValue, isRequired, void 0, void 0, void 0, void 0, caseInsensitive);
+  return isRequired ? valueExpression : generateOptionalInlineProperty(key, valueExpression);
 };
-/**
- * Generates property entries for all properties in the schema.
- */
 const generatePropertyEntries = (schema, useRefImports, suffix, caseInsensitive = false) => {
-    if (!hasProperties(schema)) {
-        return [];
-    }
-    const entries = [];
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
-        const isRequired = isPropertyRequired(key, schema);
-        const value = generatePropertyValue(key, propSchema, isRequired, useRefImports, suffix, caseInsensitive);
-        // Determine if the property uses spread syntax (making it optional in the object literal)
-        const isOptional = value.startsWith('...');
-        entries.push({ key, value, isOptional });
-    }
-    return entries;
+  if (!hasProperties(schema)) {
+    return [];
+  }
+  const entries = [];
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    const isRequired = isPropertyRequired(key, schema);
+    const value = generatePropertyValue(key, propSchema, isRequired, useRefImports, suffix, caseInsensitive);
+    const isOptional = value.startsWith("...");
+    entries.push({ key, value, isOptional });
+  }
+  return entries;
 };
-/**
- * Generates a fallback value for a required property.
- * This returns simple type-based defaults without pattern inference,
- * matching TypeBox's coercion behavior.
- */
 const generateFallbackValue = (_, propSchema, useRefImports, suffix) => {
-    // Handle direct $ref properties - call the parser with undefined
-    if (useRefImports && hasRef(propSchema)) {
-        const ref = propSchema.$ref;
-        const parserName = generateParserName(refToName(ref, suffix));
-        return `${parserName}(undefined)`;
-    }
-    // Handle array properties with $ref items
-    if (useRefImports &&
-        isSchemaObject(propSchema) &&
-        propSchema.type === 'array' &&
-        hasItems(propSchema) &&
-        hasRef(propSchema.items)) {
-        return '[]';
-    }
-    // Handle object properties with additionalProperties $ref
-    if (useRefImports &&
-        isSchemaObject(propSchema) &&
-        propSchema.type === 'object' &&
-        'additionalProperties' in propSchema) {
-        const additionalProps = propSchema.additionalProperties;
-        if (isSchemaObject(additionalProps) && hasRef(additionalProps)) {
-            return '{}';
-        }
+  if (useRefImports && hasRef(propSchema)) {
+    const ref = propSchema.$ref;
+    const parserName = generateParserName(refToName(ref, suffix));
+    return `${parserName}(undefined)`;
+  }
+  if (useRefImports && isSchemaObject(propSchema) && propSchema.type === "array" && hasItems(propSchema) && hasRef(propSchema.items)) {
+    return "[]";
+  }
+  if (useRefImports && isSchemaObject(propSchema) && propSchema.type === "object" && "additionalProperties" in propSchema) {
+    const additionalProps = propSchema.additionalProperties;
+    if (isSchemaObject(additionalProps) && hasRef(additionalProps)) {
+      return "{}";
     }
-    // Everything else (default/const/enum/examples/union, the null type, and a
-    // recursively-defaulted object) shares one source of truth so the fallback
-    // object is itself a valid instance — `getDefaultValue` handles them all.
-    return getDefaultValue(propSchema);
+  }
+  return getDefaultValue(propSchema);
 };
-/**
- * Generates a fallback object with required properties filled with default values.
- * This is used when input is not an object (undefined, null, etc.).
- */
 const generateFallbackObject = (schema, useRefImports, typeName, suffix, subTypeNames) => {
-    if (!hasProperties(schema)) {
-        return `{} as ${typeName}`;
-    }
-    // For schemas with conditional branches (if/then/else), the merged properties
-    // may not fully represent all required fields. Use a simple cast to avoid
-    // generating incomplete fallback objects.
-    if (isSchemaObject(schema) && ('if' in schema || 'then' in schema || 'else' in schema)) {
-        return `{} as ${typeName}`;
-    }
-    const requiredProps = [];
-    for (const [key, propSchema] of Object.entries(schema.properties)) {
-        const isRequired = isPropertyRequired(key, schema);
-        if (isRequired) {
-            // Inline nested objects delegate to their sub-parser so the fallback
-            // carries proper deep defaults instead of an empty object literal.
-            const subName = subTypeNames?.get(key);
-            const fallbackValue = subName
-                ? `${generateParserName(subName)}(undefined)`
-                : generateFallbackValue(key, propSchema, useRefImports, suffix);
-            if (fallbackValue === 'undefined') {
-                return `{} as ${typeName}`;
-            }
-            requiredProps.push(`        ${safeLiteralKey(key)}: ${fallbackValue},`);
-        }
-    }
-    if (requiredProps.length === 0) {
+  if (!hasProperties(schema)) {
+    return `{} as ${typeName}`;
+  }
+  if (isSchemaObject(schema) && ("if" in schema || "then" in schema || "else" in schema)) {
+    return `{} as ${typeName}`;
+  }
+  const requiredProps = [];
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    const isRequired = isPropertyRequired(key, schema);
+    if (isRequired) {
+      const subName = subTypeNames?.get(key);
+      const fallbackValue = subName ? `${generateParserName(subName)}(undefined)` : generateFallbackValue(key, propSchema, useRefImports, suffix);
+      if (fallbackValue === "undefined") {
         return `{} as ${typeName}`;
+      }
+      requiredProps.push(`        ${safeLiteralKey(key)}: ${fallbackValue},`);
     }
-    let result = '{\n';
-    for (let i = 0; i < requiredProps.length; i++) {
-        result += requiredProps[i];
-        if (i < requiredProps.length - 1) {
-            result += '\n';
-        }
+  }
+  if (requiredProps.length === 0) {
+    return `{} as ${typeName}`;
+  }
+  let result = "{\n";
+  for (let i = 0; i < requiredProps.length; i++) {
+    result += requiredProps[i];
+    if (i < requiredProps.length - 1) {
+      result += "\n";
     }
-    result += '\n      }';
-    return result;
+  }
+  result += "\n      }";
+  return result;
 };
-/**
- * Generates a parser for non-object schemas (string, number, boolean, array, etc.)
- * that validates the input matches the expected primitive type before casting.
- */
-/**
- * A default value literal (as source text) for `schema`, used as the fallback a
- * top-level union coerces an unmatched value to. Prefers a `const`/`enum` member,
- * then a per-type empty value.
- */
 const scalarDefaultLiteral = (schema) => {
-    if (!isSchemaObject(schema))
-        return '{}';
-    if (hasConst(schema))
-        return JSON.stringify(schema.const);
-    if (hasEnum(schema) && schema.enum.length > 0)
-        return JSON.stringify(schema.enum[0]);
-    if (hasType(schema)) {
-        switch (schema.type) {
-            case 'string':
-                return '""';
-            case 'number':
-            case 'integer':
-                return '0';
-            case 'boolean':
-                return 'false';
-            case 'null':
-                return 'null';
-            case 'array':
-                return '[]';
-            case 'object':
-                return '{}';
-        }
+  if (!isSchemaObject(schema))
+    return "{}";
+  if (hasConst(schema))
+    return JSON.stringify(schema.const);
+  if (hasEnum(schema) && schema.enum.length > 0)
+    return JSON.stringify(schema.enum[0]);
+  if (hasType(schema)) {
+    switch (schema.type) {
+      case "string":
+        return '""';
+      case "number":
+      case "integer":
+        return "0";
+      case "boolean":
+        return "false";
+      case "null":
+        return "null";
+      case "array":
+        return "[]";
+      case "object":
+        return "{}";
     }
-    return '{}';
+  }
+  return "{}";
 };
-/**
- * Emits a dispatcher for a top-level `oneOf`/`anyOf` whose branches are `$ref`s,
- * when the branches share a discriminator (a `const`/`enum` tag such as `kind`).
- * Each resolved branch's discriminant selects its imported parser, so a recursive
- * discriminated union (e.g. `Expr = Lit | BinOp`, where `BinOp` has `Expr`
- * children) is actually validated and dispatched instead of blindly cast. Returns
- * `null` when it can't be done (no root schema, no discriminator, a non-ref
- * branch, or ref imports disabled), so the caller keeps its passthrough fallback.
- */
 const generateRefUnionDispatch = (functionName, typeName, branches, strict, ctx) => {
-    const rootSchema = ctx.rootSchema;
-    if (!ctx.useRefImports || rootSchema === undefined)
-        return null;
-    if (branches.length === 0 || !branches.every((b) => isSchemaObject(b) && hasRef(b)))
-        return null;
-    // Resolve each branch ref so we can read its discriminant tag and derive its
-    // imported parser name.
-    const resolved = branches.map((b) => {
-        const ref = b.$ref;
-        return { parser: generateParserName(refToName(ref, ctx.suffix)), schema: resolveRef(ref, rootSchema) };
-    });
-    if (resolved.some((r) => !isSchemaObject(r.schema)))
-        return null;
-    const discriminator = findDiscriminator(resolved.map((r) => r.schema));
-    if (discriminator === null)
-        return null;
-    const cases = [];
-    for (const r of resolved) {
-        const value = getDiscriminatorValue(r.schema, discriminator);
-        if (value === null)
-            return null;
-        cases.push({ value, parser: r.parser });
-    }
-    // Read the discriminant safely: `null`/`undefined` is guarded (a property read
-    // would throw), and a non-object primitive yields `undefined` (no branch matches).
-    const access = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(discriminator)
-        ? `.${discriminator}`
-        : `[${JSON.stringify(discriminator)}]`;
-    const discExpr = `input == null ? undefined : (input as Record<string, unknown>)${access}`;
-    // Fold branches into a nested ternary in declaration order:
-    // `_disc === "lit" ? parseLit(input) : _disc === "binop" ? parseBinop(input) : <fallback>`.
-    // Unmatched: strict throws (not a member of the union); non-strict coerces via the
-    // first branch's parser, preserving the coercing parser's lenient contract while
-    // still running real validation/coercion instead of a blind cast.
-    const fallback = strict
-        ? `(() => { throw new Error(${quoteJsString(`[${typeName}] value does not match any union branch`)}); })()`
-        : `${cases[0]?.parser}(input)`;
-    let expr = fallback;
-    for (let i = cases.length - 1; i >= 0; i--) {
-        const c = cases[i];
-        if (c)
-            expr = `_disc === ${JSON.stringify(c.value)} ? ${c.parser}(input) : ${expr}`;
-    }
-    return `export const ${functionName} = (input: unknown): ${typeName} => {\n  const _disc = ${discExpr};\n  return ${expr};\n};`;
+  const rootSchema = ctx.rootSchema;
+  if (!ctx.useRefImports || rootSchema === void 0)
+    return null;
+  if (branches.length === 0 || !branches.every((b) => isSchemaObject(b) && hasRef(b)))
+    return null;
+  const resolved = branches.map((b) => {
+    const ref = b.$ref;
+    return { parser: generateParserName(refToName(ref, ctx.suffix)), schema: resolveRef(ref, rootSchema) };
+  });
+  if (resolved.some((r) => !isSchemaObject(r.schema)))
+    return null;
+  const discriminator = findDiscriminator(resolved.map((r) => r.schema));
+  if (discriminator === null)
+    return null;
+  const cases = [];
+  for (const r of resolved) {
+    const value = getDiscriminatorValue(r.schema, discriminator);
+    if (value === null)
+      return null;
+    cases.push({ value, parser: r.parser });
+  }
+  const access = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(discriminator) ? `.${discriminator}` : `[${JSON.stringify(discriminator)}]`;
+  const discExpr = `input == null ? undefined : (input as Record<string, unknown>)${access}`;
+  const fallback = strict ? `(() => { throw new Error(${quoteJsString(`[${typeName}] value does not match any union branch`)}); })()` : `${cases[0]?.parser}(input)`;
+  let expr = fallback;
+  for (let i = cases.length - 1; i >= 0; i--) {
+    const c = cases[i];
+    if (c)
+      expr = `_disc === ${JSON.stringify(c.value)} ? ${c.parser}(input) : ${expr}`;
+  }
+  return `export const ${functionName} = (input: unknown): ${typeName} => {
+  const _disc = ${discExpr};
+  return ${expr};
+};`;
 };
 const generateNonObjectParser = (typeName, schema, strict, unionCtx) => {
-    const functionName = generateParserName(typeName);
-    // A ref-branch discriminated union dispatches to its branch parsers in *both*
-    // modes (strict throws on an unmatched discriminant; non-strict coerces via the
-    // first branch). This runs before the `!strict` coercion block below so a strict
-    // recursive union is validated instead of blindly cast.
-    if (unionCtx && isSchemaObject(schema) && (hasOneOf(schema) || hasAnyOf(schema))) {
-        const branches = hasOneOf(schema) ? schema.oneOf : hasAnyOf(schema) ? schema.anyOf : [];
-        if (branches.length > 0 && branches.every((b) => isSchemaObject(b) && hasRef(b))) {
-            const dispatch = generateRefUnionDispatch(functionName, typeName, branches, strict, unionCtx);
-            if (dispatch !== null)
-                return dispatch;
-        }
+  const functionName = generateParserName(typeName);
+  if (unionCtx && isSchemaObject(schema) && (hasOneOf(schema) || hasAnyOf(schema))) {
+    const branches = hasOneOf(schema) ? schema.oneOf : hasAnyOf(schema) ? schema.anyOf : [];
+    if (branches.length > 0 && branches.every((b) => isSchemaObject(b) && hasRef(b))) {
+      const dispatch = generateRefUnionDispatch(functionName, typeName, branches, strict, unionCtx);
+      if (dispatch !== null)
+        return dispatch;
     }
-    // An alias definition (a bare `$ref` with no shape of its own, e.g. a root
-    // schema that is just `$ref: '#/$defs/expr'`) delegates to the referenced
-    // parser instead of blindly casting, in both modes. Guarded against
-    // self-reference: delegating to ourselves would recurse forever.
-    if (unionCtx?.useRefImports && isSchemaObject(schema) && hasRef(schema) && !hasProperties(schema)) {
-        const refName = refToName(schema.$ref, unionCtx.suffix);
-        if (refName !== typeName) {
-            return `export const ${functionName} = (input: unknown): ${typeName} => ${generateParserName(refName)}(input) as ${typeName};`;
-        }
-    }
-    // Strict union enforcement for inline (or mixed) branches: membership is the
-    // disjunction of per-branch checks, and a non-member throws. Only emitted
-    // when every branch check is false-sound (see canEnforceUnion) — otherwise a
-    // conservative stub validator somewhere in the graph could reject valid
-    // input — and never when stripping unknown keys (see UnionParserContext).
-    if (strict && unionCtx && isSchemaObject(schema)) {
-        const branches = getUnionBranches(schema);
-        if (branches && !unionCtx.stripUnknown && canEnforceUnion(branches, unionCtx.rootSchema)) {
-            const check = generateUnionCheck('input', branches, unionCtx.useRefImports, unionCtx.suffix);
-            if (check !== null) {
-                return `export const ${functionName} = (input: unknown): ${typeName} => {\n  if (!(${check})) throw new Error(${quoteJsString(`[${typeName}] value does not match any union branch`)});\n  return input as ${typeName};\n};`;
-            }
-        }
-    }
-    // `const`/`enum` define the value space directly (the generated type is a
-    // literal / literal-union), so a non-member must coerce to a valid member —
-    // otherwise the returned value would not be of the declared type. This runs
-    // before the `type` switch so e.g. `{ type: 'string', enum: [...] }` is covered,
-    // and before the no-`type` bail so a bare `const`/`enum` schema is covered too.
-    if (!strict && isSchemaObject(schema)) {
-        if (hasConst(schema)) {
-            const literal = JSON.stringify(schema.const);
-            // The const is the only valid value, so the parser always yields it. For a
-            // primitive we can keep the caller's value when it already equals the const
-            // (`===` is a correct comparison); for an object/array, `===` would be a
-            // (always-false) reference comparison, so just return the const literal.
-            const isPrimitive = schema.const === null || typeof schema.const !== 'object';
-            return isPrimitive
-                ? `export const ${functionName} = (input: unknown): ${typeName} => input === ${literal} ? input as ${typeName} : ${literal} as ${typeName};`
-                : `export const ${functionName} = (input: unknown): ${typeName} => ${literal} as ${typeName};`;
-        }
-        if (hasEnum(schema) && schema.enum.length > 0) {
-            const values = JSON.stringify(schema.enum);
-            const fallback = JSON.stringify(schema.enum[0]);
-            // Case-insensitive normalization sits on the non-member branch only, so an
-            // exact member still returns via the `includes` fast path untouched.
-            const ci = unionCtx?.caseInsensitive ? generateEnumCaseInsensitiveCoercion('input', schema.enum, fallback) : null;
-            const coerced = ci ? `(${ci})` : fallback;
-            return `export const ${functionName} = (input: unknown): ${typeName} => ${values}.includes(input as never) ? input as ${typeName} : ${coerced} as ${typeName};`;
-        }
-        // A top-level union must validate membership: an unmatched value is not of
-        // the declared union type, so coerce it to a member-shaped default. Reuse the
-        // same union validation the property path uses.
-        if (hasOneOf(schema) || hasAnyOf(schema)) {
-            const branches = hasOneOf(schema) ? schema.oneOf : hasAnyOf(schema) ? schema.anyOf : [];
-            const hasRefBranch = branches.some((b) => isSchemaObject(b) && hasRef(b));
-            if (branches.length > 0 && !hasRefBranch) {
-                const fallback = scalarDefaultLiteral(branches[0]);
-                const expr = generateValidationExpression('', schema, fallback, true, undefined, undefined, 'input', true);
-                return `export const ${functionName} = (input: unknown): ${typeName} => (${expr}) as ${typeName};`;
-            }
-            // Ref-branch union: a *discriminated* one was already dispatched above (both
-            // modes). Anything reaching here is non-discriminated, which can't be validated
-            // inline without risking dropping valid input — fall back to a passthrough cast.
-            return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
-        }
-    }
-    // Strict counterpart of the block above for a *type-less* `const`/`enum` root
-    // (`{ enum: [...] }` / `{ const: ... }` with no `type`): the no-`type` bail
-    // below would otherwise return a bare cast, so strict mode has to assert
-    // membership here. A typed `const`/`enum` (`{ type: 'string', enum: [...] }`)
-    // keeps flowing to the strict scalar path, which asserts it via
-    // generateScalarStrictAssertion.
-    if (strict && isSchemaObject(schema) && !hasType(schema) && (hasConst(schema) || hasEnum(schema))) {
-        const assertion = generateScalarStrictAssertion(schema, typeName, unionCtx?.rootSchema);
-        if (assertion !== null) {
-            return `export const ${functionName} = (input: unknown): ${typeName} => {\n${assertion}\n  return input as ${typeName};\n};`;
-        }
+  }
+  if (unionCtx?.useRefImports && isSchemaObject(schema) && hasRef(schema) && !hasProperties(schema)) {
+    const refName = refToName(schema.$ref, unionCtx.suffix);
+    if (refName !== typeName) {
+      return `export const ${functionName} = (input: unknown): ${typeName} => ${generateParserName(refName)}(input) as ${typeName};`;
     }
-    // Root-level arrays with rich item schemas delegate every element to a real
-    // parser, so nested enums and $refs inside array items are validated instead
-    // of spread through unchecked. $ref items call the imported parser; inline
-    // object items get a private item sub-parser in the same file. (Scalar and
-    // enum items are covered below: the lax switch coerces them element-wise and
-    // generateScalarStrictAssertion enforces them in strict mode.)
-    if (isSchemaObject(schema) &&
-        hasType(schema) &&
-        schema.type === 'array' &&
-        hasItems(schema) &&
-        !Array.isArray(schema.items)) {
-        const items = schema.items;
-        const notArrayThrow = `if (!Array.isArray(input)) throw new Error(\`[${typeName}] expected array, got \${input === null ? "null" : typeof input}\`);`;
-        // This delegating path bypasses generateScalarStrictAssertion, so enforce the
-        // array-level `contains` constraint here too — otherwise a root array of
-        // objects/$refs would silently ignore it in strict mode.
-        const strictArrayChecks = strict ? generateContainsCheck('input', schema, `[${typeName}]`).join('\n') : '';
-        // validateArray identity-returns the input array when every element parses
-        // to itself; this parser is EXPORTED, and exported parsers never alias the
-        // value the caller passed in (matching the scalar root-array path's
-        // `[...input]` copy), so materialize a copy exactly when that happens —
-        // element references are still shared, like every other fast path.
-        const delegatedBody = (itemParserName) => `  const _parsed = validateArray(input, ${itemParserName});\n  return (_parsed === input ? [..._parsed] : _parsed) as ${typeName};`;
-        const delegated = (itemParserName) => strict
-            ? `export const ${functionName} = (input: unknown): ${typeName} => {\n  ${notArrayThrow}${strictArrayChecks ? `\n${strictArrayChecks}` : ''}\n${delegatedBody(itemParserName)}\n};`
-            : `export const ${functionName} = (input: unknown): ${typeName} => {\n${delegatedBody(itemParserName)}\n};`;
-        if (unionCtx?.useRefImports && isSchemaObject(items) && hasRef(items)) {
-            return delegated(generateParserName(refToName(items.$ref, unionCtx.suffix)));
-        }
-        if (isInlineObjectProperty(items)) {
-            const reserved = unionCtx?.reservedNames ?? NO_RESERVED_NAMES;
-            // Dedup against imported identifiers: a root `List` whose items carry a
-            // $ref to `#/$defs/listItem` imports parseListItem — a bare `ListItem`
-            // here would shadow it (TS2440) and self-recurse instead of delegating.
-            let itemName = `${typeName}_Item`;
-            while (reserved.has(itemName))
-                itemName = `${itemName}_`;
-            const useRefImports = unionCtx?.useRefImports ?? false;
-            const suffix = unionCtx?.suffix ?? '';
-            const stripUnknown = unionCtx?.stripUnknown ?? false;
-            const preamble = [
-                `type ${itemName} = ${typeName}[number];`,
-                generateShapeValidator(items, itemName, useRefImports, suffix, false, stripUnknown, reserved),
-                generateObjectParser(items, itemName, useRefImports, suffix, unionCtx?.logWarnings ?? false, strict, false, stripUnknown, unionCtx?.rootSchema, reserved, unionCtx?.caseInsensitive ?? false),
-            ].join('\n\n');
-            return `${preamble}\n\n${delegated(generateParserName(itemName))}`;
-        }
+  }
+  if (strict && unionCtx && isSchemaObject(schema)) {
+    const branches = getUnionBranches(schema);
+    if (branches && !unionCtx.stripUnknown && canEnforceUnion(branches, unionCtx.rootSchema)) {
+      const check = generateUnionCheck("input", branches, unionCtx.useRefImports, unionCtx.suffix);
+      if (check !== null) {
+        return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!(${check})) throw new Error(${quoteJsString(`[${typeName}] value does not match any union branch`)});
+  return input as ${typeName};
+};`;
+      }
     }
-    if (!isSchemaObject(schema) || !hasType(schema)) {
-        // Schema without type information cannot be validated beyond a cast
-        return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
+  }
+  if (!strict && isSchemaObject(schema)) {
+    if (hasConst(schema)) {
+      const literal = JSON.stringify(schema.const);
+      const isPrimitive = schema.const === null || typeof schema.const !== "object";
+      return isPrimitive ? `export const ${functionName} = (input: unknown): ${typeName} => input === ${literal} ? input as ${typeName} : ${literal} as ${typeName};` : `export const ${functionName} = (input: unknown): ${typeName} => ${literal} as ${typeName};`;
+    }
+    if (hasEnum(schema) && schema.enum.length > 0) {
+      const values = JSON.stringify(schema.enum);
+      const fallback = JSON.stringify(schema.enum[0]);
+      const ci = unionCtx?.caseInsensitive ? generateEnumCaseInsensitiveCoercion("input", schema.enum, fallback) : null;
+      const coerced = ci ? `(${ci})` : fallback;
+      return `export const ${functionName} = (input: unknown): ${typeName} => ${values}.includes(input as never) ? input as ${typeName} : ${coerced} as ${typeName};`;
+    }
+    if (hasOneOf(schema) || hasAnyOf(schema)) {
+      const branches = hasOneOf(schema) ? schema.oneOf : hasAnyOf(schema) ? schema.anyOf : [];
+      const hasRefBranch = branches.some((b) => isSchemaObject(b) && hasRef(b));
+      if (branches.length > 0 && !hasRefBranch) {
+        const fallback = scalarDefaultLiteral(branches[0]);
+        const expr = generateValidationExpression("", schema, fallback, true, void 0, void 0, "input", true);
+        return `export const ${functionName} = (input: unknown): ${typeName} => (${expr}) as ${typeName};`;
+      }
+      return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
     }
-    if (!strict && schema.type === 'null') {
-        return `export const ${functionName} = (input: unknown): ${typeName} => null as ${typeName};`;
+  }
+  if (strict && isSchemaObject(schema) && !hasType(schema) && (hasConst(schema) || hasEnum(schema))) {
+    const assertion = generateScalarStrictAssertion(schema, typeName, unionCtx?.rootSchema);
+    if (assertion !== null) {
+      return `export const ${functionName} = (input: unknown): ${typeName} => {
+${assertion}
+  return input as ${typeName};
+};`;
     }
-    if (strict) {
-        const assertion = generateScalarStrictAssertion(schema, typeName, unionCtx?.rootSchema);
-        if (assertion === null) {
-            return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
-        }
-        const returnExpr = schema.type === 'array' ? `[...(input as readonly unknown[])] as ${typeName}` : `input as ${typeName}`;
-        return `export const ${functionName} = (input: unknown): ${typeName} => {\n${assertion}\n  return ${returnExpr};\n};`;
+  }
+  if (isSchemaObject(schema) && hasType(schema) && schema.type === "array" && hasItems(schema) && !Array.isArray(schema.items)) {
+    const items = schema.items;
+    const notArrayThrow = `if (!Array.isArray(input)) throw new Error(\`[${typeName}] expected array, got \${input === null ? "null" : typeof input}\`);`;
+    const strictArrayChecks = strict ? generateContainsCheck("input", schema, `[${typeName}]`).join("\n") : "";
+    const delegatedBody = (itemParserName) => `  const _parsed = validateArray(input, ${itemParserName});
+  return (_parsed === input ? [..._parsed] : _parsed) as ${typeName};`;
+    const delegated = (itemParserName) => strict ? `export const ${functionName} = (input: unknown): ${typeName} => {
+  ${notArrayThrow}${strictArrayChecks ? `
+${strictArrayChecks}` : ""}
+${delegatedBody(itemParserName)}
+};` : `export const ${functionName} = (input: unknown): ${typeName} => {
+${delegatedBody(itemParserName)}
+};`;
+    if (unionCtx?.useRefImports && isSchemaObject(items) && hasRef(items)) {
+      return delegated(generateParserName(refToName(items.$ref, unionCtx.suffix)));
+    }
+    if (isInlineObjectProperty(items)) {
+      const reserved = unionCtx?.reservedNames ?? NO_RESERVED_NAMES;
+      let itemName = `${typeName}_Item`;
+      while (reserved.has(itemName))
+        itemName = `${itemName}_`;
+      const useRefImports = unionCtx?.useRefImports ?? false;
+      const suffix = unionCtx?.suffix ?? "";
+      const stripUnknown = unionCtx?.stripUnknown ?? false;
+      const itemShapeValidator = generateShapeValidator(items, itemName, useRefImports, suffix, false, stripUnknown, reserved);
+      const preamble = [
+        `type ${itemName} = ${typeName}[number];`,
+        itemShapeValidator,
+        generateObjectParser(items, itemName, useRefImports, suffix, unionCtx?.logWarnings ?? false, strict, false, stripUnknown, unionCtx?.rootSchema, reserved, unionCtx?.caseInsensitive ?? false, itemShapeValidator)
+      ].join("\n\n");
+      return `${preamble}
+
+${delegated(generateParserName(itemName))}`;
     }
-    switch (schema.type) {
-        case 'string':
-            return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "string" ? input as ${typeName} : "" as ${typeName};`;
-        case 'number':
-            return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "number" ? input as ${typeName} : 0 as ${typeName};`;
-        case 'integer':
-            // `integer` rejects non-integral numbers; a bare typeof would accept `1.5`.
-            return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "number" && Number.isInteger(input) ? input as ${typeName} : 0 as ${typeName};`;
-        case 'boolean':
-            return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "boolean" ? input as ${typeName} : false as ${typeName};`;
-        case 'array': {
-            // Tuple `prefixItems`: coerce each declared position and, under items:false,
-            // drop elements past the tuple length. A non-array coerces to an empty array.
-            const prefixItems = getPrefixItems(schema);
-            if (prefixItems) {
-                const mapped = generatePrefixItemsMap('input', prefixItems, prefixItemsCapsLength(schema), unionCtx?.rootSchema, undefined, unionCtx?.caseInsensitive);
-                return `export const ${functionName} = (input: unknown): ${typeName} => Array.isArray(input) ? ${mapped} as ${typeName} : [] as ${typeName};`;
-            }
-            // Coerce each element when the item schema is a single scalar type or an enum.
-            if (hasItems(schema) && !Array.isArray(schema.items) && isCoercibleItemSchema(schema.items)) {
-                const item = schema.items;
-                const itemExpr = generateValidationExpression('', item, getDefaultValue(item), true, undefined, undefined, '_it', true, unionCtx?.caseInsensitive);
-                return `export const ${functionName} = (input: unknown): ${typeName} => Array.isArray(input) ? (input as unknown[]).map((_it) => ${itemExpr}) as ${typeName} : [] as ${typeName};`;
-            }
-            return `export const ${functionName} = (input: unknown): ${typeName} => Array.isArray(input) ? [...input] as ${typeName} : [] as ${typeName};`;
-        }
-        default:
-            return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
+  }
+  if (!isSchemaObject(schema) || !hasType(schema)) {
+    return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
+  }
+  if (!strict && schema.type === "null") {
+    return `export const ${functionName} = (input: unknown): ${typeName} => null as ${typeName};`;
+  }
+  if (strict) {
+    const assertion = generateScalarStrictAssertion(schema, typeName, unionCtx?.rootSchema);
+    if (assertion === null) {
+      return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
     }
+    const returnExpr = schema.type === "array" ? `[...(input as readonly unknown[])] as ${typeName}` : `input as ${typeName}`;
+    return `export const ${functionName} = (input: unknown): ${typeName} => {
+${assertion}
+  return ${returnExpr};
+};`;
+  }
+  switch (schema.type) {
+    case "string":
+      return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "string" ? input as ${typeName} : "" as ${typeName};`;
+    case "number":
+      return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "number" ? input as ${typeName} : 0 as ${typeName};`;
+    case "integer":
+      return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "number" && Number.isInteger(input) ? input as ${typeName} : 0 as ${typeName};`;
+    case "boolean":
+      return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "boolean" ? input as ${typeName} : false as ${typeName};`;
+    case "array": {
+      const prefixItems = getPrefixItems(schema);
+      if (prefixItems) {
+        const mapped = generatePrefixItemsMap("input", prefixItems, prefixItemsCapsLength(schema), unionCtx?.rootSchema, void 0, unionCtx?.caseInsensitive);
+        return `export const ${functionName} = (input: unknown): ${typeName} => Array.isArray(input) ? ${mapped} as ${typeName} : [] as ${typeName};`;
+      }
+      if (hasItems(schema) && !Array.isArray(schema.items) && isCoercibleItemSchema(schema.items)) {
+        const item = schema.items;
+        const itemExpr = generateValidationExpression("", item, getDefaultValue(item), true, void 0, void 0, "_it", true, unionCtx?.caseInsensitive);
+        return `export const ${functionName} = (input: unknown): ${typeName} => Array.isArray(input) ? (input as unknown[]).map((_it) => ${itemExpr}) as ${typeName} : [] as ${typeName};`;
+      }
+      return `export const ${functionName} = (input: unknown): ${typeName} => Array.isArray(input) ? [...input] as ${typeName} : [] as ${typeName};`;
+    }
+    default:
+      return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
+  }
 };
-/**
- * Object-level keyword checks (`propertyNames` / `dependentSchemas` /
- * `dependentRequired`) rendered as a newline-prefixed prelude for the
- * specialized strict object parsers (empty-object, pattern-properties,
- * additionalProperties, combined) that build their result outside
- * generateObjectStrictAssertion. Each of those emits its own
- * `if (!isObject(input)) throw` first, so the checks run against a proven object
- * (`guard = false`). Returns `''` when the schema carries none of the keywords,
- * so existing output for every other schema is byte-for-byte unchanged.
- */
 const strictObjectKeywordPrelude = (schema, typeName) => {
-    if (!isSchemaObject(schema))
-        return '';
-    const lines = generateObjectKeywordChecks('input', schema, `[${typeName}]`, false);
-    return lines.length > 0 ? `\n${lines.join('\n')}` : '';
+  if (!isSchemaObject(schema))
+    return "";
+  const lines = generateObjectKeywordChecks("input", schema, `[${typeName}]`, false);
+  return lines.length > 0 ? `
+${lines.join("\n")}` : "";
 };
-/**
- * Generates a parser for empty object schemas or schemas with only additionalProperties.
- * Validates the input is an object before casting, falling back to an empty object.
- * Returns a shallow copy to avoid mutating the original input. `schema`, when
- * given, supplies any object-level keyword checks the strict parser must enforce.
- */
 const generateEmptyObjectParser = (typeName, strict, schema) => {
-    const functionName = generateParserName(typeName);
-    if (strict) {
-        const prelude = schema !== undefined ? strictObjectKeywordPrelude(schema, typeName) : '';
-        return `export const ${functionName} = (input: unknown): ${typeName} => {\n  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${prelude}\n  return { ...input } as ${typeName};\n};`;
-    }
-    return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? { ...input } as ${typeName} : {} as ${typeName};`;
+  const functionName = generateParserName(typeName);
+  if (strict) {
+    const prelude = schema !== void 0 ? strictObjectKeywordPrelude(schema, typeName) : "";
+    return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${prelude}
+  return { ...input } as ${typeName};
+};`;
+  }
+  return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? { ...input } as ${typeName} : {} as ${typeName};`;
 };
-/**
- * Converts a property key to a safe local variable name for caching.
- * Replaces non-identifier characters with underscores.
- */
 const toVarName = (key) => {
-    const safe = key.replace(/[^a-zA-Z0-9_$]/g, '_');
-    return `_${safe}`;
+  const safe = key.replace(/[^a-zA-Z0-9_$]/g, "_");
+  return `_${safe}`;
 };
-/** PascalCases a property key for use in a synthesized sub-type name. */
-const pascalCaseKey = (key) => key
-    .replace(/[^a-zA-Z0-9_$]/g, '_')
-    .split('_')
-    .filter((part) => part.length > 0)
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-    .join('');
-/** Shared empty reserved-name set for callers with no import context. */
-const NO_RESERVED_NAMES = new Set();
-/**
- * Shared empty result for the common no-inline-sub-types case, so the per-node
- * calls (parser and validator, for every object node, on every generation)
- * allocate nothing. Callers only read from the maps.
- */
-const EMPTY_SUB_TYPES = { objects: new Map(), arrayItems: new Map() };
+const pascalCaseKey = (key) => key.replace(/[^a-zA-Z0-9_$]/g, "_").split("_").filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+const NO_RESERVED_NAMES = /* @__PURE__ */ new Set();
+const EMPTY_SUB_TYPES = { objects: /* @__PURE__ */ new Map(), arrayItems: /* @__PURE__ */ new Map() };
 const collectInlineSubTypes = (schema, typeName, reservedNames = NO_RESERVED_NAMES) => {
-    if (!hasProperties(schema))
-        return EMPTY_SUB_TYPES;
-    const props = schema.properties;
-    // Single pass with lazy allocation: most object nodes have neither inline
-    // object properties nor inline-object array items, and this runs for every
-    // node in both the parser and the validator — so nothing is allocated until
-    // the first match, and the classification predicates run exactly once per
-    // property (an eager pre-scan would re-evaluate them for matching schemas).
-    let objects = null;
-    let arrayItems = null;
-    let used = null;
-    const claim = (base) => {
-        used ??= new Set();
-        let subName = base;
-        while (used.has(subName) || reservedNames.has(subName))
-            subName = `${subName}_`;
-        used.add(subName);
-        return subName;
-    };
-    for (const key in props) {
-        const propSchema = props[key];
-        if (isInlineObjectProperty(propSchema)) {
-            objects ??= new Map();
-            objects.set(key, claim(`${typeName}_${pascalCaseKey(key) || 'Value'}`));
-        }
-        else if (isInlineObjectArrayProperty(propSchema)) {
-            arrayItems ??= new Map();
-            arrayItems.set(key, claim(`${typeName}_${pascalCaseKey(key) || 'Value'}Item`));
-        }
+  if (!hasProperties(schema))
+    return EMPTY_SUB_TYPES;
+  const props = schema.properties;
+  let objects = null;
+  let arrayItems = null;
+  let used = null;
+  const claim = (base) => {
+    used ??= /* @__PURE__ */ new Set();
+    let subName = base;
+    while (used.has(subName) || reservedNames.has(subName))
+      subName = `${subName}_`;
+    used.add(subName);
+    return subName;
+  };
+  for (const key in props) {
+    const propSchema = props[key];
+    if (isInlineObjectProperty(propSchema)) {
+      objects ??= /* @__PURE__ */ new Map();
+      objects.set(key, claim(`${typeName}_${pascalCaseKey(key) || "Value"}`));
+    } else if (isInlineObjectArrayProperty(propSchema)) {
+      arrayItems ??= /* @__PURE__ */ new Map();
+      arrayItems.set(key, claim(`${typeName}_${pascalCaseKey(key) || "Value"}Item`));
     }
-    if (objects === null && arrayItems === null)
-        return EMPTY_SUB_TYPES;
-    return { objects: objects ?? EMPTY_SUB_TYPES.objects, arrayItems: arrayItems ?? EMPTY_SUB_TYPES.arrayItems };
+  }
+  if (objects === null && arrayItems === null)
+    return EMPTY_SUB_TYPES;
+  return { objects: objects ?? EMPTY_SUB_TYPES.objects, arrayItems: arrayItems ?? EMPTY_SUB_TYPES.arrayItems };
 };
-/**
- * True when the parser must reject (strict mode) or strip (coerce mode) every
- * undeclared key: the schema sets `additionalProperties: false` and nothing
- * else (key patterns, composition) can legitimately introduce extra keys.
- */
 const hasStrictKeys = (schema) => {
-    if (!isSchemaObject(schema) || !hasProperties(schema))
-        return false;
-    if (!hasAdditionalProperties(schema) || schema.additionalProperties !== false)
-        return false;
-    if ('patternProperties' in schema)
-        return false;
-    if (hasAllOf(schema) || hasOneOf(schema) || hasAnyOf(schema))
-        return false;
-    return true;
+  if (!isSchemaObject(schema) || !hasProperties(schema))
+    return false;
+  if (!hasAdditionalProperties(schema) || schema.additionalProperties !== false)
+    return false;
+  if ("patternProperties" in schema)
+    return false;
+  if (hasAllOf(schema) || hasOneOf(schema) || hasAnyOf(schema))
+    return false;
+  return true;
 };
-/**
- * When every declared property is required (and every required key is
- * declared, with a real schema), the fast-path known-keys test can be an
- * own-key *count* comparison instead of a per-key `for..in` walk: the typed
- * property checks already prove all N declared keys are present, so
- * `Object.keys(input).length === N` proves there are no undeclared extras —
- * measurably cheaper on the hot path. Returns the declared-key count, or null
- * when the cheaper form would be unsound (an optional or non-schema property
- * breaks the presence proof).
- */
 const exactKeyCountOf = (schema) => {
-    if (!isSchemaObject(schema) || !hasProperties(schema) || !hasRequired(schema))
-        return null;
-    const props = schema.properties;
-    const required = schema.required;
-    // Allocation-free for the common small object: this runs for every object
-    // node, in both the parser and the validator, on every generation, and the
-    // O(n²) `includes` beats building a Set for a handful of keys. Wide schemas
-    // (generated API models) flip to a one-time Set so a 200-property object
-    // doesn't pay ~20k string comparisons per node.
-    const requiredLookup = required.length > 16 ? new Set(required) : null;
-    let declaredCount = 0;
-    for (const key in props) {
-        declaredCount++;
-        // Every declared key must be required, and its check must prove presence —
-        // all schema-object checks fail on undefined, but a true/false schema
-        // literal emits no check at all.
-        const isRequired = requiredLookup !== null ? requiredLookup.has(key) : required.includes(key);
-        if (!isRequired || !isSchemaObject(props[key]))
-            return null;
-    }
-    // Every declared key is required (above) and the counts match, so the
-    // required list is exactly the declared keys (a duplicated required entry
-    // would leave some declared key uncovered and fail the loop).
-    if (declaredCount === 0 || required.length !== declaredCount)
-        return null;
-    return declaredCount;
+  if (!isSchemaObject(schema) || !hasProperties(schema) || !hasRequired(schema))
+    return null;
+  const props = schema.properties;
+  const required = schema.required;
+  const requiredLookup = required.length > 16 ? new Set(required) : null;
+  let declaredCount = 0;
+  for (const key in props) {
+    declaredCount++;
+    const isRequired = requiredLookup !== null ? requiredLookup.has(key) : required.includes(key);
+    if (!isRequired || !isSchemaObject(props[key]))
+      return null;
+  }
+  if (declaredCount === 0 || required.length !== declaredCount)
+    return null;
+  return declaredCount;
 };
-/**
- * Determines if a property needs a local variable or can be inlined.
- * Schema-object properties are always cached: the slow-path ternary chain
- * reads each value 3-4x (typeof check, valid branch, undefined check, coerce),
- * so a single hoisted load is strictly cheaper than the inlined optional chain.
- */
 const shouldCacheVariable = (propSchema, _canFastPath, _useRefImports) => {
-    // Non-schema-object properties (true/false JSON Schema literals) generate
-    // `undefined` with no value access, so caching would be wasted.
-    return isSchemaObject(propSchema);
+  return isSchemaObject(propSchema);
 };
-/**
- * Generates a parser for object schemas with properties.
- *
- * Uses an optimized function body with:
- * - Early return for non-object input
- * - Selective variable caching (only when needed)
- * - Fast path that returns input directly when all properties are already valid
- * - Slow path with optimized expressions
- */
-const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, exported = true, stripUnknown = false, rootSchema, reservedNames = NO_RESERVED_NAMES, caseInsensitive = false) => {
-    const functionName = generateParserName(typeName);
-    const exportPrefix = exported ? 'export ' : '';
-    if (!hasProperties(schema)) {
-        if (strict) {
-            return `${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {\n  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${strictObjectKeywordPrelude(schema, typeName)}\n  return input as ${typeName};\n};`;
-        }
-        return `${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? input as ${typeName} : {} as ${typeName};`;
-    }
-    const schemaProps = schema.properties;
-    // Keys once, values via lookup — Object.entries allocates a tuple per
-    // property and this runs for every object node on every generation.
-    const propertyKeys = Object.keys(schemaProps);
-    // Inline nested object properties get a private sub-parser (plus shape
-    // predicate and type alias) in the same file, so their fields are parsed for
-    // real instead of only passing an isObject check. The sub-parser recurses
-    // through this same generator, so nesting works to any depth. Array
-    // properties with inline object items get the same treatment for their
-    // element type, so nested enums and $refs *inside array items* are validated
-    // too (each element runs through the item sub-parser via validateArray).
-    const { objects: subTypeNames, arrayItems: subItemNames } = collectInlineSubTypes(schema, typeName, reservedNames);
-    const preamble = [];
-    for (const [key, subName] of subTypeNames) {
-        const propSchema = schemaProps[key];
-        preamble.push(`type ${subName} = ${typeName}[${JSON.stringify(key)}];`);
-        preamble.push(generateShapeValidator(propSchema, subName, useRefImports, suffix, false, stripUnknown, reservedNames));
-        preamble.push(generateObjectParser(propSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames, caseInsensitive));
-    }
-    for (const [key, subName] of subItemNames) {
-        const propSchema = schemaProps[key];
-        const itemSchema = propSchema.items;
-        // NonNullable strips the `| undefined` an optional array property carries.
-        preamble.push(`type ${subName} = NonNullable<${typeName}[${JSON.stringify(key)}]>[number];`);
-        preamble.push(generateShapeValidator(itemSchema, subName, useRefImports, suffix, false, stripUnknown, reservedNames));
-        // Hand-rolled loop instead of Array.prototype.every on the guard path — the
-        // callback protocol costs a few percent on element-heavy hot paths.
-        preamble.push(`const _every${subName} = (arr: readonly unknown[]): boolean => {\n  for (let i = 0; i < arr.length; i++) if (!${shapeValidatorName(subName)}(arr[i])) return false;\n  return true;\n};`);
-        preamble.push(generateObjectParser(itemSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames, caseInsensitive));
+const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, exported = true, stripUnknown = false, rootSchema, reservedNames = NO_RESERVED_NAMES, caseInsensitive = false, shapeValidatorSource) => {
+  const functionName = generateParserName(typeName);
+  const exportPrefix = exported ? "export " : "";
+  if (!hasProperties(schema)) {
+    if (strict) {
+      return `${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${strictObjectKeywordPrelude(schema, typeName)}
+  return input as ${typeName};
+};`;
     }
-    // additionalProperties: false — the per-key "is this undeclared" test inlines
-    // `!==` comparisons for a short key list and hoists a Set only for a long one
-    // (see unknownKeyCheck). The predicate form is shared by the fast path and the
-    // shape validator; strict mode throws with the offending key.
-    // `additionalProperties: false` strips *and rejects* extras; `stripUnknown`
-    // only strips them. Both build the result from declared properties alone, so
-    // they share the same machinery (`stripKeys`): drop the `...input` spread and
-    // gate the `{ ...input }` fast path on the known-keys predicate. Only the real
-    // `strictKeys` makes an extra a hard error (the throw block further down).
-    const strictKeys = hasStrictKeys(schema);
-    const stripKeys = strictKeys || stripUnknown;
-    // When every declared property is required, the fast-path no-extras test is
-    // the cheaper own-key count (see exactKeyCountOf) and the `_hasOnlyKnownKeys`
-    // predicate is not emitted at all — the shape validator derives the same
-    // decision from the schema, so the cross-function contract stays in sync.
-    const exactKeyCount = stripKeys ? exactKeyCountOf(schema) : null;
-    const strictKeyCheck = unknownKeyCheck(propertyKeys, `_knownKeys${typeName}`);
-    if (stripKeys && exactKeyCount === null) {
-        for (const declaration of strictKeyCheck.declarations) {
-            preamble.push(`${declaration};`);
-        }
-        preamble.push(`const _hasOnlyKnownKeys${typeName} = (input: Record<string, unknown>): boolean => {\n  for (const _k in input) if (${strictKeyCheck.isUnknown('_k')}) return false;\n  return true;\n};`);
+    return `${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? input as ${typeName} : {} as ${typeName};`;
+  }
+  const schemaProps = schema.properties;
+  const propertyKeys = Object.keys(schemaProps);
+  const { objects: subTypeNames, arrayItems: subItemNames } = collectInlineSubTypes(schema, typeName, reservedNames);
+  const preamble = [];
+  for (const [key, subName] of subTypeNames) {
+    const propSchema = schemaProps[key];
+    preamble.push(`type ${subName} = ${typeName}[${JSON.stringify(key)}];`);
+    const subShapeValidator = generateShapeValidator(propSchema, subName, useRefImports, suffix, false, stripUnknown, reservedNames);
+    preamble.push(subShapeValidator);
+    preamble.push(generateObjectParser(propSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames, caseInsensitive, subShapeValidator));
+  }
+  for (const [key, subName] of subItemNames) {
+    const propSchema = schemaProps[key];
+    const itemSchema = propSchema.items;
+    preamble.push(`type ${subName} = NonNullable<${typeName}[${JSON.stringify(key)}]>[number];`);
+    const itemShapeValidator = generateShapeValidator(itemSchema, subName, useRefImports, suffix, false, stripUnknown, reservedNames);
+    preamble.push(itemShapeValidator);
+    preamble.push(`const _every${subName} = (arr: readonly unknown[]): boolean => {
+  for (let i = 0; i < arr.length; i++) if (!${shapeValidatorName(subName)}(arr[i])) return false;
+  return true;
+};`);
+    preamble.push(generateObjectParser(itemSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames, caseInsensitive, itemShapeValidator));
+  }
+  const strictKeys = hasStrictKeys(schema);
+  const stripKeys = strictKeys || stripUnknown;
+  const exactKeyCount = stripKeys ? exactKeyCountOf(schema) : null;
+  const strictKeyCheck = unknownKeyCheck(propertyKeys, `_knownKeys${typeName}`);
+  if (stripKeys && exactKeyCount === null) {
+    for (const declaration of strictKeyCheck.declarations) {
+      preamble.push(`${declaration};`);
+    }
+    preamble.push(`const _hasOnlyKnownKeys${typeName} = (input: Record<string, unknown>): boolean => {
+  for (const _k in input) if (${strictKeyCheck.isUnknown("_k")}) return false;
+  return true;
+};`);
+  } else if (strict && strictKeys) {
+    for (const declaration of strictKeyCheck.declarations) {
+      preamble.push(`${declaration};`);
     }
-    else if (strict && strictKeys) {
-        // The unknown-key throw loop below still needs the hoisted Set (when the
-        // key list is long enough to use one).
-        for (const declaration of strictKeyCheck.declarations) {
-            preamble.push(`${declaration};`);
-        }
+  }
+  const fallbackObject = generateFallbackObject(schema, useRefImports, typeName, suffix, subTypeNames);
+  const propInfo = [];
+  const hasAllOfRefParsers = useRefImports && isSchemaObject(schema) && hasAllOf(schema) && schema.allOf.some((entry) => isSchemaObject(entry) && hasRef(entry));
+  let canFastPath = !hasAllOfRefParsers && !hasFastPathBlockingKeyword(schema);
+  const fastPathChecks = [];
+  const fastPathAccessorChecks = [];
+  const usedVarNames = /* @__PURE__ */ new Set();
+  for (const key of propertyKeys) {
+    const propSchema = schemaProps[key];
+    const isRequired = isPropertyRequired(key, schema);
+    let varName = toVarName(key);
+    while (usedVarNames.has(varName))
+      varName = `${varName}_`;
+    usedVarNames.add(varName);
+    propInfo.push({ key, varName, isRequired, propSchema });
+    if (!canFastPath)
+      continue;
+    if (shouldUseRecordRefImport(propSchema, useRefImports)) {
+      canFastPath = false;
+      continue;
+    }
+    const subName = subTypeNames.get(key);
+    let check = subName ? `${shapeValidatorName(subName)}(${varName})` : generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
+    const itemSubName = subItemNames.get(key);
+    if (check !== null && itemSubName) {
+      check = `${check} && _every${itemSubName}(${varName})`;
+    }
+    if (check === null) {
+      canFastPath = false;
+      continue;
+    }
+    const accessor = safeAccessor("input", key);
+    let accessorCheck = subName ? `${shapeValidatorName(subName)}(${accessor})` : generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
+    if (itemSubName) {
+      accessorCheck = `${accessorCheck} && _every${itemSubName}(${accessor})`;
+    }
+    if (isRequired) {
+      fastPathChecks.push(check);
+      fastPathAccessorChecks.push(accessorCheck);
+    } else {
+      fastPathChecks.push(`(${varName} === undefined || ${check})`);
+      fastPathAccessorChecks.push(`(${accessor} === undefined || ${accessorCheck})`);
     }
-    const fallbackObject = generateFallbackObject(schema, useRefImports, typeName, suffix, subTypeNames);
-    // First pass: gather per-property info and decide whether a fast path is
-    // possible. A fast path returns the input (or a direct strip-build) for
-    // already-valid input without re-running per-property validation, so it may
-    // only fire when every property can be cheaply proven in-shape.
-    const propInfo = [];
-    // Disable fast path when allOf $ref parsers need to be spread — the fast path
-    // returns input as-is and would skip those coercions.
-    const hasAllOfRefParsers = useRefImports &&
-        isSchemaObject(schema) &&
-        hasAllOf(schema) &&
-        schema.allOf.some((entry) => isSchemaObject(entry) && hasRef(entry));
-    // Object-level keywords the fast path cannot mirror (dependentRequired,
-    // dependentSchemas, propertyNames) force the slow path so the strict assertion
-    // actually runs them; returning `{ ...input }` on a bare shape match would skip
-    // the enforcement. (A property-level blocker like `contains` is already caught
-    // per-property by generatePropertyTypeCheck returning null.)
-    let canFastPath = !hasAllOfRefParsers && !hasFastPathBlockingKeyword(schema);
-    const fastPathChecks = [];
-    // `toVarName` collapses distinct keys that differ only in non-identifier chars
-    // (e.g. `a-b` and `a.b` both → `_a_b`), which would emit two `const _a_b`
-    // declarations (TS2451). Dedupe by suffixing `_` until unique — the same
-    // approach `collectInlineObjectProperties` uses — so each key gets its own var.
-    const usedVarNames = new Set();
-    for (const key of propertyKeys) {
-        const propSchema = schemaProps[key];
-        const isRequired = isPropertyRequired(key, schema);
-        let varName = toVarName(key);
-        while (usedVarNames.has(varName))
-            varName = `${varName}_`;
-        usedVarNames.add(varName);
-        propInfo.push({ key, varName, isRequired, propSchema });
-        if (!canFastPath)
-            continue;
-        // Records of refs require iterating every value to check shape — too
-        // expensive to inline into the parser's fast path. Disable.
-        if (shouldUseRecordRefImport(propSchema, useRefImports)) {
-            canFastPath = false;
-            continue;
-        }
-        const subName = subTypeNames.get(key);
-        // Inline nested objects fast-path through their private shape predicate, the
-        // same way $ref properties use the imported one. Arrays of inline objects
-        // additionally prove every element via the private item predicate.
-        let check = subName
-            ? `${shapeValidatorName(subName)}(${varName})`
-            : generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
-        const itemSubName = subItemNames.get(key);
-        if (check !== null && itemSubName) {
-            check = `${check} && _every${itemSubName}(${varName})`;
-        }
-        if (check === null) {
-            canFastPath = false;
-        }
-        else if (isRequired) {
-            fastPathChecks.push(check);
-        }
-        else {
-            fastPathChecks.push(`(${varName} === undefined || ${check})`);
-        }
+  }
+  if (stripKeys) {
+    fastPathChecks.push(exactKeyCount !== null ? `Object.getPrototypeOf(input) === Object.prototype && Object.keys(input).length === ${exactKeyCount}` : `_hasOnlyKnownKeys${typeName}(input)`);
+  }
+  const deepGuard = canFastPath && fastPathChecks.length > 0 ? fastPathChecks.join(" && ") : null;
+  const literalReturnUsesVars = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema)) && exported;
+  let deepGuardExpr = deepGuard;
+  if (deepGuard !== null && shapeValidatorSource !== void 0 && !literalReturnUsesVars) {
+    const shapeFnName = shapeValidatorName(typeName);
+    const shapeStrictKeysGuard = stripKeys && exactKeyCount === null ? `
+  if (!_hasOnlyKnownKeys${typeName}(input)) return false;` : "";
+    const shapeChecks = [...fastPathAccessorChecks];
+    if (stripKeys && exactKeyCount !== null) {
+      shapeChecks.push(`Object.getPrototypeOf(input) === Object.prototype && Object.keys(input).length === ${exactKeyCount}`);
+    }
+    const expectedShapeValidator = shapeChecks.length === 0 ? shapeStrictKeysGuard ? `${exportPrefix}const ${shapeFnName} = (input: unknown): boolean => {
+  if (!isObject(input)) return false;${shapeStrictKeysGuard}
+  return true;
+};` : `${exportPrefix}const ${shapeFnName} = (input: unknown): boolean => isObject(input);` : `${exportPrefix}const ${shapeFnName} = (input: unknown): boolean => {
+  if (!isObject(input)) return false;${shapeStrictKeysGuard}
+  return ${shapeChecks.join("\n    && ")};
+};`;
+    if (shapeValidatorSource === expectedShapeValidator) {
+      deepGuardExpr = `${shapeFnName}(input)`;
     }
-    // The `{ ...input }` fast path preserves extras, so when stripping it may only
-    // fire on inputs that carry no undeclared key. For strict + additionalProperties:
-    // false the cold path rejects extras instead; folding the known-keys term into
-    // the guard lets the guard run *before* that rejection, so a valid clean input
-    // never pays for the per-property assertions. With every declared property
-    // required, the own-key count is equivalent and cheaper than the per-key walk —
-    // but only for plain objects: a crafted prototype could satisfy the typed
-    // checks through inherited properties while the own-key count still matches,
-    // so non-plain inputs route to the slow path, where the for..in walk keeps
-    // the historical inherited-key rejection.
-    if (stripKeys) {
-        fastPathChecks.push(exactKeyCount !== null
-            ? `Object.getPrototypeOf(input) === Object.prototype && Object.keys(input).length === ${exactKeyCount}`
-            : `_hasOnlyKnownKeys${typeName}(input)`);
+  }
+  const deepGuardCallsShape = deepGuardExpr !== deepGuard;
+  let canShallowGuard = strict && stripUnknown && !strictKeys && !hasFastPathBlockingKeyword(schema);
+  const shallowChecks = [];
+  if (canShallowGuard) {
+    for (const { key, varName, isRequired, propSchema } of propInfo) {
+      const subName = subTypeNames.get(key);
+      let check;
+      if (subName) {
+        check = `isObject(${varName})`;
+      } else if (isSchemaObject(propSchema) && !hasEnum(propSchema) && !hasRef(propSchema) && !hasOneOf(propSchema) && !hasAnyOf(propSchema) && !hasAllOf(propSchema) && !("not" in propSchema) && !shouldUseRefImport(propSchema, useRefImports) && !shouldUseArrayRefImport(propSchema, useRefImports) && !shouldUseRecordRefImport(propSchema, useRefImports)) {
+        check = generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
+      } else {
+        check = null;
+      }
+      if (check === null) {
+        canShallowGuard = false;
+        break;
+      }
+      shallowChecks.push(isRequired ? check : `(${varName} === undefined || ${check})`);
     }
-    // The deep guard proves the whole shape (so `{ ...input }` can be returned),
-    // using the nested shape predicates and the known-keys term above.
-    const deepGuard = canFastPath && fastPathChecks.length > 0 ? fastPathChecks.join(' && ') : null;
-    // The shallow guard powers the strict strip-build fast path (stripUnknown
-    // without additionalProperties: false): it proves every scalar is well-typed
-    // and every nested object is an object, but neither walks nested shapes deeply
-    // nor requires the absence of extras. That lets it fire on the common
-    // stripUnknown input — which carries extras the build removes, and nested
-    // extras each sub-parser removes — while the cold path's per-property
-    // assertions still produce the precise error on a genuine mismatch.
-    let canShallowGuard = strict && stripUnknown && !strictKeys && !hasFastPathBlockingKeyword(schema);
-    const shallowChecks = [];
-    if (canShallowGuard) {
-        for (const { key, varName, isRequired, propSchema } of propInfo) {
-            const subName = subTypeNames.get(key);
-            let check;
-            if (subName) {
-                // Nested inline object: a shallow `isObject` is enough — the sub-parser
-                // validates and strips it.
-                check = `isObject(${varName})`;
-            }
-            else if (isSchemaObject(propSchema) &&
-                !hasEnum(propSchema) &&
-                !hasRef(propSchema) &&
-                !hasOneOf(propSchema) &&
-                !hasAnyOf(propSchema) &&
-                !hasAllOf(propSchema) &&
-                !('not' in propSchema) &&
-                !shouldUseRefImport(propSchema, useRefImports) &&
-                !shouldUseArrayRefImport(propSchema, useRefImports) &&
-                !shouldUseRecordRefImport(propSchema, useRefImports)) {
-                // Plain scalar / array / object: its own type check is already shallow
-                // (arrays are not walked, objects only `isObject`-checked).
-                check = generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
-            }
-            else {
-                check = null;
-            }
-            if (check === null) {
-                canShallowGuard = false;
-                break;
-            }
-            shallowChecks.push(isRequired ? check : `(${varName} === undefined || ${check})`);
-        }
+  }
+  const shallowGuard = canShallowGuard && shallowChecks.length > 0 ? shallowChecks.join(" && ") : null;
+  const varDeclLines = [];
+  for (const { key, varName, propSchema } of propInfo) {
+    if (shouldCacheVariable(propSchema, canFastPath, useRefImports)) {
+      varDeclLines.push(`  const ${varName} = ${safeAccessor("input", key)};`);
     }
-    const shallowGuard = canShallowGuard && shallowChecks.length > 0 ? shallowChecks.join(' && ') : null;
-    // Variable declarations for properties that need them (the build and guards
-    // read each cached value once instead of re-accessing `input`).
-    const varDeclLines = [];
-    for (const { key, varName, propSchema } of propInfo) {
-        if (shouldCacheVariable(propSchema, canFastPath, useRefImports)) {
-            varDeclLines.push(`  const ${varName} = ${safeAccessor('input', key)};`);
+  }
+  const warnLines = [];
+  if (logWarnings && propInfo.length > 0) {
+    const warnKeyCheck = unknownKeyCheck(propInfo.map(({ key }) => key), "_knownKeys");
+    for (const declaration of warnKeyCheck.declarations) {
+      warnLines.push(`  ${declaration};`);
+    }
+    warnLines.push(`  for (const _k in input) {`);
+    warnLines.push(`    if (${warnKeyCheck.isUnknown("_k")}) {`);
+    warnLines.push(`      console.warn(\`[${typeName}] Unknown property "\${_k}"\`);`);
+    warnLines.push(`    }`);
+    warnLines.push(`  }`);
+  }
+  const buildObjectLines = (directAssign) => {
+    const objectLines = [];
+    if (!stripKeys) {
+      objectLines.push("    ...input,");
+    }
+    if (useRefImports && isSchemaObject(schema) && hasAllOf(schema)) {
+      for (const entry of schema.allOf) {
+        if (isSchemaObject(entry) && hasRef(entry)) {
+          const parserName = generateParserName(refToName(entry.$ref, suffix));
+          objectLines.push(`    ...(${parserName}(input) as Record<string, unknown>),`);
         }
-    }
-    // Emit a warning for any input key not declared in the schema's properties.
-    const warnLines = [];
-    if (logWarnings && propInfo.length > 0) {
-        const warnKeyCheck = unknownKeyCheck(propInfo.map(({ key }) => key), '_knownKeys');
-        for (const declaration of warnKeyCheck.declarations) {
-            warnLines.push(`  ${declaration};`);
+      }
+    }
+    for (const { key, varName, isRequired, propSchema } of propInfo) {
+      const shouldCache = shouldCacheVariable(propSchema, canFastPath, useRefImports);
+      const accessor = shouldCache ? varName : safeAccessor("input", key);
+      const subName = subTypeNames.get(key);
+      if (subName) {
+        const subParserName = generateParserName(subName);
+        if (isRequired) {
+          objectLines.push(`    ${safeLiteralKey(key)}: ${subParserName}(${accessor}),`);
+        } else {
+          objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${subParserName}(${accessor}) }),`);
         }
-        warnLines.push(`  for (const _k in input) {`);
-        warnLines.push(`    if (${warnKeyCheck.isUnknown('_k')}) {`);
-        warnLines.push(`      console.warn(\`[${typeName}] Unknown property "\${_k}"\`);`);
-        warnLines.push(`    }`);
-        warnLines.push(`  }`);
-    }
-    // Builds the result object literal. `directAssign` (strict mode) assigns each
-    // field straight from its cached read — the guard or the per-property
-    // assertions have already proven the type, so no coercion ternary is needed.
-    // Coerce mode keeps the type-checking-and-coercing expression. Refs, arrays of
-    // refs, records of refs and inline nested objects always delegate to their
-    // parser in both modes; the input spread is dropped whenever stripping.
-    const buildObjectLines = (directAssign) => {
-        const objectLines = [];
-        if (!stripKeys) {
-            objectLines.push('    ...input,');
+        continue;
+      }
+      const itemSubName = subItemNames.get(key);
+      if (itemSubName) {
+        const itemParserName = generateParserName(itemSubName);
+        if (isRequired) {
+          objectLines.push(`    ${safeLiteralKey(key)}: validateArray(${accessor}, ${itemParserName}),`);
+        } else {
+          objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: validateArray(${accessor}, ${itemParserName}) }),`);
         }
-        // Spread allOf $ref parsers so their field coercions are applied before
-        // the explicit property validations below.
-        if (useRefImports && isSchemaObject(schema) && hasAllOf(schema)) {
-            for (const entry of schema.allOf) {
-                if (isSchemaObject(entry) && hasRef(entry)) {
-                    const parserName = generateParserName(refToName(entry.$ref, suffix));
-                    objectLines.push(`    ...(${parserName}(input) as Record<string, unknown>),`);
-                }
-            }
+        continue;
+      }
+      if (shouldUseRefImport(propSchema, useRefImports)) {
+        const ref = propSchema.$ref;
+        const parserName = generateParserName(refToName(ref, suffix));
+        if (isRequired) {
+          objectLines.push(`    ${safeLiteralKey(key)}: ${parserName}(${accessor}),`);
+        } else {
+          objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${parserName}(${accessor}) }),`);
         }
-        for (const { key, varName, isRequired, propSchema } of propInfo) {
-            const shouldCache = shouldCacheVariable(propSchema, canFastPath, useRefImports);
-            const accessor = shouldCache ? varName : safeAccessor('input', key);
-            // Handle inline nested objects via their private sub-parser, mirroring
-            // how $ref properties delegate to the imported parser.
-            const subName = subTypeNames.get(key);
-            if (subName) {
-                const subParserName = generateParserName(subName);
-                if (isRequired) {
-                    objectLines.push(`    ${safeLiteralKey(key)}: ${subParserName}(${accessor}),`);
-                }
-                else {
-                    objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${subParserName}(${accessor}) }),`);
-                }
-                continue;
-            }
-            // Arrays of inline objects run every element through the private item
-            // sub-parser, the same way arrays of $refs delegate via validateArray.
-            // In strict mode the item parser throws on a bad element; in coerce mode
-            // it repairs the element to a valid instance.
-            const itemSubName = subItemNames.get(key);
-            if (itemSubName) {
-                const itemParserName = generateParserName(itemSubName);
-                if (isRequired) {
-                    objectLines.push(`    ${safeLiteralKey(key)}: validateArray(${accessor}, ${itemParserName}),`);
-                }
-                else {
-                    objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: validateArray(${accessor}, ${itemParserName}) }),`);
-                }
-                continue;
-            }
-            // Handle direct $ref properties via imported parsers
-            if (shouldUseRefImport(propSchema, useRefImports)) {
-                const ref = propSchema.$ref;
-                const parserName = generateParserName(refToName(ref, suffix));
-                if (isRequired) {
-                    objectLines.push(`    ${safeLiteralKey(key)}: ${parserName}(${accessor}),`);
-                }
-                else {
-                    objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${parserName}(${accessor}) }),`);
-                }
-                continue;
-            }
-            // Handle array properties with $ref items
-            if (shouldUseArrayRefImport(propSchema, useRefImports)) {
-                const items = propSchema.items;
-                const ref = items.$ref;
-                const parserName = generateParserName(refToName(ref, suffix));
-                if (isRequired) {
-                    objectLines.push(`    ${safeLiteralKey(key)}: validateArray(${accessor}, ${parserName}),`);
-                }
-                else {
-                    objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: validateArray(${accessor}, ${parserName}) }),`);
-                }
-                continue;
-            }
-            // Handle object properties with additionalProperties $ref
-            if (shouldUseRecordRefImport(propSchema, useRefImports)) {
-                const additionalProps = propSchema.additionalProperties;
-                const ref = additionalProps.$ref;
-                const parserName = generateParserName(refToName(ref, suffix));
-                if (isRequired) {
-                    objectLines.push(`    ${safeLiteralKey(key)}: validateRecord(${accessor}, ${parserName}),`);
-                }
-                else {
-                    objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: validateRecord(${accessor}, ${parserName}) }),`);
-                }
-                continue;
-            }
-            // Handle non-schema-object properties
-            if (!isSchemaObject(propSchema)) {
-                if (isRequired) {
-                    objectLines.push(`    ${safeLiteralKey(key)}: undefined,`);
-                }
-                continue;
-            }
-            // Strict mode has already proven the value's type (by guard or assertion),
-            // so the field is assigned straight from the cached read with no coercion.
-            let valueExpr;
-            if (directAssign) {
-                valueExpr = accessor;
-            }
-            else {
-                const defaultValue = getDefaultValue(propSchema);
-                // For optional properties we know the value is not undefined because
-                // we're inside the `...(accessor !== undefined && { ... })` check.
-                const knownNotUndefined = !isRequired;
-                valueExpr = generateValidationExpression(key, propSchema, defaultValue, true, undefined, undefined, shouldCache ? varName : undefined, knownNotUndefined, caseInsensitive);
-            }
-            if (isRequired) {
-                objectLines.push(`    ${safeLiteralKey(key)}: ${valueExpr},`);
-            }
-            else {
-                objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${valueExpr} }),`);
-            }
+        continue;
+      }
+      if (shouldUseArrayRefImport(propSchema, useRefImports)) {
+        const items = propSchema.items;
+        const ref = items.$ref;
+        const parserName = generateParserName(refToName(ref, suffix));
+        if (isRequired) {
+          objectLines.push(`    ${safeLiteralKey(key)}: validateArray(${accessor}, ${parserName}),`);
+        } else {
+          objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: validateArray(${accessor}, ${parserName}) }),`);
         }
-        return objectLines;
-    };
-    const emitReturn = (lines, objectLines) => {
-        lines.push(`  return {`);
-        lines.push(objectLines.join('\n'));
-        lines.push(`  } as unknown as ${typeName};`);
-    };
-    // The deep-guard fast path. `{ ...input }` is the only correct shape when the
-    // guard let undeclared keys through (no known-keys term) — they must survive.
-    // But when `stripKeys` is set the guard *also* proved `_hasOnlyKnownKeys`, so
-    // the input's keys are exactly the declared properties: an explicit literal of
-    // those keys is then equivalent to the spread, and faster — a fixed-shape
-    // literal beats a generic spread, yields a stable hidden class, and produces
-    // the same declared key order as the slow path (the spread used input order).
-    // The literal shares each value by reference, exactly like the spread did, so
-    // it never re-parses an already-validated nested object. allOf merges in
-    // properties this `propInfo` list doesn't carry, so it keeps the spread.
-    const emitDeepGuardReturn = (lines) => {
-        const canLiteral = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema));
-        if (!canLiteral) {
-            lines.push(`  if (${deepGuard}) return { ...input } as ${typeName};`);
-            return;
+        continue;
+      }
+      if (shouldUseRecordRefImport(propSchema, useRefImports)) {
+        const additionalProps = propSchema.additionalProperties;
+        const ref = additionalProps.$ref;
+        const parserName = generateParserName(refToName(ref, suffix));
+        if (isRequired) {
+          objectLines.push(`    ${safeLiteralKey(key)}: validateRecord(${accessor}, ${parserName}),`);
+        } else {
+          objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: validateRecord(${accessor}, ${parserName}) }),`);
         }
-        // A *private* (nested-object / array-item) parser whose deep guard proved
-        // the input is exactly the declared shape — typed checks plus the
-        // no-undeclared-keys term, recursively via sub-predicates — can hand the
-        // input back by reference instead of allocating a literal. That is the
-        // same sharing the parent's own fast-path literal performs (`items:
-        // _items`), and it is what keeps clean array elements allocation-free.
-        // Exported root parsers keep returning a fresh object so callers never
-        // alias the value they passed in.
-        if (!exported) {
-            lines.push(`  if (${deepGuard}) return input as ${typeName};`);
-            return;
+        continue;
+      }
+      if (!isSchemaObject(propSchema)) {
+        if (isRequired) {
+          objectLines.push(`    ${safeLiteralKey(key)}: undefined,`);
         }
-        const fields = [];
-        for (const { key, varName, isRequired, propSchema } of propInfo) {
-            if (!isSchemaObject(propSchema)) {
-                if (isRequired)
-                    fields.push(`    ${safeLiteralKey(key)}: undefined,`);
-                continue;
-            }
-            const accessor = shouldCacheVariable(propSchema, canFastPath, useRefImports)
-                ? varName
-                : safeAccessor('input', key);
-            fields.push(isRequired
-                ? `    ${safeLiteralKey(key)}: ${accessor},`
-                : `    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${accessor} }),`);
+        continue;
+      }
+      let valueExpr;
+      if (directAssign) {
+        valueExpr = accessor;
+      } else {
+        const defaultValue = getDefaultValue(propSchema);
+        const knownNotUndefined = !isRequired;
+        valueExpr = generateValidationExpression(key, propSchema, defaultValue, true, void 0, void 0, shouldCache ? varName : void 0, knownNotUndefined, caseInsensitive);
+      }
+      if (isRequired) {
+        objectLines.push(`    ${safeLiteralKey(key)}: ${valueExpr},`);
+      } else {
+        objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${valueExpr} }),`);
+      }
+    }
+    return objectLines;
+  };
+  const emitReturn = (lines2, objectLines) => {
+    lines2.push(`  return {`);
+    lines2.push(objectLines.join("\n"));
+    lines2.push(`  } as unknown as ${typeName};`);
+  };
+  const emitDeepGuardReturn = (lines2) => {
+    const canLiteral = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema));
+    if (!canLiteral) {
+      lines2.push(`  if (${deepGuardExpr}) return { ...input } as ${typeName};`);
+      return;
+    }
+    if (!exported) {
+      lines2.push(`  if (${deepGuardExpr}) return input as ${typeName};`);
+      return;
+    }
+    const fields = [];
+    for (const { key, varName, isRequired, propSchema } of propInfo) {
+      if (!isSchemaObject(propSchema)) {
+        if (isRequired)
+          fields.push(`    ${safeLiteralKey(key)}: undefined,`);
+        continue;
+      }
+      const accessor = shouldCacheVariable(propSchema, canFastPath, useRefImports) ? varName : safeAccessor("input", key);
+      fields.push(isRequired ? `    ${safeLiteralKey(key)}: ${accessor},` : `    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${accessor} }),`);
+    }
+    lines2.push(`  if (${deepGuardExpr}) return {`);
+    lines2.push(fields.join("\n"));
+    lines2.push(`  } as ${typeName};`);
+  };
+  const lines = [];
+  lines.push(`${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {`);
+  const varsAfterGuard = deepGuardCallsShape && shallowGuard === null;
+  if (strict) {
+    lines.push(`  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`);
+    if (!varsAfterGuard)
+      lines.push(...varDeclLines);
+    lines.push(...warnLines);
+    const assertionLines = generateObjectStrictAssertion(schema, typeName, {
+      useRefImports,
+      suffix,
+      stripUnknown,
+      ...rootSchema !== void 0 ? { rootSchema } : {}
+    }).slice(1);
+    if (shallowGuard) {
+      if (!exported && deepGuard) {
+        const residual = [];
+        for (let i = 0; i < fastPathChecks.length; i++) {
+          const deep = fastPathChecks[i];
+          const shallow = shallowChecks[i];
+          if (deep === shallow)
+            continue;
+          residual.push(shallow !== void 0 && deep.startsWith(`${shallow} && `) ? deep.slice(shallow.length + 4) : deep);
         }
-        lines.push(`  if (${deepGuard}) return {`);
-        lines.push(fields.join('\n'));
-        lines.push(`  } as ${typeName};`);
-    };
-    const lines = [];
-    lines.push(`${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {`);
-    if (strict) {
-        // Guard first: a non-object throws straight away; a clean, well-typed input
-        // then short-circuits past the per-property assertions, which only run to
-        // pinpoint the failure when the guard rejects the input.
-        lines.push(`  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`);
-        lines.push(...varDeclLines);
-        lines.push(...warnLines);
-        // The first assertion line is the `isObject` check, already done above.
-        const assertionLines = generateObjectStrictAssertion(schema, typeName, {
-            useRefImports,
-            suffix,
-            stripUnknown,
-            ...(rootSchema !== undefined ? { rootSchema } : {}),
-        }).slice(1);
-        if (shallowGuard) {
-            // A private sub-parser hands input that is already exactly the declared
-            // shape (no extras at any level) back by reference, so a clean array
-            // element or nested object costs no allocation. The deep guard is
-            // evaluated as the shallow guard plus only its *residual* terms (deeper
-            // per-property checks and the no-extras term), so a carries-extras input
-            // never runs the same typed checks twice before taking the strip build.
-            if (!exported && deepGuard) {
-                const residual = [];
-                for (let i = 0; i < fastPathChecks.length; i++) {
-                    const deep = fastPathChecks[i];
-                    const shallow = shallowChecks[i];
-                    if (deep === shallow)
-                        continue;
-                    // When the deep check extends the shallow one by conjunction (e.g.
-                    // `Array.isArray(_x) && _everyItem(_x)`), the shallow guard already
-                    // proved the prefix — re-evaluating it per clean parse was pure
-                    // waste on the hot path, so only the extension joins the residual.
-                    residual.push(shallow !== undefined && deep.startsWith(`${shallow} && `) ? deep.slice(shallow.length + 4) : deep);
-                }
-                lines.push(`  if (${shallowGuard}) {`);
-                lines.push(residual.length > 0
-                    ? `    if (${residual.join(' && ')}) return input as ${typeName};`
-                    : `    return input as ${typeName};`);
-                lines.push(`  } else {`);
-                for (const assertionLine of assertionLines) {
-                    lines.push(`  ${assertionLine}`);
-                }
-                lines.push(`  }`);
-            }
-            else {
-                // stripUnknown: a well-typed input skips the assertions and goes
-                // straight to the strip build (which removes extras and recurses into
-                // sub-parsers).
-                lines.push(`  if (!(${shallowGuard})) {`);
-                for (const assertionLine of assertionLines) {
-                    lines.push(`  ${assertionLine}`);
-                }
-                lines.push(`  }`);
-            }
-            emitReturn(lines, buildObjectLines(true));
+        lines.push(`  if (${shallowGuard}) {`);
+        lines.push(residual.length > 0 ? `    if (${residual.join(" && ")}) return input as ${typeName};` : `    return input as ${typeName};`);
+        lines.push(`  } else {`);
+        for (const assertionLine of assertionLines) {
+          lines.push(`  ${assertionLine}`);
         }
-        else {
-            if (deepGuard) {
-                emitDeepGuardReturn(lines);
-            }
-            for (const assertionLine of assertionLines) {
-                lines.push(assertionLine);
-            }
-            if (strictKeys) {
-                // for..in (not Object.keys) deliberately: this loop is cold — the fast
-                // path already proved the key set — but swapping in the keys-array
-                // iterator here once regressed the *hot* path several percent on CI:
-                // the extra dead-path bytecode changed the engine's inlining of the
-                // whole parser. The fast-path no-extras test uses own-key semantics;
-                // an inherited-key mismatch merely lands here and keeps the historical
-                // for..in rejection.
-                lines.push(`  for (const _k in input) {`);
-                lines.push(`    if (${strictKeyCheck.isUnknown('_k')}) throw new Error(\`[${typeName}] unknown property "\${_k}"\`);`);
-                lines.push(`  }`);
-            }
-            emitReturn(lines, buildObjectLines(true));
+        lines.push(`  }`);
+      } else {
+        lines.push(`  if (!(${shallowGuard})) {`);
+        for (const assertionLine of assertionLines) {
+          lines.push(`  ${assertionLine}`);
         }
-    }
-    else {
-        lines.push(`  if (!isObject(input)) return ${fallbackObject};`);
+        lines.push(`  }`);
+      }
+      emitReturn(lines, buildObjectLines(true));
+    } else {
+      if (deepGuard) {
+        emitDeepGuardReturn(lines);
+      }
+      if (varsAfterGuard)
         lines.push(...varDeclLines);
-        lines.push(...warnLines);
-        if (deepGuard) {
-            emitDeepGuardReturn(lines);
-        }
-        emitReturn(lines, buildObjectLines(false));
-    }
-    lines.push(`}`);
-    const fn = lines.join('\n');
-    if (preamble.length === 0)
-        return fn;
-    return `${preamble.join('\n\n')}\n\n${fn}`;
+      for (const assertionLine of assertionLines) {
+        lines.push(assertionLine);
+      }
+      if (strictKeys) {
+        lines.push(`  for (const _k in input) {`);
+        lines.push(`    if (${strictKeyCheck.isUnknown("_k")}) throw new Error(\`[${typeName}] unknown property "\${_k}"\`);`);
+        lines.push(`  }`);
+      }
+      emitReturn(lines, buildObjectLines(true));
+    }
+  } else {
+    lines.push(`  if (!isObject(input)) return ${fallbackObject};`);
+    if (!varsAfterGuard)
+      lines.push(...varDeclLines);
+    lines.push(...warnLines);
+    if (deepGuard) {
+      emitDeepGuardReturn(lines);
+    }
+    if (varsAfterGuard)
+      lines.push(...varDeclLines);
+    emitReturn(lines, buildObjectLines(false));
+  }
+  lines.push(`}`);
+  const fn = lines.join("\n");
+  if (preamble.length === 0)
+    return fn;
+  return `${preamble.join("\n\n")}
+
+${fn}`;
 };
-/**
- * Combined-parser variant for `properties` + `patternProperties` schemas that
- * set `additionalProperties: false`. Declared properties are coerced as usual,
- * keys matching any pattern are kept (the first `$ref` pattern is coerced via
- * its imported parser when ref imports are on), and every other key is rejected
- * in strict mode or stripped in coerce mode — matching the interpreter.
- */
-/**
- * Emits a prototype-safe `result[key] = value` for the dynamic `for..in` copy
- * loops in the pattern-property parsers. A bare `result[key] = v` is a `[[Set]]`
- * — and for the key `"__proto__"` (own-enumerable when the input came from
- * `JSON.parse`) it invokes the inherited `Object.prototype` setter and reassigns
- * `result`'s prototype to attacker-controlled data, the same vector
- * `validateRecord` guards against. `"__proto__"` is the only own-enumerable key
- * whose name resolves to an accessor on `Object.prototype` (`constructor` et al.
- * are writable data properties, so a `[[Set]]` there just creates an own key),
- * so a single-keyed guard is sufficient. Each loop already runs a `.test(key)`
- * regex per iteration, which dominates the cost, so the extra `===` on the
- * common path is immeasurable. Assumes the target variable is named `result`,
- * as it is in every parser that calls this.
- */
 const safeResultAssign = (keyVar, valueExpr) => `if (${keyVar} === "__proto__") { Object.defineProperty(result, ${keyVar}, { value: ${valueExpr}, writable: true, enumerable: true, configurable: true }); } else { (result as Record<string, unknown>)[${keyVar}] = ${valueExpr}; }`;
 const generateStrictCombinedParser = (schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict) => {
-    const declaredKeys = hasProperties(schema) ? Object.keys(schema.properties) : [];
-    // Below the inline threshold a key === "a" || key === "b" chain skips declared
-    // keys without the per-call Set allocation; a wider list hoists the Set.
-    const knownKeyCheck = unknownKeyCheck(declaredKeys, '_knownKeys');
-    // The first $ref pattern (when ref imports are on) coerces its matching values
-    // through the imported parser; the remaining patterns keep the raw value.
-    const refPattern = useRefImports ? patterns.find(([, ps]) => isSchemaObject(ps) && hasRef(ps)) : undefined;
-    const loopLines = [`    if (${knownKeyCheck.isKnown('key')}) continue;`];
-    if (refPattern) {
-        const parserName = generateParserName(refToName(refPattern[1].$ref, suffix));
-        loopLines.push(`    if (/${escapeRegexPattern(refPattern[0])}/.test(key)) {`);
-        loopLines.push(`      ${safeResultAssign('key', `${parserName}(input[key])`)}`);
-        loopLines.push(`      continue;`);
-        loopLines.push(`    }`);
-    }
-    const keepConditions = patterns
-        .filter(([p]) => !(refPattern && p === refPattern[0]))
-        .map(([p]) => `/${escapeRegexPattern(p)}/.test(key)`);
-    if (keepConditions.length > 0) {
-        loopLines.push(`    if (${keepConditions.join(' || ')}) {`);
-        loopLines.push(`      ${safeResultAssign('key', 'input[key]')}`);
-        loopLines.push(`      continue;`);
-        loopLines.push(`    }`);
-    }
-    // Unknown key: throw in strict mode, otherwise let it fall through (dropped,
-    // since it was never copied into `result`).
-    if (strict)
-        loopLines.push(`    throw new Error(\`[${typeName}] unknown property "\${key}"\`);`);
-    const notObjectBranch = strict
-        ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`
-        : `    return {} as unknown as ${typeName};`;
-    const resultBody = propertyLines.length > 0 ? `{\n${propertyLines.join('\n')}\n  }` : '{}';
-    // Only the Set form needs a declaration; the inline === chain is stateless.
-    const knownKeysDeclaration = knownKeyCheck.declarations.map((decl) => `  ${decl};\n`).join('');
-    // In strict mode assert the declared properties (type, required, enum,
-    // constraints) — the `result` below is built from the *coercing* property
-    // lines, which silently repair a wrong type and default a missing required key
-    // instead of throwing. `generateObjectStrictAssertion` throws first; the
-    // coercing build then runs only on already-valid input (a no-op there). It also
-    // covers the object-level keyword checks, so it replaces the keyword-only
-    // prelude. `.slice(1)` drops its `isObject` check (emitted just below). Coerce
-    // mode (stripUnknown) keeps its lighter prelude.
-    const assertionPrelude = strict
-        ? generateObjectStrictAssertion(schema, typeName, { useRefImports, suffix }).slice(1)
-        : [];
-    const keywordPrelude = assertionPrelude.length > 0 ? `\n${assertionPrelude.join('\n')}` : '';
-    return `export const ${functionName} = (input: unknown): ${typeName} => {
+  const declaredKeys = hasProperties(schema) ? Object.keys(schema.properties) : [];
+  const knownKeyCheck = unknownKeyCheck(declaredKeys, "_knownKeys");
+  const refPattern = useRefImports ? patterns.find(([, ps]) => isSchemaObject(ps) && hasRef(ps)) : void 0;
+  const loopLines = [`    if (${knownKeyCheck.isKnown("key")}) continue;`];
+  if (refPattern) {
+    const parserName = generateParserName(refToName(refPattern[1].$ref, suffix));
+    loopLines.push(`    if (/${escapeRegexPattern(refPattern[0])}/.test(key)) {`);
+    loopLines.push(`      ${safeResultAssign("key", `${parserName}(input[key])`)}`);
+    loopLines.push(`      continue;`);
+    loopLines.push(`    }`);
+  }
+  const keepConditions = patterns.filter(([p]) => !(refPattern && p === refPattern[0])).map(([p]) => `/${escapeRegexPattern(p)}/.test(key)`);
+  if (keepConditions.length > 0) {
+    loopLines.push(`    if (${keepConditions.join(" || ")}) {`);
+    loopLines.push(`      ${safeResultAssign("key", "input[key]")}`);
+    loopLines.push(`      continue;`);
+    loopLines.push(`    }`);
+  }
+  if (strict)
+    loopLines.push(`    throw new Error(\`[${typeName}] unknown property "\${key}"\`);`);
+  const notObjectBranch = strict ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);` : `    return {} as unknown as ${typeName};`;
+  const resultBody = propertyLines.length > 0 ? `{
+${propertyLines.join("\n")}
+  }` : "{}";
+  const knownKeysDeclaration = knownKeyCheck.declarations.map((decl) => `  ${decl};
+`).join("");
+  const assertionPrelude = strict ? generateObjectStrictAssertion(schema, typeName, { useRefImports, suffix }).slice(1) : [];
+  const keywordPrelude = assertionPrelude.length > 0 ? `
+${assertionPrelude.join("\n")}` : "";
+  return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) {
 ${notObjectBranch}
   }${keywordPrelude}
 ${knownKeysDeclaration}  const result = ${resultBody} as unknown as ${typeName};
   for (const key in input) {
-${loopLines.join('\n')}
+${loopLines.join("\n")}
   }
   return result;
 };`;
 };
-/**
- * Generates a parser for schemas that have both properties AND patternProperties.
- * Parses the known properties first, then iterates remaining keys to match patterns.
- */
 const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown = false, caseInsensitive = false) => {
-    const functionName = generateParserName(typeName);
-    const entries = generatePropertyEntries(schema, useRefImports, suffix, caseInsensitive);
-    // Build the known property lines for the initial object
-    const propertyLines = entries.map((entry) => {
-        if (entry.isOptional) {
-            return `    ${entry.value},`;
-        }
-        return `    ${safeLiteralKey(entry.key)}: ${entry.value},`;
-    });
-    // Find the first pattern with a $ref for parser delegation
-    if (!isSchemaObject(schema) || !('patternProperties' in schema)) {
-        return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, undefined, NO_RESERVED_NAMES, caseInsensitive);
-    }
-    const patternProps = schema.patternProperties;
-    const patterns = Object.entries(patternProps);
-    const refPattern = patterns.find(([, ps]) => isSchemaObject(ps) && hasRef(ps));
-    const strictKeys = hasAdditionalProperties(schema) && schema.additionalProperties === false;
-    // With `additionalProperties: false`, keys matching neither a declared
-    // property nor any pattern must be rejected (strict) or stripped (coerce).
-    // The blanket `...input` spread used below cannot do that, so build a
-    // selective copy that mirrors the interpreter's undeclared-key handling.
-    if (strictKeys) {
-        return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict);
-    }
-    // `stripUnknown` (coerce mode) must keep keys a `patternProperties` regex
-    // declares and drop only the genuinely-undeclared ones. Delegating to
-    // `generateObjectParser` below would strip the pattern-matching keys too — its
-    // strip logic only knows the declared `properties`. The selective combined
-    // copy keeps declared + pattern-matching keys, exactly like the interpreter.
-    if (stripUnknown && !strict) {
-        return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, false);
-    }
-    if (!refPattern || !useRefImports) {
-        return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, undefined, NO_RESERVED_NAMES, caseInsensitive);
-    }
-    const [pattern, patternSchema] = refPattern;
-    const ref = patternSchema.$ref;
-    const parserName = generateParserName(refToName(ref, suffix));
-    const assignmentCode = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
-    const escapedPattern = escapeRegexPattern(pattern);
-    const inputSpread = '    ...input,';
-    let objectProperties = inputSpread;
-    if (propertyLines.length > 0) {
-        for (const line of propertyLines) {
-            objectProperties += '\n' + line;
-        }
+  const functionName = generateParserName(typeName);
+  const entries = generatePropertyEntries(schema, useRefImports, suffix, caseInsensitive);
+  const propertyLines = entries.map((entry) => {
+    if (entry.isOptional) {
+      return `    ${entry.value},`;
+    }
+    return `    ${safeLiteralKey(entry.key)}: ${entry.value},`;
+  });
+  if (!isSchemaObject(schema) || !("patternProperties" in schema)) {
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive);
+  }
+  const patternProps = schema.patternProperties;
+  const patterns = Object.entries(patternProps);
+  const refPattern = patterns.find(([, ps]) => isSchemaObject(ps) && hasRef(ps));
+  const strictKeys = hasAdditionalProperties(schema) && schema.additionalProperties === false;
+  if (strictKeys) {
+    return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict);
+  }
+  if (stripUnknown && !strict) {
+    return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, false);
+  }
+  if (!refPattern || !useRefImports) {
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive);
+  }
+  const [pattern, patternSchema] = refPattern;
+  const ref = patternSchema.$ref;
+  const parserName = generateParserName(refToName(ref, suffix));
+  const assignmentCode = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
+  const escapedPattern = escapeRegexPattern(pattern);
+  const inputSpread = "    ...input,";
+  let objectProperties = inputSpread;
+  if (propertyLines.length > 0) {
+    for (const line of propertyLines) {
+      objectProperties += "\n" + line;
     }
-    const notObjectBranch = strict
-        ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`
-        : `    return {} as unknown as ${typeName};`;
-    const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName) : '';
-    return `export const ${functionName} = (input: unknown): ${typeName} => {
+  }
+  const notObjectBranch = strict ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);` : `    return {} as unknown as ${typeName};`;
+  const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName) : "";
+  return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) {
 ${notObjectBranch}
   }${keywordPrelude}
@@ -1350,162 +919,135 @@ ${objectProperties}
   return result;
 };`;
 };
-/**
- * Generates a parser for schemas with additionalProperties.
- */
 const generateAdditionalPropertiesParser = (schema, typeName, useRefImports, suffix, strict) => {
-    const functionName = generateParserName(typeName);
-    const additionalProps = schema.additionalProperties;
-    // Check if additionalProps is defined before using it
-    if (!additionalProps) {
-        return generateEmptyObjectParser(typeName, strict, schema);
-    }
-    const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName) : '';
-    // If additionalProperties is a $ref and useRefImports is true, generate a loop
-    if (useRefImports && isSchemaObject(additionalProps) && hasRef(additionalProps)) {
-        const ref = additionalProps.$ref;
-        const parserName = generateParserName(refToName(ref, suffix));
-        if (strict) {
-            return `export const ${functionName} = (input: unknown): ${typeName} => {\n  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${keywordPrelude}\n  return validateRecord(input, ${parserName}) as ${typeName};\n};`;
-        }
-        return `export const ${functionName} = (input: unknown): ${typeName} => validateRecord(input, ${parserName}) as ${typeName};`;
-    }
-    // Handle additionalProperties with a known type by generating inline validation
-    if (isSchemaObject(additionalProps) && hasType(additionalProps)) {
-        const inlineParser = generateInlineValueParser(additionalProps, strict, `[${typeName}]`);
-        if (inlineParser) {
-            if (strict) {
-                return `export const ${functionName} = (input: unknown): ${typeName} => {\n  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${keywordPrelude}\n  return validateRecord(input, ${inlineParser}) as ${typeName};\n};`;
-            }
-            return `export const ${functionName} = (input: unknown): ${typeName} => validateRecord(input, ${inlineParser}) as ${typeName};`;
-        }
-    }
-    // Otherwise, just validate the input type and shallow copy
+  const functionName = generateParserName(typeName);
+  const additionalProps = schema.additionalProperties;
+  if (!additionalProps) {
+    return generateEmptyObjectParser(typeName, strict, schema);
+  }
+  const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName) : "";
+  if (useRefImports && isSchemaObject(additionalProps) && hasRef(additionalProps)) {
+    const ref = additionalProps.$ref;
+    const parserName = generateParserName(refToName(ref, suffix));
     if (strict) {
-        return `export const ${functionName} = (input: unknown): ${typeName} => {\n  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${keywordPrelude}\n  return { ...input } as ${typeName};\n};`;
-    }
-    return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? { ...input } as ${typeName} : {};`;
-};
-/**
- * Generates an inline arrow function that validates a single value based on
- * the additionalProperties schema type. Returns null if the type is not supported.
- *
- * Used to generate parsers for Record-like types where values have a known
- * primitive or array type (e.g. Record<string, string> or Record<string, string[]>).
- */
-const generateInlineValueParser = (schema, strict = false, label = '') => {
-    if (!isSchemaObject(schema) || !hasType(schema)) {
-        return null;
+      return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${keywordPrelude}
+  return validateRecord(input, ${parserName}) as ${typeName};
+};`;
     }
-    // Strict mode must *throw* on a wrong-typed record value, not repair it — the
-    // coercing branch below would silently turn `{ a: 'x' }` into `{ a: 0 }` for a
-    // `Record<string, number>`, which strict mode is documented never to do.
-    if (strict) {
-        const err = (t) => `throw new Error(${JSON.stringify(`${label} record value must be ${t}`)})`;
-        switch (schema.type) {
-            case 'string':
-                return `(value: unknown) => { if (typeof value !== "string") ${err('string')}; return value; }`;
-            case 'number':
-                return `(value: unknown) => { if (typeof value !== "number") ${err('number')}; return value; }`;
-            case 'integer':
-                return `(value: unknown) => { if (typeof value !== "number" || !Number.isInteger(value)) ${err('integer')}; return value; }`;
-            case 'boolean':
-                return `(value: unknown) => { if (typeof value !== "boolean") ${err('boolean')}; return value; }`;
-            case 'array':
-                return `(value: unknown) => { if (!Array.isArray(value)) ${err('array')}; return value; }`;
-            default:
-                return null;
-        }
+    return `export const ${functionName} = (input: unknown): ${typeName} => validateRecord(input, ${parserName}) as ${typeName};`;
+  }
+  if (isSchemaObject(additionalProps) && hasType(additionalProps)) {
+    const inlineParser = generateInlineValueParser(additionalProps, strict, `[${typeName}]`);
+    if (inlineParser) {
+      if (strict) {
+        return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${keywordPrelude}
+  return validateRecord(input, ${inlineParser}) as ${typeName};
+};`;
+      }
+      return `export const ${functionName} = (input: unknown): ${typeName} => validateRecord(input, ${inlineParser}) as ${typeName};`;
     }
+  }
+  if (strict) {
+    return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${keywordPrelude}
+  return { ...input } as ${typeName};
+};`;
+  }
+  return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? { ...input } as ${typeName} : {};`;
+};
+const generateInlineValueParser = (schema, strict = false, label = "") => {
+  if (!isSchemaObject(schema) || !hasType(schema)) {
+    return null;
+  }
+  if (strict) {
+    const err = (t) => `throw new Error(${JSON.stringify(`${label} record value must be ${t}`)})`;
     switch (schema.type) {
-        case 'string':
-            return '(value: unknown) => typeof value === "string" ? value : ""';
-        case 'number':
-            return '(value: unknown) => typeof value === "number" ? value : 0';
-        case 'integer':
-            // `integer` rejects non-integral numbers; a bare typeof accepts `1.5`,
-            // matching every other integer site in this package (and strict mode).
-            return '(value: unknown) => typeof value === "number" && Number.isInteger(value) ? value : 0';
-        case 'boolean':
-            return '(value: unknown) => typeof value === "boolean" ? value : false';
-        case 'array':
-            return '(value: unknown) => Array.isArray(value) ? value : []';
-        default:
-            return null;
+      case "string":
+        return `(value: unknown) => { if (typeof value !== "string") ${err("string")}; return value; }`;
+      case "number":
+        return `(value: unknown) => { if (typeof value !== "number") ${err("number")}; return value; }`;
+      case "integer":
+        return `(value: unknown) => { if (typeof value !== "number" || !Number.isInteger(value)) ${err("integer")}; return value; }`;
+      case "boolean":
+        return `(value: unknown) => { if (typeof value !== "boolean") ${err("boolean")}; return value; }`;
+      case "array":
+        return `(value: unknown) => { if (!Array.isArray(value)) ${err("array")}; return value; }`;
+      default:
+        return null;
     }
+  }
+  switch (schema.type) {
+    case "string":
+      return '(value: unknown) => typeof value === "string" ? value : ""';
+    case "number":
+      return '(value: unknown) => typeof value === "number" ? value : 0';
+    case "integer":
+      return '(value: unknown) => typeof value === "number" && Number.isInteger(value) ? value : 0';
+    case "boolean":
+      return '(value: unknown) => typeof value === "boolean" ? value : false';
+    case "array":
+      return "(value: unknown) => Array.isArray(value) ? value : []";
+    default:
+      return null;
+  }
 };
-/**
- * Generates a parser for schemas with patternProperties.
- * Handles both patternProperties and specification-extensions (x- prefix).
- */
 const generatePatternPropertiesParser = (schema, typeName, useRefImports, suffix, strict) => {
-    const functionName = generateParserName(typeName);
-    if (!('patternProperties' in schema) || typeof schema.patternProperties !== 'object') {
-        return generateEmptyObjectParser(typeName, strict, schema);
-    }
-    const patternProps = schema.patternProperties;
-    // Find the first pattern and its schema
-    const patterns = Object.entries(patternProps);
-    if (patterns.length === 0) {
-        return generateEmptyObjectParser(typeName, strict, schema);
-    }
-    const [pattern, patternSchema] = patterns[0];
-    let patternAssignment = '(result as Record<string, unknown>)[key] = value;';
-    // The value-expression form, used by the strictKeys path (which builds from
-    // `{}`) to emit a prototype-safe assignment. `null` when no value is allowed.
-    let patternValueExpr = 'value';
-    // Use imported parser when pattern schema points to a $ref.
-    if (useRefImports && isSchemaObject(patternSchema) && hasRef(patternSchema)) {
-        const ref = patternSchema.$ref;
-        const parserName = generateParserName(refToName(ref, suffix));
-        patternAssignment = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
-        patternValueExpr = `${parserName}(value)`;
-    }
-    else if (patternSchema === false) {
-        // `false` means no values are allowed for matching keys.
-        patternAssignment = '';
-        patternValueExpr = null;
+  const functionName = generateParserName(typeName);
+  if (!("patternProperties" in schema) || typeof schema.patternProperties !== "object") {
+    return generateEmptyObjectParser(typeName, strict, schema);
+  }
+  const patternProps = schema.patternProperties;
+  const patterns = Object.entries(patternProps);
+  if (patterns.length === 0) {
+    return generateEmptyObjectParser(typeName, strict, schema);
+  }
+  const [pattern, patternSchema] = patterns[0];
+  let patternAssignment = "(result as Record<string, unknown>)[key] = value;";
+  let patternValueExpr = "value";
+  if (useRefImports && isSchemaObject(patternSchema) && hasRef(patternSchema)) {
+    const ref = patternSchema.$ref;
+    const parserName = generateParserName(refToName(ref, suffix));
+    patternAssignment = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
+    patternValueExpr = `${parserName}(value)`;
+  } else if (patternSchema === false) {
+    patternAssignment = "";
+    patternValueExpr = null;
+  }
+  const escapedPattern = escapeRegexPattern(pattern);
+  const notObjectBranch = strict ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);` : `    return {} as unknown as ${typeName};`;
+  const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName) : "";
+  const strictKeys = hasAdditionalProperties(schema) && schema.additionalProperties === false;
+  if (strictKeys) {
+    const loopLines = [`    if (/${escapedPattern}/.test(key)) {`];
+    if (patternValueExpr) {
+      loopLines.push(`      const value = input[key];`);
+      loopLines.push(`      ${safeResultAssign("key", patternValueExpr)}`);
+    }
+    loopLines.push(`      continue;`);
+    loopLines.push(`    }`);
+    const keepConditions = patterns.slice(1).map(([p]) => `/${escapeRegexPattern(p)}/.test(key)`);
+    if (keepConditions.length > 0) {
+      loopLines.push(`    if (${keepConditions.join(" || ")}) {`);
+      loopLines.push(`      ${safeResultAssign("key", "input[key]")}`);
+      loopLines.push(`      continue;`);
+      loopLines.push(`    }`);
     }
-    // Escape the pattern for safe inclusion in generated code
-    const escapedPattern = escapeRegexPattern(pattern);
-    const notObjectBranch = strict
-        ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`
-        : `    return {} as unknown as ${typeName};`;
-    const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName) : '';
-    // With `additionalProperties: false`, only keys matching a pattern survive:
-    // others are rejected (strict) or stripped (coerce). Start from an empty
-    // object rather than spreading every input key.
-    const strictKeys = hasAdditionalProperties(schema) && schema.additionalProperties === false;
-    if (strictKeys) {
-        const loopLines = [`    if (/${escapedPattern}/.test(key)) {`];
-        if (patternValueExpr) {
-            loopLines.push(`      const value = input[key];`);
-            loopLines.push(`      ${safeResultAssign('key', patternValueExpr)}`);
-        }
-        loopLines.push(`      continue;`);
-        loopLines.push(`    }`);
-        const keepConditions = patterns.slice(1).map(([p]) => `/${escapeRegexPattern(p)}/.test(key)`);
-        if (keepConditions.length > 0) {
-            loopLines.push(`    if (${keepConditions.join(' || ')}) {`);
-            loopLines.push(`      ${safeResultAssign('key', 'input[key]')}`);
-            loopLines.push(`      continue;`);
-            loopLines.push(`    }`);
-        }
-        if (strict)
-            loopLines.push(`    throw new Error(\`[${typeName}] unknown property "\${key}"\`);`);
-        return `export const ${functionName} = (input: unknown): ${typeName} => {
+    if (strict)
+      loopLines.push(`    throw new Error(\`[${typeName}] unknown property "\${key}"\`);`);
+    return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) {
 ${notObjectBranch}
   }${keywordPrelude}
   const result = {} as unknown as ${typeName};
   for (const key in input) {
-${loopLines.join('\n')}
+${loopLines.join("\n")}
   }
   return result;
 };`;
-    }
-    // Generate a parser that handles both pattern matching and x- extensions
-    return `export const ${functionName} = (input: unknown): ${typeName} => {
+  }
+  return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) {
 ${notObjectBranch}
   }${keywordPrelude}
@@ -1521,117 +1063,91 @@ ${notObjectBranch}
   return result;
 };`;
 };
-/**
- * Generates a parser for conditional schemas with if/then/else.
- * This always generates parser calls regardless of useRefImports setting,
- * because conditional logic requires delegating to the appropriate parser.
- */
 const generateConditionalParser = (schema, typeName, suffix, stripUnknown = false, caseInsensitive = false) => {
-    const functionName = generateParserName(typeName);
-    // Extract the condition and branches
-    const ifSchema = schema.if;
-    const thenSchema = schema.then;
-    const elseSchema = schema.else;
-    // Check if branches are defined and have $ref
-    const thenHasRef = thenSchema && isSchemaObject(thenSchema) && hasRef(thenSchema);
-    const elseHasRef = elseSchema && isSchemaObject(elseSchema) && hasRef(elseSchema);
-    if (!thenHasRef || !elseHasRef) {
-        // Non-$ref branches (e.g. if/then/else providing defaults for properties).
-        // Flatten all three branches into a single object schema and generate a
-        // regular object parser from the merged property set.
-        const mergedSchema = getConditionalObjectSchema(schema);
-        if (mergedSchema) {
-            return generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown, undefined, NO_RESERVED_NAMES, caseInsensitive);
-        }
-        return generateEmptyObjectParser(typeName);
-    }
-    // Check if the condition is checking for $ref property
-    const isRefCondition = ifSchema &&
-        isSchemaObject(ifSchema) &&
-        'required' in ifSchema &&
-        Array.isArray(ifSchema.required) &&
-        ifSchema.required.includes('$ref');
-    if (!isRefCondition) {
-        // Condition is not a $ref check — flatten into an object parser
-        const mergedSchema = getConditionalObjectSchema(schema);
-        if (mergedSchema) {
-            return generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown, undefined, NO_RESERVED_NAMES, caseInsensitive);
-        }
-        return generateEmptyObjectParser(typeName);
+  const functionName = generateParserName(typeName);
+  const ifSchema = schema.if;
+  const thenSchema = schema.then;
+  const elseSchema = schema.else;
+  const thenHasRef = thenSchema && isSchemaObject(thenSchema) && hasRef(thenSchema);
+  const elseHasRef = elseSchema && isSchemaObject(elseSchema) && hasRef(elseSchema);
+  if (!thenHasRef || !elseHasRef) {
+    const mergedSchema = getConditionalObjectSchema(schema);
+    if (mergedSchema) {
+      return generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive);
+    }
+    return generateEmptyObjectParser(typeName);
+  }
+  const isRefCondition = ifSchema && isSchemaObject(ifSchema) && "required" in ifSchema && Array.isArray(ifSchema.required) && ifSchema.required.includes("$ref");
+  if (!isRefCondition) {
+    const mergedSchema = getConditionalObjectSchema(schema);
+    if (mergedSchema) {
+      return generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive);
     }
-    const thenRef = thenSchema.$ref;
-    const elseRef = elseSchema.$ref;
-    const thenParserName = generateParserName(refToName(thenRef, suffix));
-    const elseParserName = generateParserName(refToName(elseRef, suffix));
-    const thenTypeName = refToName(thenRef, suffix);
-    return `export const ${functionName} = (input: unknown): ${typeName} | ${thenTypeName} =>
+    return generateEmptyObjectParser(typeName);
+  }
+  const thenRef = thenSchema.$ref;
+  const elseRef = elseSchema.$ref;
+  const thenParserName = generateParserName(refToName(thenRef, suffix));
+  const elseParserName = generateParserName(refToName(elseRef, suffix));
+  const thenTypeName = refToName(thenRef, suffix);
+  return `export const ${functionName} = (input: unknown): ${typeName} | ${thenTypeName} =>
   hasRef(input) ? ${thenParserName}(input) : ${elseParserName}(input)
       `;
 };
-/**
- * Builds an object schema from conditional if/then keywords when the schema does not
- * declare type: "object". Flattens if/then/else property sets into a single object schema.
- */
 const getConditionalObjectSchema = (schema) => {
-    if (!isSchemaObject(schema)) {
-        return null;
-    }
-    if (!('if' in schema) || !('then' in schema)) {
-        return null;
-    }
-    const ifSchema = schema.if;
-    const thenSchema = schema.then;
-    const elseSchema = 'else' in schema ? schema.else : undefined;
-    if (!isSchemaObject(ifSchema) || !isSchemaObject(thenSchema)) {
-        return null;
-    }
-    const ifProperties = ifSchema.properties;
-    const thenProperties = thenSchema.properties;
-    const elseProperties = elseSchema && isSchemaObject(elseSchema) ? elseSchema.properties : undefined;
-    const hasIfProperties = ifProperties && typeof ifProperties === 'object';
-    const hasThenProperties = thenProperties && typeof thenProperties === 'object';
-    const hasElseProperties = elseProperties && typeof elseProperties === 'object';
-    if (!hasIfProperties && !hasThenProperties && !hasElseProperties) {
-        return null;
-    }
-    const required = new Set();
-    if (Array.isArray(ifSchema.required)) {
-        for (const key of ifSchema.required) {
-            required.add(key);
-        }
+  if (!isSchemaObject(schema)) {
+    return null;
+  }
+  if (!("if" in schema) || !("then" in schema)) {
+    return null;
+  }
+  const ifSchema = schema.if;
+  const thenSchema = schema.then;
+  const elseSchema = "else" in schema ? schema.else : void 0;
+  if (!isSchemaObject(ifSchema) || !isSchemaObject(thenSchema)) {
+    return null;
+  }
+  const ifProperties = ifSchema.properties;
+  const thenProperties = thenSchema.properties;
+  const elseProperties = elseSchema && isSchemaObject(elseSchema) ? elseSchema.properties : void 0;
+  const hasIfProperties = ifProperties && typeof ifProperties === "object";
+  const hasThenProperties = thenProperties && typeof thenProperties === "object";
+  const hasElseProperties = elseProperties && typeof elseProperties === "object";
+  if (!hasIfProperties && !hasThenProperties && !hasElseProperties) {
+    return null;
+  }
+  const required = /* @__PURE__ */ new Set();
+  if (Array.isArray(ifSchema.required)) {
+    for (const key of ifSchema.required) {
+      required.add(key);
     }
-    // If the `if` condition checks for a `const` value on a property, that property
-    // is effectively required (the schema only applies when the condition is true).
-    if (hasIfProperties && ifProperties && typeof ifProperties === 'object') {
-        for (const [key, propSchema] of Object.entries(ifProperties)) {
-            if (isSchemaObject(propSchema) && hasConst(propSchema)) {
-                required.add(key);
-            }
-        }
+  }
+  if (hasIfProperties && ifProperties && typeof ifProperties === "object") {
+    for (const [key, propSchema] of Object.entries(ifProperties)) {
+      if (isSchemaObject(propSchema) && hasConst(propSchema)) {
+        required.add(key);
+      }
     }
-    if (Array.isArray(thenSchema.required)) {
-        for (const key of thenSchema.required) {
-            required.add(key);
-        }
+  }
+  if (Array.isArray(thenSchema.required)) {
+    for (const key of thenSchema.required) {
+      required.add(key);
     }
-    return {
-        type: 'object',
-        properties: {
-            // else properties first so then properties take precedence on overlap
-            ...(hasElseProperties ? elseProperties : {}),
-            ...(hasIfProperties ? ifProperties : {}),
-            ...(hasThenProperties ? thenProperties : {}),
-        },
-        ...(required.size > 0 ? { required: Array.from(required) } : {}),
-    };
+  }
+  return {
+    type: "object",
+    properties: {
+      // else properties first so then properties take precedence on overlap
+      ...hasElseProperties ? elseProperties : {},
+      ...hasIfProperties ? ifProperties : {},
+      ...hasThenProperties ? thenProperties : {}
+    },
+    ...required.size > 0 ? { required: Array.from(required) } : {}
+  };
 };
-/**
- * Generates a parser for SchemaObject that validates all JSON Schema 2020-12 properties.
- * This handles the special case where a schema can be any valid JSON Schema.
- */
 const generateSchemaObjectParser = (typeName) => {
-    const functionName = generateParserName(typeName);
-    return `export const ${functionName} = (input: unknown): ${typeName} => {
+  const functionName = generateParserName(typeName);
+  return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (typeof input === 'boolean') {
     return input as ${typeName};
   }
@@ -1643,251 +1159,156 @@ const generateSchemaObjectParser = (typeName) => {
   return input as ${typeName};
 };`;
 };
-/**
- * Determines the appropriate parser generation strategy for a schema.
- */
 const selectParserStrategy = (schema, typeName, options) => {
-    const useRefImports = options?.useRefImports ?? false;
-    const logWarnings = options?.logWarnings ?? false;
-    const strict = options?.strict ?? false;
-    const stripUnknown = options?.stripUnknown ?? false;
-    const caseInsensitive = options?.caseInsensitive ?? false;
-    const suffix = options?.typeSuffix ?? '';
-    // Special case for the self-referential JSON Schema meta-schema type (e.g.
-    // `Schema` / `SchemaObject`) - it can be any JSON Schema. This is an OpenAPI
-    // heuristic for a `$defs`/`components.schemas` entry named `schema`; it must
-    // never fire for the root document, whose name is user-derived (a `schema.json`
-    // file naturally yields the root type `Schema`) and would otherwise collapse
-    // to a validation-free pass-through parser.
-    if (!options?.isRoot && typeName === `Schema${suffix}`) {
-        return generateSchemaObjectParser(typeName);
-    }
-    const isObjectLikeSchema = isObjectSchema(schema) ||
-        (isSchemaObject(schema) && ('patternProperties' in schema || 'additionalProperties' in schema));
-    // Handle non-object schemas with type-appropriate validation
-    if (!isObjectLikeSchema && !isSchemaObject(schema)) {
-        return generateNonObjectParser(typeName, schema, strict, {
-            useRefImports,
-            suffix,
-            stripUnknown,
-            caseInsensitive,
-            logWarnings,
-            ...(options?.rootSchema !== undefined ? { rootSchema: options.rootSchema } : {}),
-            ...(options?.reservedNames !== undefined ? { reservedNames: options.reservedNames } : {}),
-        });
-    }
-    // Handle schemas with both properties AND patternProperties.
-    // This generates a parser that handles known properties and also iterates
-    // pattern-matched keys (e.g. responses with "default" + "200", "4XX").
-    if (hasProperties(schema) && isSchemaObject(schema) && 'patternProperties' in schema) {
-        return generateCombinedObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown, caseInsensitive);
-    }
-    // Handle schemas that have explicit properties — generate a full object parser.
-    // This intentionally runs before if/then checks so that schemas with both
-    // properties AND conditional keywords use all declared properties rather than
-    // only the if/then fragment.
-    if (hasProperties(schema)) {
-        return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, options?.rootSchema, options?.reservedNames, caseInsensitive);
-    }
-    // Handle conditional schemas (if/then/else) for schemas without explicit properties.
-    if (isSchemaObject(schema) && 'if' in schema && 'then' in schema && 'else' in schema) {
-        return generateConditionalParser(schema, typeName, suffix, stripUnknown, caseInsensitive);
-    }
-    // Handle conditional schemas that only define if/then object fragments.
-    // We flatten the fragments into a regular object parser.
-    const conditionalObjectSchema = getConditionalObjectSchema(schema);
-    if (conditionalObjectSchema) {
-        return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, undefined, NO_RESERVED_NAMES, caseInsensitive);
-    }
-    // Handle non-object schemas with type-appropriate validation (no properties, no conditionals)
-    if (!isObjectLikeSchema) {
-        return generateNonObjectParser(typeName, schema, strict, {
-            useRefImports,
-            suffix,
-            stripUnknown,
-            caseInsensitive,
-            logWarnings,
-            ...(options?.rootSchema !== undefined ? { rootSchema: options.rootSchema } : {}),
-            ...(options?.reservedNames !== undefined ? { reservedNames: options.reservedNames } : {}),
-        });
-    }
-    // Handle schemas with patternProperties (but no properties)
-    if ('patternProperties' in schema) {
-        return generatePatternPropertiesParser(schema, typeName, useRefImports, suffix, strict);
-    }
-    // Handle schemas with additionalProperties as true or false (but no properties)
-    if ('additionalProperties' in schema && !hasProperties(schema)) {
-        const additionalProps = schema.additionalProperties;
-        // If additionalProperties is true or false, validate it is an object
-        if (additionalProps === true || additionalProps === false) {
-            return generateEmptyObjectParser(typeName, strict, schema);
-        }
-        // Otherwise, handle as a schema (could be a $ref or object schema)
-        return generateAdditionalPropertiesParser(schema, typeName, useRefImports, suffix, strict);
-    }
-    // Handle empty object schemas
-    if ('type' in schema && schema.type === 'object' && !hasProperties(schema)) {
-        return generateEmptyObjectParser(typeName, strict, schema);
+  const useRefImports = options?.useRefImports ?? false;
+  const logWarnings = options?.logWarnings ?? false;
+  const strict = options?.strict ?? false;
+  const stripUnknown = options?.stripUnknown ?? false;
+  const caseInsensitive = options?.caseInsensitive ?? false;
+  const suffix = options?.typeSuffix ?? "";
+  if (!options?.isRoot && typeName === `Schema${suffix}`) {
+    return generateSchemaObjectParser(typeName);
+  }
+  const isObjectLikeSchema = isObjectSchema(schema) || isSchemaObject(schema) && ("patternProperties" in schema || "additionalProperties" in schema);
+  if (!isObjectLikeSchema && !isSchemaObject(schema)) {
+    return generateNonObjectParser(typeName, schema, strict, {
+      useRefImports,
+      suffix,
+      stripUnknown,
+      caseInsensitive,
+      logWarnings,
+      ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
+      ...options?.reservedNames !== void 0 ? { reservedNames: options.reservedNames } : {}
+    });
+  }
+  if (hasProperties(schema) && isSchemaObject(schema) && "patternProperties" in schema) {
+    return generateCombinedObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown, caseInsensitive);
+  }
+  if (hasProperties(schema)) {
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, options?.rootSchema, options?.reservedNames, caseInsensitive, options?.shapeValidatorSource);
+  }
+  if (isSchemaObject(schema) && "if" in schema && "then" in schema && "else" in schema) {
+    return generateConditionalParser(schema, typeName, suffix, stripUnknown, caseInsensitive);
+  }
+  const conditionalObjectSchema = getConditionalObjectSchema(schema);
+  if (conditionalObjectSchema) {
+    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive);
+  }
+  if (!isObjectLikeSchema) {
+    return generateNonObjectParser(typeName, schema, strict, {
+      useRefImports,
+      suffix,
+      stripUnknown,
+      caseInsensitive,
+      logWarnings,
+      ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
+      ...options?.reservedNames !== void 0 ? { reservedNames: options.reservedNames } : {}
+    });
+  }
+  if ("patternProperties" in schema) {
+    return generatePatternPropertiesParser(schema, typeName, useRefImports, suffix, strict);
+  }
+  if ("additionalProperties" in schema && !hasProperties(schema)) {
+    const additionalProps = schema.additionalProperties;
+    if (additionalProps === true || additionalProps === false) {
+      return generateEmptyObjectParser(typeName, strict, schema);
     }
-    // Default fallback - validate it is an object since we passed the isObjectSchema check
+    return generateAdditionalPropertiesParser(schema, typeName, useRefImports, suffix, strict);
+  }
+  if ("type" in schema && schema.type === "object" && !hasProperties(schema)) {
     return generateEmptyObjectParser(typeName, strict, schema);
+  }
+  return generateEmptyObjectParser(typeName, strict, schema);
 };
-/**
- * Generates a safe parser as an arrow function that never throws.
- * The parser provides default values for all missing or invalid fields.
- *
- * When useRefImports is enabled, properties with $ref will call the imported
- * parser function (e.g., parseContact(input?.contact)) instead of inlining
- * the resolved schema's validation logic. Array properties whose items are a
- * $ref will map each element through the imported parser.
- */
-export const generateParserFunction = (schema, typeName, options) => {
-    // Strict parsers promise to throw on violations, so any keyword we cannot
-    // enforce must fail loudly at generation rather than emit a permissive parser.
-    // Coercing parsers are documented to repair rather than reject, so the guard
-    // does not apply to them.
-    if (options?.strict)
-        assertNoUnsupportedKeywords(schema, typeName);
-    return selectParserStrategy(schema, typeName, options);
+const generateParserFunction = (schema, typeName, options) => {
+  if (options?.strict)
+    assertNoUnsupportedKeywords(schema, typeName);
+  return selectParserStrategy(schema, typeName, options);
 };
-/**
- * Returns the predicate function name for a generated shape validator.
- * @example shapeValidatorFunctionName('CustomerObject') // 'validateCustomerObjectShape'
- */
-export const shapeValidatorFunctionName = (typeName) => shapeValidatorName(typeName);
-/**
- * Generates a `validate{TypeName}Shape(input)` predicate that returns true
- * iff `input` already matches the shape produced by the parser's fast path —
- * i.e. the parser would return `{ ...input } as TypeName` without coercion.
- *
- * Parents call this predicate to fast-path through nested ref properties
- * (and arrays of refs) without recursing into their parser.
- *
- * Returns a stub that always returns `false` for schemas that cannot be
- * predicated (composition, conditionals, pattern properties, complex refs
- * in additionalProperties). The stub is safe: parents calling it will fall
- * through to the slow path, matching the pre-deep-fast-path behavior.
- */
-export const generateShapeValidator = (schema, typeName, useRefImports, suffix = '', exported = true, stripUnknown = false, reservedNames = NO_RESERVED_NAMES) => {
-    const fnName = shapeValidatorName(typeName);
-    const exportPrefix = exported ? 'export ' : '';
-    const stub = `${exportPrefix}const ${fnName} = (_input: unknown): boolean => false;`;
-    if (!isSchemaObject(schema))
-        return stub;
-    // Keywords the parser's fast path cannot mirror (contains, dependentRequired,
-    // dependentSchemas, propertyNames) make a bare shape match insufficient: a
-    // parent that fast-pathed through this predicate would skip their enforcement,
-    // so stub out and force the parent's slow path (which calls the real parser).
-    if (hasFastPathBlockingKeyword(schema))
-        return stub;
-    // An alias definition (a bare `$ref` with no shape of its own) delegates to
-    // the referenced type's validator. Guarded against self-reference.
-    if (useRefImports && hasRef(schema) && !hasProperties(schema)) {
-        const refName = refToName(schema.$ref, suffix);
-        if (refName !== typeName) {
-            return `${exportPrefix}const ${fnName} = (input: unknown): boolean => ${shapeValidatorName(refName)}(input);`;
-        }
-        return stub;
-    }
-    // A pure union definition (file-level oneOf/anyOf without properties) gets a
-    // real membership predicate when every branch is checkable. A recursive
-    // union (e.g. `expr` whose branches $ref `expr` itself) works because the
-    // branch checks call this very validator by name at runtime. Skipped under
-    // stripUnknown: the branch checks carry no known-keys terms, so a `true`
-    // could not guarantee the parser's strip build would be a no-op.
-    if (!hasProperties(schema) && !('patternProperties' in schema) && !('if' in schema) && !stripUnknown) {
-        const branches = getUnionBranches(schema);
-        if (branches) {
-            const check = generateUnionCheck('input', branches, useRefImports, suffix);
-            if (check !== null) {
-                return `${exportPrefix}const ${fnName} = (input: unknown): boolean => ${check};`;
-            }
-        }
-        return stub;
+const shapeValidatorFunctionName = (typeName) => shapeValidatorName(typeName);
+const generateShapeValidator = (schema, typeName, useRefImports, suffix = "", exported = true, stripUnknown = false, reservedNames = NO_RESERVED_NAMES) => {
+  const fnName = shapeValidatorName(typeName);
+  const exportPrefix = exported ? "export " : "";
+  const stub = `${exportPrefix}const ${fnName} = (_input: unknown): boolean => false;`;
+  if (!isSchemaObject(schema))
+    return stub;
+  if (hasFastPathBlockingKeyword(schema))
+    return stub;
+  if (useRefImports && hasRef(schema) && !hasProperties(schema)) {
+    const refName = refToName(schema.$ref, suffix);
+    if (refName !== typeName) {
+      return `${exportPrefix}const ${fnName} = (input: unknown): boolean => ${shapeValidatorName(refName)}(input);`;
+    }
+    return stub;
+  }
+  if (!hasProperties(schema) && !("patternProperties" in schema) && !("if" in schema) && !stripUnknown) {
+    const branches = getUnionBranches(schema);
+    if (branches) {
+      const check = generateUnionCheck("input", branches, useRefImports, suffix);
+      if (check !== null) {
+        return `${exportPrefix}const ${fnName} = (input: unknown): boolean => ${check};`;
+      }
+    }
+    return stub;
+  }
+  if (!hasProperties(schema))
+    return stub;
+  if (hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || "not" in schema || "patternProperties" in schema || "if" in schema || "then" in schema || "else" in schema) {
+    return stub;
+  }
+  const schemaProps = schema.properties;
+  const propertyKeys = Object.keys(schemaProps);
+  const { objects: subTypeNames, arrayItems: subItemNames } = collectInlineSubTypes(schema, typeName, reservedNames);
+  const validatorStripKeys = hasStrictKeys(schema) || stripUnknown;
+  const validatorKeyCount = validatorStripKeys ? exactKeyCountOf(schema) : null;
+  const strictKeysGuard = validatorStripKeys && validatorKeyCount === null ? `
+  if (!_hasOnlyKnownKeys${typeName}(input)) return false;` : "";
+  const checks = [];
+  for (const key of propertyKeys) {
+    const propSchema = schemaProps[key];
+    if (shouldUseRecordRefImport(propSchema, useRefImports)) {
+      return stub;
     }
-    if (!hasProperties(schema))
-        return stub;
-    // Composition / conditional schemas can match in many shapes — bail.
-    if (hasOneOf(schema) ||
-        hasAnyOf(schema) ||
-        hasAllOf(schema) ||
-        'not' in schema ||
-        'patternProperties' in schema ||
-        'if' in schema ||
-        'then' in schema ||
-        'else' in schema) {
-        return stub;
+    const accessor = safeAccessor("input", key);
+    const isRequired = isPropertyRequired(key, schema);
+    const subName = subTypeNames.get(key);
+    let check = subName ? `${shapeValidatorName(subName)}(${accessor})` : generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
+    const itemSubName = subItemNames.get(key);
+    if (check !== null && itemSubName) {
+      check = `${check} && _every${itemSubName}(${accessor})`;
     }
-    const schemaProps = schema.properties;
-    const propertyKeys = Object.keys(schemaProps);
-    // Same deterministic naming as the parser's sub-parser generation, so the
-    // referenced private shape predicates exist in the same file.
-    const { objects: subTypeNames, arrayItems: subItemNames } = collectInlineSubTypes(schema, typeName, reservedNames);
-    // When the parser strips extras (additionalProperties: false or stripUnknown),
-    // an input carrying an undeclared key is *not* fast-path eligible — the parser
-    // would strip it rather than return `{ ...input }` — so the shape only matches
-    // when every key is declared. With every declared property required, the
-    // no-extras test is the cheaper own-key count appended after the typed checks
-    // (which prove all N keys present); otherwise it is the `_hasOnlyKnownKeys`
-    // walk the parser emits under the same `stripKeys` condition.
-    const validatorStripKeys = hasStrictKeys(schema) || stripUnknown;
-    const validatorKeyCount = validatorStripKeys ? exactKeyCountOf(schema) : null;
-    const strictKeysGuard = validatorStripKeys && validatorKeyCount === null
-        ? `\n  if (!_hasOnlyKnownKeys${typeName}(input)) return false;`
-        : '';
-    const checks = [];
-    for (const key of propertyKeys) {
-        const propSchema = schemaProps[key];
-        // Records of refs require iterating every value — too expensive for the fast path.
-        if (shouldUseRecordRefImport(propSchema, useRefImports)) {
-            return stub;
-        }
-        const accessor = safeAccessor('input', key);
-        const isRequired = isPropertyRequired(key, schema);
-        const subName = subTypeNames.get(key);
-        let check = subName
-            ? `${shapeValidatorName(subName)}(${accessor})`
-            : generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
-        // Arrays of inline objects prove every element via the private item loop
-        // helper (emitted alongside the item sub-parser), matching the parser's
-        // fast-path guard.
-        const itemSubName = subItemNames.get(key);
-        if (check !== null && itemSubName) {
-            check = `${check} && _every${itemSubName}(${accessor})`;
-        }
-        if (check === null) {
-            return stub;
-        }
-        if (isRequired) {
-            checks.push(check);
-        }
-        else {
-            checks.push(`(${accessor} === undefined || ${check})`);
-        }
+    if (check === null) {
+      return stub;
     }
-    // The count form is sound only in conjunction with the typed checks above
-    // (they prove every declared key present) and only for plain objects (a
-    // crafted prototype could satisfy those checks through inherited
-    // properties), so it joins the chain last, prototype-guarded like the
-    // parser's own fast path.
-    if (validatorKeyCount !== null) {
-        checks.push(`Object.getPrototypeOf(input) === Object.prototype && Object.keys(input).length === ${validatorKeyCount}`);
+    if (isRequired) {
+      checks.push(check);
+    } else {
+      checks.push(`(${accessor} === undefined || ${check})`);
     }
-    if (checks.length === 0) {
-        if (strictKeysGuard) {
-            return `${exportPrefix}const ${fnName} = (input: unknown): boolean => {
+  }
+  if (validatorKeyCount !== null) {
+    checks.push(`Object.getPrototypeOf(input) === Object.prototype && Object.keys(input).length === ${validatorKeyCount}`);
+  }
+  if (checks.length === 0) {
+    if (strictKeysGuard) {
+      return `${exportPrefix}const ${fnName} = (input: unknown): boolean => {
   if (!isObject(input)) return false;${strictKeysGuard}
   return true;
 };`;
-        }
-        return `${exportPrefix}const ${fnName} = (input: unknown): boolean => isObject(input);`;
-    }
-    let body = checks[0];
-    for (let i = 1; i < checks.length; i++) {
-        body += '\n    && ' + checks[i];
     }
-    return `${exportPrefix}const ${fnName} = (input: unknown): boolean => {
+    return `${exportPrefix}const ${fnName} = (input: unknown): boolean => isObject(input);`;
+  }
+  let body = checks[0];
+  for (let i = 1; i < checks.length; i++) {
+    body += "\n    && " + checks[i];
+  }
+  return `${exportPrefix}const ${fnName} = (input: unknown): boolean => {
   if (!isObject(input)) return false;${strictKeysGuard}
   return ${body};
 };`;
 };
+export {
+  generateParserFunction,
+  generateShapeValidator,
+  shapeValidatorFunctionName
+};