@amritk/generate-parsers 0.20.1 → 0.21.0

package/AI.md

@@ -22,9 +22,11 @@ const files = await buildSchema(schema, 'Document')
 
 1. **`buildSchema` is `async` and takes POSITIONAL args, no options object.** The
    full signature is
-   `buildSchema(rootSchema, rootTypeName, extensions?, typesOnly?, logWarnings?, strict?, helpersMode?, helpersImportPrefix?, readonly?, stripUnknown?, typeSuffix?, importExt?, caseInsensitive?)`.
+   `buildSchema(rootSchema, rootTypeName, extensions?, typesOnly?, logWarnings?, strict?, helpersMode?, helpersImportPrefix?, readonly?, stripUnknown?, typeSuffix?, importExt?, caseInsensitive?, schemas?, unknownKeys?)`.
    To set a later flag you must pass every intervening positional. (The README's
-   short form omits the trailing seven.)
+   short form omits the trailing seven.) `unknownKeys` (`'count-keys'` by default,
+   `'count-enumerable'` for Node-only output) picks how a closed object's fast
+   path counts keys; nothing in the generated code detects its runtime.
 2. **It returns files in memory — it does NOT write to disk.** You write the
    `GeneratedFile[]` (`{ filename, content }`) yourself. `rootTypeName` becomes
    that filename (lowercased) as well as the `export type` name, so it must be a

package/README.md

@@ -95,6 +95,7 @@ Every option after the first two is **positional** — pass them in this order:
 | 12 | `importExt` | `'js' \| 'ts'` | `'js'` | Extension emitted on relative import specifiers. `'js'` is the NodeNext form for output you compile; `'ts'` emits the literal on-disk paths so the sources run unbuilt. |
 | 13 | `caseInsensitive` | `boolean` | `false` | Normalize a mis-cased string to the exact casing of an enum/const member it matches case-insensitively. Coerce mode only. |
 | 14 | `schemas` | `Record<string, unknown>` | — | Documents you have **already loaded**, keyed by the absolute URI a `$ref` names them by. See below. |
+| 15 | `unknownKeys` | `'count-keys' \| 'count-enumerable'` | `'count-keys'` | How a fast path proves a closed object (`additionalProperties: false`, or a `stripUnknown` build) has no undeclared key: a prototype-guarded `Object.keys(input).length` (fastest on Bun) or a `for…in` count (fastest on Node). See [Counting keys on the fast path](#counting-keys-on-the-fast-path). |
 
 Returns: `Promise<GeneratedFile[]>`.
 
@@ -184,6 +185,14 @@ nobody registered still stops the build, with a message naming the ref.
 <tr>
 <td colspan="3">Normalize a mis-cased string to the exact casing of a declared enum/const member it matches case-insensitively (e.g. hElLo → hello) instead of coercing to the default. Coerce mode only — strict parsers still reject a casing mismatch. Correctly-cased input keeps the exact-match fast path, so the hot path is unaffected.</td>
 </tr>
+<tr>
+<td>🔢 <code>unknownKeys</code></td>
+<td><code>string</code></td>
+<td align="center"><code>"count-keys"</code></td>
+</tr>
+<tr>
+<td colspan="3">How a fast path proves a closed object (additionalProperties: false, or a stripUnknown build) carries no undeclared key. 'count-keys' is a prototype-guarded Object.keys(input).length comparison, the faster form on JavaScriptCore (Bun); 'count-enumerable' is a for…in count that allocates nothing; it was the faster form on Node 22, but on Node 26 'count-keys' ties or wins there too. Keep the default unless you are pinned to an older V8 and have measured your own shapes; nothing detects the runtime at runtime.<br><strong>Allowed:</strong> <code>"count-enumerable"</code>, <code>"count-keys"</code></td>
+</tr>
 </tbody>
 </table>
 <!-- config-table-end -->
@@ -237,9 +246,10 @@ Three deliberate departures:
   Ajv accepts `"a string"` against `{ properties: { a: {} } }`; a parser has to
   return the type it declares, and the declared type is an object.
 
-If a strict parser cannot enforce something — a `$ref` cycle it would have to
-inline because the build emits a single file, a subschema using a keyword it
-cannot prove — generation **fails with an error naming the keyword** rather than
+If a strict parser cannot enforce something — a `$ref` cycle inside a subschema it
+has to match inline (`contains`, `not`, `propertyNames`, `dependentSchemas`, or an
+`unevaluated*` backstop), which the inline matcher will not unroll; a subschema
+using a keyword it cannot prove — generation **fails with an error naming the keyword** rather than
 emitting a parser that quietly accepts what the schema forbids. Coercing
 (non-strict) parsers are documented to repair rather than reject, so they ignore
 the rejecting keywords by design.
@@ -266,8 +276,9 @@ no I/O to answer the retrieval step. Everything else — applying the base URIs,
 walking anchors across documents, emitting a parser per definition and an import
 graph that links — the generator still has to do.
 
-Of the 41 that do not, **18** are the `ignores a non-object` cases that follow
-from the third departure above, and **12** are a keyword strict mode will not
+Of the 41 that do not, **18** follow from the third departure above — the
+`ignores a non-object` cases plus three `ref.json` cases where a recursive `$ref`
+lands on a root that declares `properties` — and **12** are a keyword strict mode will not
 approximate (a cyclic `$ref` with siblings, a cyclic `unevaluatedProperties`) —
 those cost a build error naming the cause, never a wrong verdict. The rest: **8**
 `$dynamicRef`s whose binding depends on the evaluation path (a generator emits one
@@ -296,20 +307,34 @@ keys) and `parseStrict` (assert + reject undeclared keys) halves of
 [`moltar/typescript-runtime-type-benchmarks`](https://github.com/moltar/typescript-runtime-type-benchmarks)
 against the other *pure* parsers — the ones that return a new typed value rather
 than mutating in place — [zod](https://zod.dev) and
-[TypeBox](https://github.com/sinclairzx81/typebox). Measured on Bun 1.4 (Linux
-x64), parsing valid input at steady state:
-
-| case | mode | mjst (generated) | zod | typebox |
-|:--|:--|--:|--:|--:|
-| user (4 fields) | parseSafe | **~18M** ops/s | ~3.7M ops/s | ~1.6M ops/s |
-| order (nested + array) | parseSafe | **~6.9M** ops/s | ~0.71M ops/s | ~0.24M ops/s |
-| user (4 fields) | parseStrict | **~14M** ops/s | ~2.3M ops/s | ~2.04M ops/s |
-| order (nested + array) | parseStrict | **~7M** ops/s | ~0.43M ops/s | ~0.36M ops/s |
-
-The upstream `assert` case (seven scalar roots plus a nested object) runs faster
-still — ~51M ops/s strict, ~127M safe — but at that size the numbers swing enough
-run-to-run that the ratio, not the absolute, is the honest signal: mjst lands
-~5–29× ahead of zod across every case above.
+[TypeBox](https://github.com/sinclairzx81/typebox).
+
+Both runtimes were measured together on one machine (Linux x64, a 4-vCPU cloud
+box, Bun 1.4.0 and Node 26.8.1 — the same machine and runtimes as every table in
+this repo), each cell the median of three separate runs of the whole suite.
+Within one sitting a cell repeats to within a few percent; the same suite
+measured hours later moved ~60% across every case at once, so read the ratios
+and treat the absolutes as a property of that box.
+
+Parsing valid input at steady state:
+
+| case | mode | Bun: mjst | Bun: zod | Bun: typebox | Node: mjst | Node: zod | Node: typebox |
+|:--|:--|--:|--:|--:|--:|--:|--:|
+| user (4 fields) | parseSafe | **~163M** | ~3.3M | ~1.7M | **~88M** | ~4.0M | ~0.67M |
+| order (nested + array) | parseSafe | **~7.7M** | ~0.60M | ~0.26M | **~8.2M** | ~0.64M | ~0.15M |
+| assert (moltar shape) | parseSafe | **~120M** | ~3.5M | ~0.87M | **~66M** | ~5.3M | ~0.35M |
+| user (4 fields) | parseStrict | **~43M** | ~1.9M | ~2.2M | **~55M** | ~2.7M | ~1.5M |
+| order (nested + array) | parseStrict | **~13M** | ~0.36M | ~0.43M | **~8.7M** | ~0.55M | ~0.25M |
+| assert (moltar shape) | parseStrict | **~44M** | ~1.4M | ~1.2M | **~34M** | ~3.5M | ~0.80M |
+
+<sub>ops/s, higher is better.</sub>
+
+Unlike the validator suite — where TypeBox's compiled checker takes the loose
+moltar shape on V8 — the generated parser leads every case on both engines:
+~12–49× over zod on Bun and ~13–22× on Node. The two `user`/`assert` safe cells
+are the ones to read as ratios rather than absolutes: stripping to four declared
+keys builds one small object and nothing else, which is fast enough that the
+engine's inlining, not the parser, sets the number.
 
 What is replicated upstream is the *cases* — the two parse modes and their
 shapes — not the harness. These numbers come from this repo's own measurement
@@ -321,9 +346,9 @@ reproducible run of both harnesses:
 [Against the moltar harness](../generate-validators#against-the-moltar-harness).
 
 The trade is a one-shot **prepare** cost that only mjst pays — generating the
-parser source — which measures **~0.2–0.8 ms** per schema here (zod and TypeBox
-author or interpret their parsers with no separate build step, so there is
-nothing to time). That is trivially amortized: you generate once at build time
+parser source — which measures **~0.20–0.74 ms** per schema on Bun and
+**~0.16–0.72 ms** on Node (zod and TypeBox author or interpret their parsers
+with no separate build step, so there is nothing to time). That is trivially amortized: you generate once at build time
 and run the emitted code forever.
 
 Every library is checked for agreement — same stripped/rejected output, same
@@ -333,9 +358,48 @@ the optimiser can't hoist the work away. Micro-benchmark figures vary by machine
 and runtime — reproduce with:
 
 ```bash
-bun run bench
+bun run bench        # Bun / JavaScriptCore
+bun run bench:node   # Node / V8 (builds the package first, then runs it under node)
 ```
 
+### Counting keys on the fast path
+
+A closed object whose declared properties are all required proves "no undeclared
+key" by counting: the typed checks ahead of the count have already proven every
+declared key present, so exactly *n* keys means no extra. `unknownKeys` (the 15th
+positional argument, `--unknown-keys` on the CLI) picks how the count is spelled,
+because the two spellings trade places between the engines:
+
+- **`'count-keys'`** (default) — `Object.getPrototypeOf(input) === Object.prototype
+  && Object.keys(input).length === n`, one more term of the fast-path guard. The
+  prototype guard keeps an own-key count sound: a crafted prototype could satisfy
+  the typed checks through an inherited declared key while an own extra kept the
+  count at *n*, so a non-plain object takes the cold path instead, whose `for…in`
+  rejection sees the inherited key.
+- **`'count-enumerable'`** — `let c = 0; for (const k in input) c++`, as
+  statements behind the guard. It allocates nothing and needs no prototype guard
+  (the count sees inherited keys too), and on V8 it is answered from the enum
+  cache. On JavaScriptCore a `for…in` over a non-extensible object is the engine's
+  slow path, and the strict parse runs at half speed.
+
+A nested object's shape is proven on the parent's fast path by the same checks
+its own shape validator makes, spelled out over the cached local rather than
+called — `typeof _nested === "object" && … && Object.keys(_nested).length === n`
+— one level deep and within a size budget, because a call was the one thing
+left on the strict fast path that JavaScriptCore would not see through. Under
+the moltar harness (each case alone in its own process) `parseStrict` reaches
+the harness floor on Bun 1.4.0 (~360M ops/s, the call eliminated) with
+`count-keys` against ~22M with `count-enumerable`.
+
+On Node the answer has moved with the engine. On Node 22 the two spellings were
+level (~14M either way, which is where the advice to flip it came from); on
+Node 26.8.1 `count-keys` measures ~29M against `count-enumerable`'s ~26M, so the
+default now ties or wins on both engines. Keep the default unless you are
+pinned to an older V8 and have measured your own shapes. See
+[Choosing how keys are counted](../generate-validators#choosing-how-keys-are-counted)
+in the sister package for the validator numbers and the full trade-off. Whichever
+you pick, every verdict on a value that could have come from JSON is the same.
+
 ---
 
 ## Related packages

package/dist/generators/build-schema.d.ts

@@ -1,3 +1,4 @@
+import { type UnknownKeysStrategy } from '@amritk/helpers/unknown-keys-strategy';
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
 import type { HelpersMode } from '../helpers/collect-helpers.js';
 import type { ImportExtension } from '../helpers/collect-imports.js';
@@ -70,6 +71,11 @@ export type GeneratedFile = {
  *   is yours to do (or `@amritk/resolve-refs`'), and a `$ref` to a URI nobody registered still
  *   stops generation. Only the documents actually referenced get files, so registering more
  *   than the schema uses costs nothing in the output.
+ * @param unknownKeys - How the generated fast paths prove a closed object
+ *   (`additionalProperties: false`, or a `stripUnknown` build) carries no undeclared key:
+ *   `'count-keys'` (the default) compares `Object.keys(input).length` behind a plain-prototype
+ *   guard, `'count-enumerable'` counts with `for…in`. The first is the faster form on
+ *   JavaScriptCore (Bun), the second on V8 (Node) — see the README for the measurements.
  * @returns An array of generated TypeScript files
  *
  * @example
@@ -102,4 +108,4 @@ export type GeneratedFile = {
  * });
  * ```
  */
-export declare const buildSchema: (rootSchema: JSONSchema, rootTypeName: string, extensions?: SchemaExtensions, typesOnly?: boolean, logWarnings?: boolean, strict?: boolean, helpersMode?: HelpersMode, helpersImportPrefix?: string, readonly?: boolean, stripUnknown?: boolean, typeSuffix?: string, importExt?: ImportExtension, caseInsensitive?: boolean, schemas?: Readonly<Record<string, unknown>>) => Promise<GeneratedFile[]>;
+export declare const buildSchema: (rootSchema: JSONSchema, rootTypeName: string, extensions?: SchemaExtensions, typesOnly?: boolean, logWarnings?: boolean, strict?: boolean, helpersMode?: HelpersMode, helpersImportPrefix?: string, readonly?: boolean, stripUnknown?: boolean, typeSuffix?: string, importExt?: ImportExtension, caseInsensitive?: boolean, schemas?: Readonly<Record<string, unknown>>, unknownKeys?: UnknownKeysStrategy) => Promise<GeneratedFile[]>;

package/dist/generators/build-schema.js

@@ -3,6 +3,7 @@ import { createRequire } from "node:module";
 import { dirname, resolve as resolvePath } from "node:path";
 import { foldNullable } from "@amritk/helpers/fold-nullable";
 import { generateIndexBarrel } from "@amritk/helpers/generate-index-barrel";
+import { DEFAULT_UNKNOWN_KEYS } from "@amritk/helpers/unknown-keys-strategy";
 import { walkRefGraph } from "@amritk/helpers/walk-ref-graph";
 import { applySchemaExtensions } from "../helpers/apply-schema-extensions.js";
 import { generateFile } from "./generate-files.js";
@@ -26,7 +27,7 @@ const assertRootTypeName = (rootTypeName) => {
     return;
   throw new Error(`Invalid root type name ${JSON.stringify(rootTypeName)}: expected a TypeScript identifier. The name is emitted as \`export type <name>\` and, lowercased, used as the output filename, so anything else either fails to compile or escapes the output directory. Derive it with @amritk/helpers' \`deriveRootTypeName\`, which always produces one.`);
 };
-const buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict, helpersMode = "package", helpersImportPrefix = "./", readonly = false, stripUnknown = false, typeSuffix = "", importExt = "js", caseInsensitive = false, schemas) => {
+const buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict, helpersMode = "package", helpersImportPrefix = "./", readonly = false, stripUnknown = false, typeSuffix = "", importExt = "js", caseInsensitive = false, schemas, unknownKeys = DEFAULT_UNKNOWN_KEYS) => {
   assertRootTypeName(rootTypeName);
   const files = [];
   const usedHelpers = /* @__PURE__ */ new Set();
@@ -49,7 +50,8 @@ const buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logW
       ...logWarnings !== void 0 ? { logWarnings } : {},
       ...strict !== void 0 ? { strict } : {},
       ...stripUnknown ? { stripUnknown } : {},
-      ...caseInsensitive ? { caseInsensitive } : {}
+      ...caseInsensitive ? { caseInsensitive } : {},
+      unknownKeys
     });
     files.push({ filename: `${node.filename}.ts`, content: result.content });
     for (const helper of result.usedHelpers)

package/dist/generators/generate-files.d.ts

@@ -1,3 +1,4 @@
+import { type UnknownKeysStrategy } from '@amritk/helpers/unknown-keys-strategy';
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
 import { type HelpersMode, type RuntimeHelperName } from '../helpers/collect-helpers.js';
 import { type ImportExtension } from '../helpers/collect-imports.js';
@@ -92,6 +93,12 @@ type GenerateFileOptions = {
      * already-valid input keeps the exact-match fast path.
      */
     readonly caseInsensitive?: boolean;
+    /**
+     * How the generated fast paths prove a closed object carries no undeclared
+     * key — `Object.keys` (the default) or a `for…in` count. See
+     * {@link UnknownKeysStrategy} for the trade-off between the two.
+     */
+    readonly unknownKeys?: UnknownKeysStrategy;
 };
 /** Result of generating a single parser file. */
 export type GeneratedFileContent = {

package/dist/generators/generate-files.js

@@ -1,4 +1,5 @@
 import { generateTypeDefinition } from "@amritk/helpers/generate-type-definition";
+import { DEFAULT_UNKNOWN_KEYS } from "@amritk/helpers/unknown-keys-strategy";
 import { collectHelpers } from "../helpers/collect-helpers.js";
 import { collectImports, collectImportTypeNames } from "../helpers/collect-imports.js";
 import { generateParserFunction, generateShapeValidator } from "./generate-parser-function.js";
@@ -40,12 +41,14 @@ const generateFile = (schema, typeName, options) => {
     rootSchema,
     typeSuffix
   });
-  const shapeValidator = generateShapeValidator(schema, typeName, true, typeSuffix, true, stripUnknown, reservedNames);
+  const unknownKeys = options?.unknownKeys ?? DEFAULT_UNKNOWN_KEYS;
+  const shapeValidator = generateShapeValidator(schema, typeName, true, typeSuffix, true, stripUnknown, reservedNames, unknownKeys);
   const parserFunction = generateParserFunction(schema, typeName, {
     useRefImports: true,
     typeSuffix,
     reservedNames,
     shapeValidatorSource: shapeValidator,
+    unknownKeys,
     ...options?.isRoot !== void 0 ? { isRoot: options.isRoot } : {},
     ...rootSchema !== void 0 ? { rootSchema } : {},
     ...options?.logWarnings !== void 0 ? { logWarnings: options.logWarnings } : {},

package/dist/generators/generate-parser-function.d.ts

@@ -1,3 +1,4 @@
+import { type UnknownKeysStrategy } from '@amritk/helpers/unknown-keys-strategy';
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
 /**
  * Options for controlling parser function generation behavior.
@@ -67,6 +68,13 @@ type GenerateParserOptions = {
      * exact `===` fast path and the hot path is unaffected.
      */
     readonly caseInsensitive?: boolean;
+    /**
+     * How the fast paths prove a closed object carries no undeclared key —
+     * `Object.getPrototypeOf(input) === Object.prototype && Object.keys(input).length`
+     * (the default) or a `for…in` count. See {@link UnknownKeysStrategy} for the
+     * trade-off, and {@link keyCountCheck} for what each form emits.
+     */
+    readonly unknownKeys?: UnknownKeysStrategy;
     /**
      * The exact source of the `validate{TypeName}Shape` predicate emitted into
      * the same file as this parser (generate-files produces it for the root
@@ -108,5 +116,5 @@ export declare const shapeValidatorFunctionName: (typeName: string) => string;
  * in additionalProperties). The stub is safe: parents calling it will fall
  * through to the slow path, matching the pre-deep-fast-path behavior.
  */
-export declare const generateShapeValidator: (schema: JSONSchema, typeName: string, useRefImports: boolean, suffix?: string, exported?: boolean, stripUnknown?: boolean, reservedNames?: ReadonlySet<string>) => string;
+export declare const generateShapeValidator: (schema: JSONSchema, typeName: string, useRefImports: boolean, suffix?: string, exported?: boolean, stripUnknown?: boolean, reservedNames?: ReadonlySet<string>, unknownKeys?: UnknownKeysStrategy) => string;
 export {};

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 {

package/dist/generators/generate-strict-assertion.d.ts

@@ -1,3 +1,4 @@
+import type { UnknownKeysStrategy } from '@amritk/helpers/unknown-keys-strategy';
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
 /**
  * Context for assertions that reach beyond the property's own schema: union
@@ -13,6 +14,11 @@ export type StrictAssertionContext = {
     readonly suffix?: string;
     readonly rootSchema?: Record<string, unknown>;
     readonly stripUnknown?: boolean;
+    /**
+     * The parser's `unknownKeys` option, carried so every object parser one of
+     * these contexts reaches counts keys on its fast path the same way.
+     */
+    readonly unknownKeys?: UnknownKeysStrategy;
     /**
      * Whether the parser these assertions run inside also emits the private
      * sub-parsers for its inline object properties (and inline-object array

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.20.1",
+  "version": "0.21.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -41,7 +41,11 @@
     "types:check": "tsgo -p . --noEmit",
     "test": "NODE_ENV=production vitest run --root ../.. generate-parsers",
     "generate-readme": "bun run ./scripts/generate-readme.ts",
-    "bench": "bun --conditions development ./bench/run.ts"
+    "prebench": "bun run --filter='@amritk/helpers' build && bun run build",
+    "bench": "bun --conditions development ./bench/run.ts",
+    "prebench:node": "bun run --filter='@amritk/helpers' build && bun run build",
+    "bench:node": "node ./bench/run.ts",
+    "bench:moltar": "bun --conditions development ./bench/moltar.ts"
   },
   "imports": {
     "#generators/*": "./src/generators/*.ts",
@@ -56,12 +60,13 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "^0.18.0"
+    "@amritk/helpers": "^0.19.0"
   },
   "devDependencies": {
-    "@amritk/generate-markdown": "^0.5.0",
+    "@amritk/generate-markdown": "^0.6.0",
     "@sinclair/typebox": "^0.34.49",
     "ajv": "^8.17.1",
+    "benny": "^3.7.1",
     "zod": "^4.4.3"
   }
 }