@amritk/generate-parsers 0.20.0 → 0.21.0

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

@@ -5,6 +5,7 @@ import { resolveRef } from "@amritk/helpers/resolve-ref";
 import { missingCheck, safeAccessor, safeKey } from "@amritk/helpers/safe-accessor";
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasItems, hasMaxItems, hasMaxProperties, hasMinItems, hasMinProperties, hasOneOf, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
 import { unknownKeyCheck } from "@amritk/helpers/unknown-key-check";
+import { DEFAULT_UNKNOWN_KEYS } from "@amritk/helpers/unknown-keys-strategy";
 import { findDiscriminator } from "../helpers/find-discriminator.js";
 import { getDefaultValue } from "../helpers/get-default-value.js";
 import { getDiscriminatorValue } from "../helpers/get-discriminator-value.js";
@@ -177,6 +178,11 @@ const generateFallbackObject = (schema, useRefImports, typeName, suffix, subType
   if (isSchemaObject(schema) && ("if" in schema || "then" in schema || "else" in schema)) {
     return `{} as ${typeName}`;
   }
+  if (isSchemaObject(schema) && hasAllOf(schema)) {
+    const composesConditional = schema.allOf.some((member) => isSchemaObject(member) && (hasRef(member) || "if" in member || "then" in member || "else" in member));
+    if (composesConditional)
+      return `{} as ${typeName}`;
+  }
   const requiredProps = [];
   for (const [key, propSchema] of Object.entries(schema.properties)) {
     const isRequired = isPropertyRequired(key, schema);
@@ -250,7 +256,8 @@ const strictContext = (ctx) => ({
   useRefImports: ctx?.useRefImports ?? false,
   suffix: ctx?.suffix ?? "",
   ...ctx?.rootSchema !== void 0 ? { rootSchema: ctx.rootSchema } : {},
-  ...ctx?.stripUnknown !== void 0 ? { stripUnknown: ctx.stripUnknown } : {}
+  ...ctx?.stripUnknown !== void 0 ? { stripUnknown: ctx.stripUnknown } : {},
+  ...ctx?.unknownKeys !== void 0 ? { unknownKeys: ctx.unknownKeys } : {}
 });
 const generateNonObjectParser = (typeName, schema, strict, unionCtx) => {
   const functionName = generateParserName(typeName);
@@ -368,11 +375,12 @@ ${delegatedBody(itemParserName)}
       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 unknownKeys = unionCtx?.unknownKeys ?? DEFAULT_UNKNOWN_KEYS;
+      const itemShapeValidator = generateShapeValidator(items, itemName, useRefImports, suffix, false, stripUnknown, reserved, unknownKeys);
       const preamble = [
         `type ${itemName} = NonNullable<${typeName}>[number];`,
         itemShapeValidator,
-        generateObjectParser(items, itemName, useRefImports, suffix, unionCtx?.logWarnings ?? false, strict, false, stripUnknown, unionCtx?.rootSchema, reserved, unionCtx?.caseInsensitive ?? false, itemShapeValidator)
+        generateObjectParser(items, itemName, useRefImports, suffix, unionCtx?.logWarnings ?? false, strict, false, stripUnknown, unionCtx?.rootSchema, reserved, unionCtx?.caseInsensitive ?? false, itemShapeValidator, unknownKeys)
       ].join("\n\n");
       return `${preamble}
 
@@ -548,13 +556,21 @@ const exactKeyCountOf = (schema) => {
     return null;
   return declaredCount;
 };
+const KEY_COUNT_VAR = "_keyCount";
+const keyCountCheck = (unknownKeys, count, indent, obj = "input") => unknownKeys === "count-keys" ? {
+  statements: [],
+  verdict: `Object.getPrototypeOf(${obj}) === Object.prototype && Object.keys(${obj}).length === ${count}`
+} : {
+  statements: [`${indent}let ${KEY_COUNT_VAR} = 0;`, `${indent}for (const _k in ${obj}) ${KEY_COUNT_VAR}++;`],
+  verdict: `${KEY_COUNT_VAR} === ${count}`
+};
 const shouldCacheVariable = (propSchema) => {
   return isSchemaObject(propSchema);
 };
 const INLINE_NESTED_MAX_PROPERTIES = 12;
 const INLINE_NESTED_MAX_SITES = 4;
 const INLINE_NESTED_MAX_TOTAL_PROPERTIES = 24;
-const inlineNestedFastPath = (childSchema, childTypeName, objectExpr, useRefImports, suffix, stripUnknown, reservedNames) => {
+const inlineNestedFastPath = (childSchema, childTypeName, objectExpr, useRefImports, suffix, stripUnknown, reservedNames, claimVarName) => {
   if (!isSchemaObject(childSchema) || !hasProperties(childSchema))
     return null;
   if (!stripUnknown)
@@ -576,6 +592,7 @@ const inlineNestedFastPath = (childSchema, childTypeName, objectExpr, useRefImpo
   const keys = Object.keys(props);
   if (keys.length === 0 || keys.length > INLINE_NESTED_MAX_PROPERTIES)
     return null;
+  const declarations = [];
   const checks = [];
   const fields = [];
   const readRoot = `(${objectExpr} as Record<string, any>)`;
@@ -584,22 +601,64 @@ const inlineNestedFastPath = (childSchema, childTypeName, objectExpr, useRefImpo
     if (shouldUseRefImport(propSchema, useRefImports) || shouldUseArrayRefImport(propSchema, useRefImports) || shouldUseRecordRefImport(propSchema, useRefImports)) {
       return null;
     }
-    const accessor = safeAccessor(readRoot, key);
+    const accessor = claimVarName(`${objectExpr}_${toVarName(key).slice(1)}`);
+    declarations.push(`  const ${accessor} = ${safeAccessor(readRoot, key)};`);
     const check = generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
     if (check === null)
       return null;
     checks.push(check);
     fields.push(`${safeLiteralKey(key)}: ${accessor}`);
   }
-  const condition = [
-    `typeof ${objectExpr} === "object"`,
-    `${objectExpr} !== null`,
-    `!Array.isArray(${objectExpr})`,
-    ...checks
-  ].join(" && ");
-  return { condition, literal: `{ ${fields.join(", ")} }`, propertyCount: keys.length };
+  const condition = checks.join(" && ");
+  return { declarations, condition, literal: `{ ${fields.join(", ")} }`, propertyCount: keys.length };
+};
+const RESULT_VARIABLE = "out";
+const PROTOTYPE_MEMBERS = new Set(Object.getOwnPropertyNames(Object.prototype));
+const resultMember = (key) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? `${RESULT_VARIABLE}.${key}` : `${RESULT_VARIABLE}[${JSON.stringify(key)}]`;
+const renderLiteralEntry = (entry, indent) => {
+  if (entry.kind === "field")
+    return `${indent}${safeLiteralKey(entry.key)}: ${entry.value},`;
+  if (entry.kind === "spread")
+    return `${indent}...${entry.expression},`;
+  return `${indent}...(${entry.read} !== undefined && { ${safeLiteralKey(entry.key)}: ${entry.value} }),`;
+};
+const renderResultObject = (entries, typeName, guard) => {
+  const firstOptional = entries.findIndex((entry) => entry.kind === "optional");
+  const assignable = entries.every((entry, index) => index < firstOptional || entry.kind === "spread" || !PROTOTYPE_MEMBERS.has(entry.key));
+  if (firstOptional === -1 || !assignable) {
+    const open = guard === void 0 ? "  return {" : `  if (${guard}) return {`;
+    return [
+      open,
+      entries.map((entry) => renderLiteralEntry(entry, "    ")).join("\n"),
+      `  } as unknown as ${typeName};`
+    ];
+  }
+  const indent = guard === void 0 ? "  " : "    ";
+  const lines = [];
+  if (guard !== void 0)
+    lines.push(`  if (${guard}) {`);
+  const literal = entries.slice(0, firstOptional);
+  if (literal.length === 0) {
+    lines.push(`${indent}const ${RESULT_VARIABLE}: Record<string, unknown> = {};`);
+  } else {
+    lines.push(`${indent}const ${RESULT_VARIABLE}: Record<string, unknown> = {`);
+    lines.push(literal.map((entry) => renderLiteralEntry(entry, `${indent}  `)).join("\n"));
+    lines.push(`${indent}};`);
+  }
+  for (const entry of entries.slice(firstOptional)) {
+    if (entry.kind === "field")
+      lines.push(`${indent}${resultMember(entry.key)} = ${entry.value};`);
+    else if (entry.kind === "optional") {
+      lines.push(`${indent}if (${entry.read} !== undefined) ${resultMember(entry.key)} = ${entry.value};`);
+    } else
+      lines.push(`${indent}Object.assign(${RESULT_VARIABLE}, ${entry.expression});`);
+  }
+  lines.push(`${indent}return ${RESULT_VARIABLE} as unknown as ${typeName};`);
+  if (guard !== void 0)
+    lines.push("  }");
+  return lines;
 };
-const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, exported = true, stripUnknown = false, rootSchema, reservedNames = NO_RESERVED_NAMES, caseInsensitive = false, shapeValidatorSource) => {
+const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, exported = true, stripUnknown = false, rootSchema, reservedNames = NO_RESERVED_NAMES, caseInsensitive = false, shapeValidatorSource, unknownKeys = DEFAULT_UNKNOWN_KEYS) => {
   const functionName = generateParserName(typeName);
   const exportPrefix = exported ? "export " : "";
   if (!hasProperties(schema)) {
@@ -618,21 +677,21 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
   for (const [key, subName] of subTypeNames) {
     const propSchema = schemaProps[key];
     preamble.push(`type ${subName} = NonNullable<${typeName}>[${JSON.stringify(key)}];`);
-    const subShapeValidator = generateShapeValidator(propSchema, subName, useRefImports, suffix, false, stripUnknown, reservedNames);
+    const subShapeValidator = generateShapeValidator(propSchema, subName, useRefImports, suffix, false, stripUnknown, reservedNames, unknownKeys);
     preamble.push(subShapeValidator);
-    preamble.push(generateObjectParser(propSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames, caseInsensitive, subShapeValidator));
+    preamble.push(generateObjectParser(propSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames, caseInsensitive, subShapeValidator, unknownKeys));
   }
   for (const [key, subName] of subItemNames) {
     const propSchema = schemaProps[key];
     const itemSchema = propSchema.items;
     preamble.push(`type ${subName} = NonNullable<NonNullable<${typeName}>[${JSON.stringify(key)}]>[number];`);
-    const itemShapeValidator = generateShapeValidator(itemSchema, subName, useRefImports, suffix, false, stripUnknown, reservedNames);
+    const itemShapeValidator = generateShapeValidator(itemSchema, subName, useRefImports, suffix, false, stripUnknown, reservedNames, unknownKeys);
     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));
+    preamble.push(generateObjectParser(itemSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames, caseInsensitive, itemShapeValidator, unknownKeys));
   }
   const strictKeys = hasStrictKeys(schema);
   const stripKeys = strictKeys || stripUnknown;
@@ -663,7 +722,9 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
   let canFastPath = !hasAllOfRefParsers && !hasFastPathBlockingKeyword(schema) && !(strict && inlineAllOfMembers(schema).length > 0);
   const fastPathChecks = [];
   const fastPathAccessorChecks = [];
-  const usedVarNames = /* @__PURE__ */ new Set();
+  const usedVarNames = /* @__PURE__ */ new Set([KEY_COUNT_VAR]);
+  let inlinedGuardSites = 0;
+  let inlinedGuardProperties = 0;
   for (const key of propertyKeys) {
     const propSchema = schemaProps[key];
     const isRequired = isPropertyRequired(key, schema);
@@ -679,7 +740,13 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       continue;
     }
     const subName = subTypeNames.get(key);
-    let check = subName ? `${shapeValidatorName(subName)}(${varName})` : generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
+    const inlined = subName !== void 0 && inlinedGuardSites < INLINE_NESTED_MAX_SITES ? inlineNestedShapeCheck(propSchema, subName, varName, useRefImports, suffix, stripUnknown, reservedNames, unknownKeys) : null;
+    const withinBudget = inlined !== null && inlinedGuardProperties + inlined.propertyCount <= INLINE_NESTED_MAX_TOTAL_PROPERTIES;
+    if (withinBudget) {
+      inlinedGuardSites++;
+      inlinedGuardProperties += inlined.propertyCount;
+    }
+    let check = withinBudget ? inlined.check : subName ? `${shapeValidatorName(subName)}(${varName})` : generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
     const itemSubName = subItemNames.get(key);
     if (check !== null && itemSubName) {
       check = `${check} && _every${itemSubName}(${varName})`;
@@ -711,32 +778,24 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       fastPathAccessorChecks.push(`Object.keys(input).length <= ${schema.maxProperties}`);
     }
   }
-  if (fastPathNeedsKnownKeys) {
-    fastPathChecks.push(exactKeyCount !== null ? `Object.getPrototypeOf(input) === Object.prototype && Object.keys(input).length === ${exactKeyCount}` : `_hasOnlyKnownKeys${typeName}(input)`);
+  const fastPathKeyCount = fastPathNeedsKnownKeys ? exactKeyCount : null;
+  if (fastPathNeedsKnownKeys && exactKeyCount === null) {
+    fastPathChecks.push(`_hasOnlyKnownKeys${typeName}(input)`);
   }
-  const deepGuard = canFastPath && fastPathChecks.length > 0 ? fastPathChecks.join(" && ") : null;
+  const deepGuard = canFastPath && (fastPathChecks.length > 0 || fastPathKeyCount !== null) ? fastPathChecks.join(" && ") : null;
   const literalReturnUsesVars = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema)) && exported;
   let deepGuardExpr = deepGuard;
   if (deepGuard !== null && shapeValidatorSource !== void 0 && !literalReturnUsesVars && !droppedKnownKeysTerm) {
     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    && ")};
-};`;
+    const expectedShapeValidator = renderShapeValidator(exportPrefix, shapeFnName, fastPathAccessorChecks, stripKeys ? exactKeyCount : null, shapeStrictKeysGuard, unknownKeys);
     if (shapeValidatorSource === expectedShapeValidator) {
       deepGuardExpr = `${shapeFnName}(input)`;
     }
   }
   const deepGuardCallsShape = deepGuardExpr !== deepGuard;
+  const inlineKeyCount = deepGuardCallsShape ? null : fastPathKeyCount;
   let canShallowGuard = strict && stripUnknown && !strictKeys && !hasFastPathBlockingKeyword(schema);
   const shallowChecks = [];
   if (canShallowGuard) {
@@ -776,18 +835,25 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
     warnLines.push(`    }`);
     warnLines.push(`  }`);
   }
-  const buildObjectLines = (directAssign) => {
-    const objectLines = [];
+  const claimNestedVarName = (base) => {
+    let name = base;
+    while (usedVarNames.has(name))
+      name = `${name}_`;
+    usedVarNames.add(name);
+    return name;
+  };
+  const buildObjectLines = (directAssign, hoistLines) => {
+    const entries = [];
     let inlinedSites = 0;
     let inlinedProperties = 0;
     if (!stripKeys) {
-      objectLines.push("    ...input,");
+      entries.push({ kind: "spread", expression: "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>),`);
+          entries.push({ kind: "spread", expression: `(${parserName}(input) as Record<string, unknown>)` });
         }
       }
     }
@@ -798,18 +864,23 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       if (subName) {
         const subParserName = generateParserName(subName);
         if (isRequired) {
-          const inlined = directAssign && !logWarnings && inlinedSites < INLINE_NESTED_MAX_SITES ? inlineNestedFastPath(propSchema, subName, accessor, useRefImports, suffix, stripUnknown, reservedNames) : null;
+          const inlined = hoistLines !== void 0 && directAssign && !logWarnings && inlinedSites < INLINE_NESTED_MAX_SITES ? inlineNestedFastPath(propSchema, subName, accessor, useRefImports, suffix, stripUnknown, reservedNames, claimNestedVarName) : null;
           if (inlined !== null && inlinedProperties + inlined.propertyCount <= INLINE_NESTED_MAX_TOTAL_PROPERTIES) {
             inlinedSites++;
             inlinedProperties += inlined.propertyCount;
-            objectLines.push(`    ${safeLiteralKey(key)}: (${inlined.condition})
+            hoistLines?.push(...inlined.declarations);
+            entries.push({
+              kind: "field",
+              key,
+              value: `(${inlined.condition})
       ? ${inlined.literal}
-      : ${subParserName}(${accessor}),`);
+      : ${subParserName}(${accessor})`
+            });
             continue;
           }
-          objectLines.push(`    ${safeLiteralKey(key)}: ${subParserName}(${accessor}),`);
+          entries.push({ kind: "field", key, value: `${subParserName}(${accessor})` });
         } else {
-          objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${subParserName}(${accessor}) }),`);
+          entries.push({ kind: "optional", key, read: accessor, value: `${subParserName}(${accessor})` });
         }
         continue;
       }
@@ -817,9 +888,14 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       if (itemSubName) {
         const itemParserName = generateParserName(itemSubName);
         if (isRequired) {
-          objectLines.push(`    ${safeLiteralKey(key)}: validateArray(${accessor}, ${itemParserName}),`);
+          entries.push({ kind: "field", key, value: `validateArray(${accessor}, ${itemParserName})` });
         } else {
-          objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: validateArray(${accessor}, ${itemParserName}) }),`);
+          entries.push({
+            kind: "optional",
+            key,
+            read: accessor,
+            value: `validateArray(${accessor}, ${itemParserName})`
+          });
         }
         continue;
       }
@@ -827,9 +903,9 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         const ref = propSchema.$ref;
         const parserName = generateParserName(refToName(ref, suffix));
         if (isRequired) {
-          objectLines.push(`    ${safeLiteralKey(key)}: ${parserName}(${accessor}),`);
+          entries.push({ kind: "field", key, value: `${parserName}(${accessor})` });
         } else {
-          objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${parserName}(${accessor}) }),`);
+          entries.push({ kind: "optional", key, read: accessor, value: `${parserName}(${accessor})` });
         }
         continue;
       }
@@ -838,9 +914,9 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         const ref = items.$ref;
         const parserName = generateParserName(refToName(ref, suffix));
         if (isRequired) {
-          objectLines.push(`    ${safeLiteralKey(key)}: validateArray(${accessor}, ${parserName}),`);
+          entries.push({ kind: "field", key, value: `validateArray(${accessor}, ${parserName})` });
         } else {
-          objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: validateArray(${accessor}, ${parserName}) }),`);
+          entries.push({ kind: "optional", key, read: accessor, value: `validateArray(${accessor}, ${parserName})` });
         }
         continue;
       }
@@ -849,21 +925,21 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         const ref = additionalProps.$ref;
         const parserName = generateParserName(refToName(ref, suffix));
         if (isRequired) {
-          objectLines.push(`    ${safeLiteralKey(key)}: validateRecord(${accessor}, ${parserName}),`);
+          entries.push({ kind: "field", key, value: `validateRecord(${accessor}, ${parserName})` });
         } else {
-          objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: validateRecord(${accessor}, ${parserName}) }),`);
+          entries.push({ kind: "optional", key, read: accessor, value: `validateRecord(${accessor}, ${parserName})` });
         }
         continue;
       }
       if (!isSchemaObject(propSchema)) {
         if (propSchema === true) {
           if (isRequired) {
-            objectLines.push(`    ${safeLiteralKey(key)}: ${accessor},`);
+            entries.push({ kind: "field", key, value: accessor });
           } else if (stripKeys) {
-            objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${accessor} }),`);
+            entries.push({ kind: "optional", key, read: accessor, value: accessor });
           }
         } else if (isRequired) {
-          objectLines.push(`    ${safeLiteralKey(key)}: undefined,`);
+          entries.push({ kind: "field", key, value: "undefined" });
         }
         continue;
       }
@@ -876,25 +952,47 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         valueExpr = generateValidationExpression(key, propSchema, defaultValue, true, void 0, void 0, shouldCache ? varName : void 0, knownNotUndefined, caseInsensitive);
       }
       if (isRequired) {
-        objectLines.push(`    ${safeLiteralKey(key)}: ${valueExpr},`);
+        entries.push({ kind: "field", key, value: valueExpr });
       } else {
-        objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${valueExpr} }),`);
+        entries.push({ kind: "optional", key, read: accessor, value: valueExpr });
       }
     }
-    return objectLines;
+    return entries;
   };
-  const emitReturn = (lines2, objectLines) => {
-    lines2.push(`  return {`);
-    lines2.push(objectLines.join("\n"));
-    lines2.push(`  } as unknown as ${typeName};`);
+  const emitReturn = (lines2, entries) => {
+    lines2.push(...renderResultObject(entries, typeName));
+  };
+  const withKeyCount = (lines2, guarded) => {
+    if (inlineKeyCount === null) {
+      lines2.push(...guarded(deepGuardExpr));
+      return;
+    }
+    const count = keyCountCheck(unknownKeys, inlineKeyCount, "    ");
+    if (count.statements.length === 0) {
+      lines2.push(...guarded(deepGuardExpr === "" ? count.verdict : `${deepGuardExpr} && ${count.verdict}`));
+      return;
+    }
+    const counted = guarded(count.verdict);
+    if (deepGuardExpr === "") {
+      lines2.push(...keyCountCheck(unknownKeys, inlineKeyCount, "  ").statements, ...counted);
+      return;
+    }
+    const nested = counted.map((line) => line.split("\n").map((part) => `  ${part}`).join("\n"));
+    lines2.push(`  if (${deepGuardExpr}) {`, ...count.statements, ...nested, `  }`);
+  };
+  const emitGuardedReturn = (lines2, statement) => {
+    withKeyCount(lines2, (guard) => [`  if (${guard}) ${statement}`]);
+  };
+  const emitGuardedResult = (lines2, fields) => {
+    withKeyCount(lines2, (guard) => renderResultObject(fields, typeName, guard));
   };
   const emitDeepGuardReturn = (lines2) => {
     if (!fastPathBuildsDeclaredLiteral) {
-      lines2.push(`  if (${deepGuardExpr}) return { ...input } as ${typeName};`);
+      emitGuardedReturn(lines2, `return { ...input } as ${typeName};`);
       return;
     }
     if (!exported && fastPathNeedsKnownKeys) {
-      lines2.push(`  if (${deepGuardExpr}) return input as ${typeName};`);
+      emitGuardedReturn(lines2, `return input as ${typeName};`);
       return;
     }
     const fields = [];
@@ -902,33 +1000,90 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       if (!isSchemaObject(propSchema)) {
         if (propSchema === true) {
           const acc = safeAccessor("input", key);
-          fields.push(isRequired ? `    ${safeLiteralKey(key)}: ${acc},` : `    ...(${acc} !== undefined && { ${safeLiteralKey(key)}: ${acc} }),`);
+          fields.push(isRequired ? { kind: "field", key, value: acc } : { kind: "optional", key, read: acc, value: acc });
         } else if (isRequired) {
-          fields.push(`    ${safeLiteralKey(key)}: undefined,`);
+          fields.push({ kind: "field", key, value: "undefined" });
         }
         continue;
       }
       const accessor = shouldCacheVariable(propSchema) ? varName : safeAccessor("input", key);
-      fields.push(isRequired ? `    ${safeLiteralKey(key)}: ${accessor},` : `    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${accessor} }),`);
+      fields.push(isRequired ? { kind: "field", key, value: accessor } : { kind: "optional", key, read: accessor, value: accessor });
     }
-    lines2.push(`  if (${deepGuardExpr}) return {`);
-    lines2.push(fields.join("\n"));
-    lines2.push(`  } as unknown as ${typeName};`);
+    emitGuardedResult(lines2, fields);
   };
+  const assertionLines = strict ? generateObjectStrictAssertion(schema, typeName, {
+    useRefImports,
+    suffix,
+    stripUnknown,
+    ...rootSchema !== void 0 ? { rootSchema } : {}
+  }) : [];
+  const unknownKeyThrowLines = () => rejectsUnknownKeys ? [
+    `  for (const _k in input) {`,
+    `    if (${strictKeyCheck.isUnknown("_k")}) throw new Error(\`[${typeName}] unknown property "\${_k}"\`);`,
+    `  }`
+  ] : [];
+  const varsAfterGuard = deepGuardCallsShape && shallowGuard === null;
+  const assertBodyLines = [...assertionLines.slice(1), ...shallowGuard === null ? unknownKeyThrowLines() : []];
+  const canSplit = !logWarnings && strict === true && (deepGuard !== null || shallowGuard !== null) && assertBodyLines.length > 0;
+  const assertName = `_assert${typeName}`;
+  const assertObjectName = `_assert${typeName}Object`;
+  const emitAssertObjectFunction = () => `const ${assertObjectName}: (input: unknown) => asserts input is Record<string, unknown> = (input) => {
+${assertionLines[0]}
+};`;
+  const emitAssertFunction = () => `const ${assertName} = (input: Record<string, unknown>): void => {
+${assertBodyLines.join("\n")}
+};`;
   const lines = [];
   lines.push(`${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {`);
-  const varsAfterGuard = deepGuardCallsShape && shallowGuard === null;
-  if (strict) {
+  if (canSplit) {
+    preamble.push(emitAssertObjectFunction());
+    preamble.push(emitAssertFunction());
+    lines.push(`  if (!isObject(input)) ${assertObjectName}(input);`);
+    if (!varsAfterGuard)
+      lines.push(...varDeclLines);
+    if (shallowGuard) {
+      lines.push(`  if (!(${shallowGuard})) ${assertName}(input);`);
+      if (!exported && deepGuard !== null && fastPathNeedsKnownKeys) {
+        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);
+        }
+        const returnInput = `return input as ${typeName};`;
+        if (fastPathKeyCount === null) {
+          lines.push(residual.length > 0 ? `  if (${residual.join(" && ")}) ${returnInput}` : `  ${returnInput}`);
+        } else {
+          const count = keyCountCheck(unknownKeys, fastPathKeyCount, residual.length === 0 ? "  " : "    ");
+          if (count.statements.length === 0) {
+            lines.push(`  if (${[...residual, count.verdict].join(" && ")}) ${returnInput}`);
+          } else if (residual.length === 0) {
+            lines.push(...count.statements, `  if (${count.verdict}) ${returnInput}`);
+          } else {
+            lines.push(`  if (${residual.join(" && ")}) {`);
+            lines.push(...count.statements, `    if (${count.verdict}) ${returnInput}`);
+            lines.push(`  }`);
+          }
+        }
+      }
+      const hoisted = [];
+      const objectLines = buildObjectLines(true, hoisted);
+      lines.push(...hoisted);
+      emitReturn(lines, objectLines);
+    } else {
+      emitDeepGuardReturn(lines);
+      if (varsAfterGuard)
+        lines.push(...varDeclLines);
+      lines.push(`  ${assertName}(input);`);
+      emitReturn(lines, buildObjectLines(true));
+    }
+  } else 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 && fastPathNeedsKnownKeys) {
         const residual = [];
@@ -940,34 +1095,41 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
           residual.push(shallow !== void 0 && 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};`);
+        const returnInput = `return input as ${typeName};`;
+        if (fastPathKeyCount === null) {
+          lines.push(residual.length > 0 ? `    if (${residual.join(" && ")}) ${returnInput}` : `    ${returnInput}`);
+        } else {
+          const count = keyCountCheck(unknownKeys, fastPathKeyCount, residual.length === 0 ? "    " : "      ");
+          if (count.statements.length === 0) {
+            lines.push(`    if (${[...residual, count.verdict].join(" && ")}) ${returnInput}`);
+          } else if (residual.length === 0) {
+            lines.push(...count.statements, `    if (${count.verdict}) ${returnInput}`);
+          } else {
+            lines.push(`    if (${residual.join(" && ")}) {`);
+            lines.push(...count.statements, `      if (${count.verdict}) ${returnInput}`);
+            lines.push(`    }`);
+          }
+        }
         lines.push(`  } else {`);
-        for (const assertionLine of assertionLines) {
+        for (const assertionLine of assertionLines.slice(1))
           lines.push(`  ${assertionLine}`);
-        }
         lines.push(`  }`);
       } else {
         lines.push(`  if (!(${shallowGuard})) {`);
-        for (const assertionLine of assertionLines) {
+        for (const assertionLine of assertionLines.slice(1))
           lines.push(`  ${assertionLine}`);
-        }
         lines.push(`  }`);
       }
       emitReturn(lines, buildObjectLines(true));
     } else {
-      if (deepGuard) {
+      if (deepGuard !== null) {
         emitDeepGuardReturn(lines);
       }
       if (varsAfterGuard)
         lines.push(...varDeclLines);
-      for (const assertionLine of assertionLines) {
+      for (const assertionLine of assertionLines.slice(1))
         lines.push(assertionLine);
-      }
-      if (rejectsUnknownKeys) {
-        lines.push(`  for (const _k in input) {`);
-        lines.push(`    if (${strictKeyCheck.isUnknown("_k")}) throw new Error(\`[${typeName}] unknown property "\${_k}"\`);`);
-        lines.push(`  }`);
-      }
+      lines.push(...unknownKeyThrowLines());
       emitReturn(lines, buildObjectLines(true));
     }
   } else {
@@ -975,7 +1137,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
     if (!varsAfterGuard)
       lines.push(...varDeclLines);
     lines.push(...warnLines);
-    if (deepGuard) {
+    if (deepGuard !== null) {
       emitDeepGuardReturn(lines);
     }
     if (varsAfterGuard)
@@ -1034,6 +1196,7 @@ ${loopLines.join("\n")}
 };
 const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown = false, caseInsensitive = false, context = {}) => {
   const functionName = generateParserName(typeName);
+  const unknownKeys = context.unknownKeys ?? DEFAULT_UNKNOWN_KEYS;
   const entries = generatePropertyEntries(schema, useRefImports, suffix, caseInsensitive);
   const propertyLines = entries.map((entry) => {
     if (entry.isOptional) {
@@ -1042,7 +1205,7 @@ const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, l
     return `    ${safeLiteralKey(entry.key)}: ${entry.value},`;
   });
   if (!isSchemaObject(schema) || !("patternProperties" in schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, context.rootSchema, NO_RESERVED_NAMES, caseInsensitive);
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, context.rootSchema, NO_RESERVED_NAMES, caseInsensitive, void 0, unknownKeys);
   }
   const patternProps = schema.patternProperties;
   const patterns = Object.entries(patternProps);
@@ -1055,7 +1218,7 @@ const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, l
     return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, false, context);
   }
   if (!refPattern || !useRefImports) {
-    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, context.rootSchema, NO_RESERVED_NAMES, caseInsensitive);
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, context.rootSchema, NO_RESERVED_NAMES, caseInsensitive, void 0, unknownKeys);
   }
   const [pattern, patternSchema] = refPattern;
   const ref = patternSchema.$ref;
@@ -1231,7 +1394,7 @@ ${notObjectBranch}
   return result;
 };`;
 };
-const generateConditionalParser = (schema, typeName, suffix, stripUnknown = false, caseInsensitive = false) => {
+const generateConditionalParser = (schema, typeName, suffix, stripUnknown = false, caseInsensitive = false, unknownKeys = DEFAULT_UNKNOWN_KEYS) => {
   const functionName = generateParserName(typeName);
   const ifSchema = schema.if;
   const thenSchema = schema.then;
@@ -1241,7 +1404,7 @@ const generateConditionalParser = (schema, typeName, suffix, stripUnknown = fals
   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 generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive, void 0, unknownKeys);
     }
     return generateEmptyObjectParser(typeName);
   }
@@ -1249,7 +1412,7 @@ const generateConditionalParser = (schema, typeName, suffix, stripUnknown = fals
   if (!isRefCondition) {
     const mergedSchema = getConditionalObjectSchema(schema);
     if (mergedSchema) {
-      return generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive);
+      return generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive, void 0, unknownKeys);
     }
     return generateEmptyObjectParser(typeName);
   }
@@ -1333,11 +1496,13 @@ const selectParserStrategy = (schema, typeName, options) => {
   const strict = options?.strict ?? false;
   const stripUnknown = options?.stripUnknown ?? false;
   const caseInsensitive = options?.caseInsensitive ?? false;
+  const unknownKeys = options?.unknownKeys ?? DEFAULT_UNKNOWN_KEYS;
   const suffix = options?.typeSuffix ?? "";
   const context = {
     useRefImports,
     suffix,
     stripUnknown,
+    unknownKeys,
     ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {}
   };
   const copyLoopContext = { ...context, subParsers: false };
@@ -1352,6 +1517,7 @@ const selectParserStrategy = (schema, typeName, options) => {
       stripUnknown,
       caseInsensitive,
       logWarnings,
+      unknownKeys,
       ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
       ...options?.reservedNames !== void 0 ? { reservedNames: options.reservedNames } : {}
     });
@@ -1366,12 +1532,13 @@ const selectParserStrategy = (schema, typeName, options) => {
       stripUnknown,
       caseInsensitive,
       logWarnings,
+      unknownKeys,
       ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
       ...options?.reservedNames !== void 0 ? { reservedNames: options.reservedNames } : {}
     });
   }
   if (hasProperties(schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, options?.rootSchema, options?.reservedNames, caseInsensitive, options?.shapeValidatorSource);
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, options?.rootSchema, options?.reservedNames, caseInsensitive, options?.shapeValidatorSource, unknownKeys);
   }
   if (strict && isSchemaObject(schema) && ("if" in schema || "then" in schema || "else" in schema)) {
     return generateNonObjectParser(typeName, schema, strict, {
@@ -1380,16 +1547,17 @@ const selectParserStrategy = (schema, typeName, options) => {
       stripUnknown,
       caseInsensitive,
       logWarnings,
+      unknownKeys,
       ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
       ...options?.reservedNames !== void 0 ? { reservedNames: options.reservedNames } : {}
     });
   }
   if (isSchemaObject(schema) && "if" in schema && "then" in schema && "else" in schema) {
-    return generateConditionalParser(schema, typeName, suffix, stripUnknown, caseInsensitive);
+    return generateConditionalParser(schema, typeName, suffix, stripUnknown, caseInsensitive, unknownKeys);
   }
   const conditionalObjectSchema = getConditionalObjectSchema(schema);
   if (conditionalObjectSchema) {
-    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, context.rootSchema, NO_RESERVED_NAMES, caseInsensitive);
+    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, context.rootSchema, NO_RESERVED_NAMES, caseInsensitive, void 0, unknownKeys);
   }
   if (!isObjectLikeSchema) {
     return generateNonObjectParser(typeName, schema, strict, {
@@ -1398,6 +1566,7 @@ const selectParserStrategy = (schema, typeName, options) => {
       stripUnknown,
       caseInsensitive,
       logWarnings,
+      unknownKeys,
       ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
       ...options?.reservedNames !== void 0 ? { reservedNames: options.reservedNames } : {}
     });
@@ -1430,7 +1599,7 @@ const generateParserFunction = (schema, typeName, rawOptions) => {
   return selectParserStrategy(schema, typeName, options);
 };
 const shapeValidatorFunctionName = (typeName) => shapeValidatorName(typeName);
-const generateShapeValidator = (schema, typeName, useRefImports, suffix = "", exported = true, stripUnknown = false, reservedNames = NO_RESERVED_NAMES) => {
+const generateShapeValidator = (schema, typeName, useRefImports, suffix = "", exported = true, stripUnknown = false, reservedNames = NO_RESERVED_NAMES, unknownKeys = DEFAULT_UNKNOWN_KEYS) => {
   const fnName = shapeValidatorName(typeName);
   const exportPrefix = exported ? "export " : "";
   const stub = `${exportPrefix}const ${fnName} = (_input: unknown): boolean => false;`;
@@ -1455,25 +1624,34 @@ const generateShapeValidator = (schema, typeName, useRefImports, suffix = "", ex
     }
     return stub;
   }
-  if (!hasProperties(schema))
+  const shape = shapeChecksOf(schema, typeName, "input", useRefImports, suffix, stripUnknown, reservedNames);
+  if (shape === null)
     return stub;
+  const strictKeysGuard = shape.walksKeys ? `
+  if (!_hasOnlyKnownKeys${typeName}(input)) return false;` : "";
+  return renderShapeValidator(exportPrefix, fnName, shape.checks, shape.keyCount, strictKeysGuard, unknownKeys);
+};
+const shapeChecksOf = (schema, typeName, root, useRefImports, suffix, stripUnknown, reservedNames) => {
+  if (!isSchemaObject(schema))
+    return null;
+  if (hasFastPathBlockingKeyword(schema))
+    return null;
+  if (!hasProperties(schema))
+    return null;
   if (hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || "not" in schema || "patternProperties" in schema || "if" in schema || "then" in schema || "else" in schema) {
-    return stub;
+    return null;
   }
   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 keyCount = validatorStripKeys ? exactKeyCountOf(schema) : null;
   const checks = [];
   for (const key of propertyKeys) {
     const propSchema = schemaProps[key];
-    if (shouldUseRecordRefImport(propSchema, useRefImports)) {
-      return stub;
-    }
-    const accessor = safeAccessor("input", key);
+    if (shouldUseRecordRefImport(propSchema, useRefImports))
+      return null;
+    const accessor = safeAccessor(root, key);
     const isRequired = isPropertyRequired(key, schema);
     const subName = subTypeNames.get(key);
     let check = subName ? `${shapeValidatorName(subName)}(${accessor})` : generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
@@ -1481,9 +1659,8 @@ const generateShapeValidator = (schema, typeName, useRefImports, suffix = "", ex
     if (check !== null && itemSubName) {
       check = `${check} && _every${itemSubName}(${accessor})`;
     }
-    if (check === null) {
-      return stub;
-    }
+    if (check === null)
+      return null;
     if (isRequired) {
       checks.push(check);
     } else {
@@ -1491,28 +1668,56 @@ const generateShapeValidator = (schema, typeName, useRefImports, suffix = "", ex
     }
   }
   if (hasMinProperties(schema))
-    checks.push(`Object.keys(input).length >= ${schema.minProperties}`);
+    checks.push(`Object.keys(${root}).length >= ${schema.minProperties}`);
   if (hasMaxProperties(schema))
-    checks.push(`Object.keys(input).length <= ${schema.maxProperties}`);
-  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}
+    checks.push(`Object.keys(${root}).length <= ${schema.maxProperties}`);
+  return { checks, keyCount, walksKeys: validatorStripKeys && keyCount === null, propertyCount: propertyKeys.length };
+};
+const inlineNestedShapeCheck = (childSchema, childTypeName, local, useRefImports, suffix, stripUnknown, reservedNames, unknownKeys) => {
+  const readRoot = `(${local} as Record<string, any>)`;
+  const shape = shapeChecksOf(childSchema, childTypeName, readRoot, useRefImports, suffix, stripUnknown, reservedNames);
+  if (shape === null || shape.walksKeys)
+    return null;
+  if (shape.propertyCount === 0 || shape.propertyCount > INLINE_NESTED_MAX_PROPERTIES)
+    return null;
+  const count = shape.keyCount === null ? null : keyCountCheck(unknownKeys, shape.keyCount, "", local);
+  if (count !== null && count.statements.length > 0)
+    return null;
+  const parts = [
+    `typeof ${local} === "object"`,
+    `${local} !== null`,
+    `!Array.isArray(${local})`,
+    ...shape.checks,
+    ...count === null ? [] : [count.verdict]
+  ];
+  return { check: `(${parts.join(" && ")})`, propertyCount: shape.propertyCount };
+};
+const renderShapeValidator = (exportPrefix, fnName, checks, keyCount, strictKeysGuard, unknownKeys) => {
+  const head = `${exportPrefix}const ${fnName} = (input: unknown): boolean => {
+  if (!isObject(input)) return false;${strictKeysGuard}`;
+  const chain = checks.join("\n    && ");
+  if (keyCount === null) {
+    if (checks.length === 0) {
+      return strictKeysGuard ? `${head}
   return true;
-};`;
+};` : `${exportPrefix}const ${fnName} = (input: unknown): boolean => isObject(input);`;
     }
-    return `${exportPrefix}const ${fnName} = (input: unknown): boolean => isObject(input);`;
+    return `${head}
+  return ${chain};
+};`;
   }
-  let body = checks[0];
-  for (let i = 1; i < checks.length; i++) {
-    body += "\n    && " + checks[i];
+  const count = keyCountCheck(unknownKeys, keyCount, "  ");
+  if (count.statements.length === 0) {
+    return `${head}
+  return ${checks.length === 0 ? count.verdict : `${chain}
+    && ${count.verdict}`};
+};`;
   }
-  return `${exportPrefix}const ${fnName} = (input: unknown): boolean => {
-  if (!isObject(input)) return false;${strictKeysGuard}
-  return ${body};
+  const gate = checks.length === 0 ? "" : `
+  if (!(${chain})) return false;`;
+  return `${head}${gate}
+${count.statements.join("\n")}
+  return ${count.verdict};
 };`;
 };
 export {