@amritk/generate-parsers 0.7.2 → 0.9.0

package/README.md

@@ -132,7 +132,7 @@ Returns: `Promise<GeneratedFile[]>`.
 <td align="center"><code>false</code></td>
 </tr>
 <tr>
-<td colspan="5">Generate parsers that throw on type/shape mismatches (wrong type, missing required property, enum/pattern/min/max violations) instead of coercing invalid input to default values. Unknown extra keys are still allowed.</td>
+<td colspan="5">Generate parsers that throw on type/shape mismatches (wrong type, missing required property, enum/pattern/min/max violations) instead of coercing invalid input to default values. When a schema sets additionalProperties: false, undeclared keys throw too; otherwise they are still allowed.</td>
 </tr>
 </tbody>
 </table>

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

@@ -74,4 +74,3 @@ 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, typeSuffix?: string) => Promise<GeneratedFile[]>;
-//# sourceMappingURL=build-schema.d.ts.map

package/dist/generators/generate-default-from-pattern.d.ts

@@ -3,4 +3,3 @@
  * Recognizes common patterns and returns appropriate defaults.
  */
 export declare const generateDefaultFromPattern: (pattern: string) => string | null;
-//# sourceMappingURL=generate-default-from-pattern.d.ts.map

package/dist/generators/generate-discriminated-union-validation.d.ts

@@ -4,4 +4,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Uses a discriminator property to efficiently choose the correct schema.
  */
 export declare const generateDiscriminatedUnionValidation: (accessor: string, schemas: readonly JSONSchema[], discriminatorKey: string, defaultValue: string, isRequired: boolean) => string;
-//# sourceMappingURL=generate-discriminated-union-validation.d.ts.map

package/dist/generators/generate-enum-check.d.ts

@@ -3,4 +3,3 @@
  * Returns a string that checks if the value is in the allowed enum values.
  */
 export declare const generateEnumCheck: (accessor: string, enumValues: readonly unknown[]) => string;
-//# sourceMappingURL=generate-enum-check.d.ts.map

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

@@ -91,4 +91,3 @@ export type GeneratedFileContent = {
  */
 export declare const generateFile: (schema: JSONSchema, typeName: string, options?: GenerateFileOptions) => GeneratedFileContent;
 export {};
-//# sourceMappingURL=generate-files.d.ts.map

package/dist/generators/generate-non-discriminated-union-validation.d.ts

@@ -4,4 +4,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Tries each schema in order until one matches.
  */
 export declare const generateNonDiscriminatedUnionValidation: (accessor: string, schemas: readonly JSONSchema[], defaultValue: string, isRequired: boolean) => string;
-//# sourceMappingURL=generate-non-discriminated-union-validation.d.ts.map

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

@@ -17,7 +17,8 @@ type GenerateParserOptions = {
     /**
      * When true, the generated parser throws on type/shape mismatches instead
      * of coercing invalid input to default values. Throws on the first violation
-     * with a path-aware Error. Unknown extra keys are still allowed.
+     * with a path-aware Error. When the schema sets `additionalProperties: false`,
+     * undeclared keys throw too; otherwise they are still allowed.
      */
     readonly strict?: boolean;
     /**
@@ -54,6 +55,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) => string;
+export declare const generateShapeValidator: (schema: JSONSchema, typeName: string, useRefImports: boolean, suffix?: string, exported?: boolean) => string;
 export {};
-//# sourceMappingURL=generate-parser-function.d.ts.map

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

@@ -1,7 +1,8 @@
 import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { refToName } from '@amritk/helpers/ref-to-name';
 import { safeAccessor, safeKey } from '@amritk/helpers/safe-accessor';
-import { hasAllOf, hasAnyOf, hasConst, hasDefault, hasEnum, hasExamples, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasType, hasUniqueItems, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasDefault, hasEnum, hasExamples, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasType, hasUniqueItems, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { unknownKeyCheck } from '@amritk/helpers/unknown-key-check';
 import { getDefaultValue } from '../helpers/get-default-value.js';
 import { generateObjectStrictAssertion, generateScalarStrictAssertion } from './generate-strict-assertion.js';
 import { generateValidationExpression } from './generate-validation-expression.js';
@@ -252,7 +253,7 @@ const generateFallbackValue = (_, propSchema, useRefImports, suffix) => {
  * Generates a fallback object with required properties filled with default values.
  * This is used when input is not an object (undefined, null, etc.).
  */
-const generateFallbackObject = (schema, useRefImports, typeName, suffix) => {
+const generateFallbackObject = (schema, useRefImports, typeName, suffix, subTypeNames) => {
     if (!hasProperties(schema)) {
         return `{} as ${typeName}`;
     }
@@ -266,7 +267,12 @@ const generateFallbackObject = (schema, useRefImports, typeName, suffix) => {
     for (const [key, propSchema] of Object.entries(schema.properties)) {
         const isRequired = isPropertyRequired(key, schema);
         if (isRequired) {
-            const fallbackValue = generateFallbackValue(key, propSchema, useRefImports, suffix);
+            // Inline nested objects delegate to their sub-parser so the fallback
+            // carries proper deep defaults instead of an empty object literal.
+            const subName = subTypeNames?.get(key);
+            const fallbackValue = subName
+                ? `${generateParserName(subName)}(undefined)`
+                : generateFallbackValue(key, propSchema, useRefImports, suffix);
             if (fallbackValue === 'undefined') {
                 return `{} as ${typeName}`;
             }
@@ -344,6 +350,73 @@ const toVarName = (key) => {
  * whether `input` is already in the shape produced by the parser's fast path.
  */
 const shapeValidatorName = (typeName) => `validate${typeName}Shape`;
+/**
+ * Matches an inline nested object property — an object schema written directly
+ * under `properties` with its own `properties`, rather than referenced via
+ * `$ref`. These get a private sub-parser (and shape predicate) in the same
+ * generated file so their fields are actually parsed; anything involving
+ * composition, conditionals, enums, or record semantics keeps the existing
+ * code paths.
+ */
+const isInlineObjectProperty = (propSchema) => {
+    if (!isSchemaObject(propSchema))
+        return false;
+    if (hasRef(propSchema) || hasEnum(propSchema) || hasConst(propSchema))
+        return false;
+    if (hasOneOf(propSchema) || hasAnyOf(propSchema) || hasAllOf(propSchema))
+        return false;
+    if ('patternProperties' in propSchema || 'not' in propSchema || 'if' in propSchema)
+        return false;
+    // additionalProperties-as-schema records go through the record paths instead
+    if (hasAdditionalProperties(propSchema) && typeof propSchema.additionalProperties !== 'boolean')
+        return false;
+    return isObjectSchema(propSchema) && hasProperties(propSchema);
+};
+/**
+ * Builds the property-key → synthesized-type-name map for every inline nested
+ * object property of a schema, e.g. parent `Order` + key `shipTo` →
+ * `OrderShipTo`. Both the parser and the shape validator derive the map
+ * independently, so the naming (including collision suffixes) is a pure
+ * function of the schema and parent type name.
+ */
+const collectInlineObjectProperties = (schema, typeName) => {
+    const subTypeNames = new Map();
+    if (!hasProperties(schema))
+        return subTypeNames;
+    const used = new Set();
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (!isInlineObjectProperty(propSchema))
+            continue;
+        const pascal = key
+            .replace(/[^a-zA-Z0-9_$]/g, '_')
+            .split('_')
+            .filter((part) => part.length > 0)
+            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+            .join('');
+        let subName = `${typeName}${pascal || 'Value'}`;
+        while (used.has(subName))
+            subName = `${subName}_`;
+        used.add(subName);
+        subTypeNames.set(key, subName);
+    }
+    return subTypeNames;
+};
+/**
+ * True when the parser must reject (strict mode) or strip (coerce mode) every
+ * undeclared key: the schema sets `additionalProperties: false` and nothing
+ * else (key patterns, composition) can legitimately introduce extra keys.
+ */
+const hasStrictKeys = (schema) => {
+    if (!isSchemaObject(schema) || !hasProperties(schema))
+        return false;
+    if (!hasAdditionalProperties(schema) || schema.additionalProperties !== false)
+        return false;
+    if ('patternProperties' in schema)
+        return false;
+    if (hasAllOf(schema) || hasOneOf(schema) || hasAnyOf(schema))
+        return false;
+    return true;
+};
 /**
  * Generates a fast-path type check expression for a property.
  * Returns null if the schema is too complex for a simple type check
@@ -457,22 +530,52 @@ const shouldCacheVariable = (propSchema, _canFastPath, _useRefImports) => {
  * - Fast path that returns input directly when all properties are already valid
  * - Slow path with optimized expressions
  */
-const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict) => {
+const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, exported = true) => {
     const functionName = generateParserName(typeName);
+    const exportPrefix = exported ? 'export ' : '';
     if (!hasProperties(schema)) {
         if (strict) {
-            return `export const ${functionName} = (input: unknown): ${typeName} => {\n  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);\n  return input as ${typeName};\n};`;
+            return `${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {\n  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);\n  return input as ${typeName};\n};`;
         }
-        return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? input as ${typeName} : {} as ${typeName};`;
+        return `${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? input as ${typeName} : {} as ${typeName};`;
     }
-    const fallbackObject = generateFallbackObject(schema, useRefImports, typeName, suffix);
     const properties = Object.entries(schema.properties);
+    // Inline nested object properties get a private sub-parser (plus shape
+    // predicate and type alias) in the same file, so their fields are parsed for
+    // real instead of only passing an isObject check. The sub-parser recurses
+    // through this same generator, so nesting works to any depth.
+    const subTypeNames = collectInlineObjectProperties(schema, typeName);
+    const preamble = [];
+    for (const [key, subName] of subTypeNames) {
+        const propSchema = schema.properties[key];
+        preamble.push(`type ${subName} = ${typeName}[${JSON.stringify(key)}];`);
+        preamble.push(generateShapeValidator(propSchema, subName, useRefImports, suffix, false));
+        preamble.push(generateObjectParser(propSchema, subName, useRefImports, suffix, logWarnings, strict, false));
+    }
+    // additionalProperties: false — the per-key "is this undeclared" test inlines
+    // `!==` comparisons for a short key list and hoists a Set only for a long one
+    // (see unknownKeyCheck). The predicate form is shared by the fast path and the
+    // shape validator; strict mode throws with the offending key.
+    const strictKeys = hasStrictKeys(schema);
+    const strictKeyCheck = unknownKeyCheck(properties.map(([key]) => key), `_knownKeys${typeName}`);
+    if (strictKeys) {
+        for (const declaration of strictKeyCheck.declarations) {
+            preamble.push(`${declaration};`);
+        }
+        preamble.push(`const _hasOnlyKnownKeys${typeName} = (input: Record<string, unknown>): boolean => {\n  for (const _k in input) if (${strictKeyCheck.isUnknown('_k')}) return false;\n  return true;\n};`);
+    }
+    const fallbackObject = generateFallbackObject(schema, useRefImports, typeName, suffix, subTypeNames);
     const lines = [];
-    lines.push(`export const ${functionName} = (input: unknown): ${typeName} => {`);
+    lines.push(`${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {`);
     if (strict) {
         for (const assertionLine of generateObjectStrictAssertion(schema, typeName)) {
             lines.push(assertionLine);
         }
+        if (strictKeys) {
+            lines.push(`  for (const _k in input) {`);
+            lines.push(`    if (${strictKeyCheck.isUnknown('_k')}) throw new Error(\`[${typeName}] unknown property "\${_k}"\`);`);
+            lines.push(`  }`);
+        }
     }
     else {
         lines.push(`  if (!isObject(input)) return ${fallbackObject};`);
@@ -499,7 +602,12 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
                 canFastPath = false;
             }
             else {
-                const check = generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
+                const subName = subTypeNames.get(key);
+                // Inline nested objects fast-path through their private shape
+                // predicate, the same way $ref properties use the imported one.
+                const check = subName
+                    ? `${shapeValidatorName(subName)}(${varName})`
+                    : generatePropertyTypeCheck(varName, propSchema, useRefImports, suffix);
                 if (check === null) {
                     canFastPath = false;
                 }
@@ -514,6 +622,12 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
             }
         }
     }
+    // The fast path returns `{ ...input }`, so with additionalProperties: false
+    // it must only fire when no undeclared keys are present. Strict mode already
+    // threw on them above.
+    if (strictKeys && !strict) {
+        fastPathChecks.push(`_hasOnlyKnownKeys${typeName}(input)`);
+    }
     // Second pass: generate variable declarations only for properties that need them
     for (const { key, varName, propSchema } of propInfo) {
         if (shouldCacheVariable(propSchema, canFastPath, useRefImports)) {
@@ -522,10 +636,12 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
     }
     // Emit a warning for any input key not declared in the schema's properties
     if (logWarnings && propInfo.length > 0) {
-        const keysList = propInfo.map(({ key }) => JSON.stringify(key)).join(', ');
-        lines.push(`  const _knownKeys = new Set([${keysList}]);`);
+        const warnKeyCheck = unknownKeyCheck(propInfo.map(({ key }) => key), '_knownKeys');
+        for (const declaration of warnKeyCheck.declarations) {
+            lines.push(`  ${declaration};`);
+        }
         lines.push(`  for (const _k in input) {`);
-        lines.push(`    if (!_knownKeys.has(_k)) {`);
+        lines.push(`    if (${warnKeyCheck.isUnknown('_k')}) {`);
         lines.push(`      console.warn(\`[${typeName}] Unknown property "\${_k}"\`);`);
         lines.push(`    }`);
         lines.push(`  }`);
@@ -538,9 +654,13 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         }
         lines.push(`  if (${fastPathExpr}) return { ...input } as ${typeName};`);
     }
-    // Generate slow-path object construction
+    // Generate slow-path object construction. The input spread preserves
+    // undeclared keys, so it is dropped when additionalProperties: false —
+    // building from the declared properties alone strips them from the result.
     const objectLines = [];
-    objectLines.push('    ...input,');
+    if (!strictKeys) {
+        objectLines.push('    ...input,');
+    }
     // Spread allOf $ref parsers so their field coercions are applied before
     // the explicit property validations below.
     if (useRefImports && isSchemaObject(schema) && hasAllOf(schema)) {
@@ -554,6 +674,19 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
     for (const { key, varName, isRequired, propSchema } of propInfo) {
         const shouldCache = shouldCacheVariable(propSchema, canFastPath, useRefImports);
         const accessor = shouldCache ? varName : safeAccessor('input', key);
+        // Handle inline nested objects via their private sub-parser, mirroring
+        // how $ref properties delegate to the imported parser.
+        const subName = subTypeNames.get(key);
+        if (subName) {
+            const subParserName = generateParserName(subName);
+            if (isRequired) {
+                objectLines.push(`    ${safeKey(key)}: ${subParserName}(${accessor}),`);
+            }
+            else {
+                objectLines.push(`    ...(${accessor} !== undefined && { ${safeKey(key)}: ${subParserName}(${accessor}) }),`);
+            }
+            continue;
+        }
         // Handle direct $ref properties via imported parsers
         if (shouldUseRefImport(propSchema, useRefImports)) {
             const ref = propSchema.$ref;
@@ -613,20 +746,66 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         }
     }
     lines.push(`  return {`);
-    // objectLines[0] is safe: objectLines is always non-empty (has at least the closing brace line)
-    let objectBody = objectLines[0];
-    for (let i = 1; i < objectLines.length; i++) {
-        objectBody += '\n' + objectLines[i];
-    }
-    lines.push(objectBody);
+    lines.push(objectLines.join('\n'));
     lines.push(`  } as unknown as ${typeName};`);
     lines.push(`}`);
-    // lines[0] is safe: lines is always non-empty (it always has the function declaration)
-    let result = lines[0];
-    for (let i = 1; i < lines.length; i++) {
-        result += '\n' + lines[i];
-    }
-    return result;
+    const fn = lines.join('\n');
+    if (preamble.length === 0)
+        return fn;
+    return `${preamble.join('\n\n')}\n\n${fn}`;
+};
+/**
+ * Combined-parser variant for `properties` + `patternProperties` schemas that
+ * set `additionalProperties: false`. Declared properties are coerced as usual,
+ * keys matching any pattern are kept (the first `$ref` pattern is coerced via
+ * its imported parser when ref imports are on), and every other key is rejected
+ * in strict mode or stripped in coerce mode — matching the interpreter.
+ */
+const generateStrictCombinedParser = (schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict) => {
+    const declaredKeys = hasProperties(schema) ? Object.keys(schema.properties) : [];
+    // Below the inline threshold a key === "a" || key === "b" chain skips declared
+    // keys without the per-call Set allocation; a wider list hoists the Set.
+    const knownKeyCheck = unknownKeyCheck(declaredKeys, '_knownKeys');
+    // The first $ref pattern (when ref imports are on) coerces its matching values
+    // through the imported parser; the remaining patterns keep the raw value.
+    const refPattern = useRefImports ? patterns.find(([, ps]) => isSchemaObject(ps) && hasRef(ps)) : undefined;
+    const loopLines = [`    if (${knownKeyCheck.isKnown('key')}) continue;`];
+    if (refPattern) {
+        const parserName = generateParserName(refToName(refPattern[1].$ref, suffix));
+        loopLines.push(`    if (/${escapeRegexPattern(refPattern[0])}/.test(key)) {`);
+        loopLines.push(`      (result as Record<string, unknown>)[key] = ${parserName}(input[key]);`);
+        loopLines.push(`      continue;`);
+        loopLines.push(`    }`);
+    }
+    const keepConditions = patterns
+        .filter(([p]) => !(refPattern && p === refPattern[0]))
+        .map(([p]) => `/${escapeRegexPattern(p)}/.test(key)`);
+    if (keepConditions.length > 0) {
+        loopLines.push(`    if (${keepConditions.join(' || ')}) {`);
+        loopLines.push(`      (result as Record<string, unknown>)[key] = input[key];`);
+        loopLines.push(`      continue;`);
+        loopLines.push(`    }`);
+    }
+    // Unknown key: throw in strict mode, otherwise let it fall through (dropped,
+    // since it was never copied into `result`).
+    if (strict)
+        loopLines.push(`    throw new Error(\`[${typeName}] unknown property "\${key}"\`);`);
+    const notObjectBranch = strict
+        ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`
+        : `    return {} as unknown as ${typeName};`;
+    const resultBody = propertyLines.length > 0 ? `{\n${propertyLines.join('\n')}\n  }` : '{}';
+    // Only the Set form needs a declaration; the inline === chain is stateless.
+    const knownKeysDeclaration = knownKeyCheck.declarations.map((decl) => `  ${decl};\n`).join('');
+    return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) {
+${notObjectBranch}
+  }
+${knownKeysDeclaration}  const result = ${resultBody} as unknown as ${typeName};
+  for (const key in input) {
+${loopLines.join('\n')}
+  }
+  return result;
+};`;
 };
 /**
  * Generates a parser for schemas that have both properties AND patternProperties.
@@ -649,6 +828,14 @@ const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, l
     const patternProps = schema.patternProperties;
     const patterns = Object.entries(patternProps);
     const refPattern = patterns.find(([, ps]) => isSchemaObject(ps) && hasRef(ps));
+    const strictKeys = hasAdditionalProperties(schema) && schema.additionalProperties === false;
+    // With `additionalProperties: false`, keys matching neither a declared
+    // property nor any pattern must be rejected (strict) or stripped (coerce).
+    // The blanket `...input` spread used below cannot do that, so build a
+    // selective copy that mirrors the interpreter's undeclared-key handling.
+    if (strictKeys) {
+        return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict);
+    }
     if (!refPattern || !useRefImports) {
         return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict);
     }
@@ -775,6 +962,38 @@ const generatePatternPropertiesParser = (schema, typeName, useRefImports, suffix
     const notObjectBranch = strict
         ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`
         : `    return {} as unknown as ${typeName};`;
+    // With `additionalProperties: false`, only keys matching a pattern survive:
+    // others are rejected (strict) or stripped (coerce). Start from an empty
+    // object rather than spreading every input key.
+    const strictKeys = hasAdditionalProperties(schema) && schema.additionalProperties === false;
+    if (strictKeys) {
+        const loopLines = [`    if (/${escapedPattern}/.test(key)) {`];
+        if (patternAssignment) {
+            loopLines.push(`      const value = input[key];`);
+            loopLines.push(`      ${patternAssignment}`);
+        }
+        loopLines.push(`      continue;`);
+        loopLines.push(`    }`);
+        const keepConditions = patterns.slice(1).map(([p]) => `/${escapeRegexPattern(p)}/.test(key)`);
+        if (keepConditions.length > 0) {
+            loopLines.push(`    if (${keepConditions.join(' || ')}) {`);
+            loopLines.push(`      (result as Record<string, unknown>)[key] = input[key];`);
+            loopLines.push(`      continue;`);
+            loopLines.push(`    }`);
+        }
+        if (strict)
+            loopLines.push(`    throw new Error(\`[${typeName}] unknown property "\${key}"\`);`);
+        return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) {
+${notObjectBranch}
+  }
+  const result = {} as unknown as ${typeName};
+  for (const key in input) {
+${loopLines.join('\n')}
+  }
+  return result;
+};`;
+    }
     // Generate a parser that handles both pattern matching and x- extensions
     return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) {
@@ -1011,9 +1230,10 @@ export const shapeValidatorFunctionName = (typeName) => shapeValidatorName(typeN
  * in additionalProperties). The stub is safe: parents calling it will fall
  * through to the slow path, matching the pre-deep-fast-path behavior.
  */
-export const generateShapeValidator = (schema, typeName, useRefImports, suffix = '') => {
+export const generateShapeValidator = (schema, typeName, useRefImports, suffix = '', exported = true) => {
     const fnName = shapeValidatorName(typeName);
-    const stub = `export const ${fnName} = (_input: unknown): boolean => false;`;
+    const exportPrefix = exported ? 'export ' : '';
+    const stub = `${exportPrefix}const ${fnName} = (_input: unknown): boolean => false;`;
     if (!isSchemaObject(schema))
         return stub;
     if (!hasProperties(schema))
@@ -1030,6 +1250,12 @@ export const generateShapeValidator = (schema, typeName, useRefImports, suffix =
         return stub;
     }
     const properties = Object.entries(schema.properties);
+    // Same deterministic naming as the parser's sub-parser generation, so the
+    // referenced private shape predicates exist in the same file.
+    const subTypeNames = collectInlineObjectProperties(schema, typeName);
+    // With additionalProperties: false the shape only matches when every key is
+    // declared, so the parser's fast path will not smuggle extras through.
+    const strictKeysGuard = hasStrictKeys(schema) ? `\n  if (!_hasOnlyKnownKeys${typeName}(input)) return false;` : '';
     const checks = [];
     for (const [key, propSchema] of properties) {
         // Records of refs require iterating every value — too expensive for the fast path.
@@ -1038,7 +1264,10 @@ export const generateShapeValidator = (schema, typeName, useRefImports, suffix =
         }
         const accessor = safeAccessor('input', key);
         const isRequired = isPropertyRequired(key, schema);
-        const check = generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
+        const subName = subTypeNames.get(key);
+        const check = subName
+            ? `${shapeValidatorName(subName)}(${accessor})`
+            : generatePropertyTypeCheck(accessor, propSchema, useRefImports, suffix);
         if (check === null) {
             return stub;
         }
@@ -1050,14 +1279,20 @@ export const generateShapeValidator = (schema, typeName, useRefImports, suffix =
         }
     }
     if (checks.length === 0) {
-        return `export const ${fnName} = (input: unknown): boolean => isObject(input);`;
+        if (strictKeysGuard) {
+            return `${exportPrefix}const ${fnName} = (input: unknown): boolean => {
+  if (!isObject(input)) return false;${strictKeysGuard}
+  return true;
+};`;
+        }
+        return `${exportPrefix}const ${fnName} = (input: unknown): boolean => isObject(input);`;
     }
     let body = checks[0];
     for (let i = 1; i < checks.length; i++) {
         body += '\n    && ' + checks[i];
     }
-    return `export const ${fnName} = (input: unknown): boolean => {
-  if (!isObject(input)) return false;
+    return `${exportPrefix}const ${fnName} = (input: unknown): boolean => {
+  if (!isObject(input)) return false;${strictKeysGuard}
   return ${body};
 };`;
 };

package/dist/generators/generate-schema-checks.d.ts

@@ -3,4 +3,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Generates validation checks for a single schema (used in union validation).
  */
 export declare const generateSchemaChecks: (accessor: string, schema: JSONSchema) => string[];
-//# sourceMappingURL=generate-schema-checks.d.ts.map

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

@@ -16,4 +16,3 @@ export declare const generateObjectStrictAssertion: (schema: JSONSchema, typeNam
  * Returns null when the schema has no type information to assert on.
  */
 export declare const generateScalarStrictAssertion: (schema: JSONSchema, typeName: string) => string | null;
-//# sourceMappingURL=generate-strict-assertion.d.ts.map

package/dist/generators/generate-validation-expression.d.ts

@@ -5,4 +5,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Supports type checking, pattern validation, enum validation, union types, and $ref resolution.
  */
 export declare const generateValidationExpression: (key: string, schema: JSONSchema, defaultValue: string, isRequired: boolean, rootSchema?: Record<string, unknown>, visitedRefs?: Set<string>, accessorOverride?: string, knownNotUndefined?: boolean) => string;
-//# sourceMappingURL=generate-validation-expression.d.ts.map

package/dist/helpers/apply-schema-extensions.d.ts

@@ -33,4 +33,3 @@ import type { SchemaExtensions } from '../types/schema-extensions.js';
  * ```
  */
 export declare const applySchemaExtensions: (schema: JSONSchema, definitionName: string, extensions: SchemaExtensions) => JSONSchema;
-//# sourceMappingURL=apply-schema-extensions.d.ts.map

package/dist/helpers/collect-helpers.d.ts

@@ -21,4 +21,3 @@ export type CollectedHelpers = {
  *   `_helpers/` directory at the output root.
  */
 export declare const collectHelpers: (parserFunction: string, mode: HelpersMode, helpersImportPrefix?: string) => CollectedHelpers;
-//# sourceMappingURL=collect-helpers.d.ts.map

package/dist/helpers/collect-imports.d.ts

@@ -68,4 +68,3 @@ type CollectImportsOptions = {
  */
 export declare const collectImports: (schema: JSONSchema, options?: CollectImportsOptions) => string[];
 export {};
-//# sourceMappingURL=collect-imports.d.ts.map

package/dist/helpers/find-discriminator.d.ts

@@ -4,4 +4,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Returns the property name if a suitable discriminator is found, otherwise null.
  */
 export declare const findDiscriminator: (schemas: readonly JSONSchema[]) => string | null;
-//# sourceMappingURL=find-discriminator.d.ts.map

package/dist/helpers/get-default-value.d.ts

@@ -5,4 +5,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * These defaults ensure that parsing never fails, even with missing data.
  */
 export declare const getDefaultValue: (schema: JSONSchema) => string;
-//# sourceMappingURL=get-default-value.d.ts.map

package/dist/helpers/get-discriminator-value.d.ts

@@ -4,4 +4,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Returns the const value or single enum value if available.
  */
 export declare const getDiscriminatorValue: (schema: JSONSchema, discriminatorKey: string) => unknown | null;
-//# sourceMappingURL=get-discriminator-value.d.ts.map

package/dist/index.d.ts

@@ -1,2 +1 @@
 export { buildSchema, type GeneratedFile } from './generators/build-schema.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/schema-extensions.d.ts

@@ -32,4 +32,3 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * ```
  */
 export type SchemaExtensions = Record<string, Record<string, JSONSchema>>;
-//# sourceMappingURL=schema-extensions.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -23,8 +23,7 @@
     "url": "https://github.com/amritk/mjst/issues"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
@@ -42,14 +41,13 @@
   },
   "exports": {
     ".": {
-      "development": "./src/index.ts",
       "default": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.8.0",
+    "@amritk/helpers": "0.10.0",
     "@amritk/generate-markdown": "0.2.4"
   }
 }

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

@@ -1 +0,0 @@
-{"version":3,"file":"build-schema.d.ts","sourceRoot":"","sources":["../../src/generators/build-schema.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAEjE,OAAO,KAAK,EAAE,WAAW,EAAqB,MAAM,0BAA0B,CAAA;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAahE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,eAAO,MAAM,WAAW,eACV,UAAU,gBACR,MAAM,eACP,gBAAgB,cACjB,OAAO,gBACL,OAAO,WACZ,OAAO,gBACH,WAAW,4EAIvB,OAAO,CAAC,aAAa,EAAE,CAyCzB,CAAA"}

package/dist/generators/generate-default-from-pattern.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-default-from-pattern.d.ts","sourceRoot":"","sources":["../../src/generators/generate-default-from-pattern.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,0BAA0B,YAAa,MAAM,KAAG,MAAM,GAAG,IAkCrE,CAAA"}

package/dist/generators/generate-discriminated-union-validation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-discriminated-union-validation.d.ts","sourceRoot":"","sources":["../../src/generators/generate-discriminated-union-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAMjE;;;GAGG;AACH,eAAO,MAAM,oCAAoC,aACrC,MAAM,WACP,SAAS,UAAU,EAAE,oBACZ,MAAM,gBACV,MAAM,cACR,OAAO,KAClB,MAqCF,CAAA"}

package/dist/generators/generate-enum-check.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-enum-check.d.ts","sourceRoot":"","sources":["../../src/generators/generate-enum-check.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,iBAAiB,aAAc,MAAM,cAAc,SAAS,OAAO,EAAE,KAAG,MAGpF,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"generate-files.d.ts","sourceRoot":"","sources":["../../src/generators/generate-files.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACvB,MAAM,0BAA0B,CAAA;AAKjC;;GAEG;AACH,KAAK,mBAAmB,GAAG;IACzB;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAA;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7C;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAA;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IACrC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAED,iDAAiD;AACjD,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAA;CACrD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,YAAY,WACf,UAAU,YACR,MAAM,YACN,mBAAmB,KAC5B,oBA+CF,CAAA"}

package/dist/generators/generate-non-discriminated-union-validation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-non-discriminated-union-validation.d.ts","sourceRoot":"","sources":["../../src/generators/generate-non-discriminated-union-validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAIjE;;;GAGG;AACH,eAAO,MAAM,uCAAuC,aACxC,MAAM,WACP,SAAS,UAAU,EAAE,gBAChB,MAAM,cACR,OAAO,KAClB,MA0BF,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"generate-parser-function.d.ts","sourceRoot":"","sources":["../../src/generators/generate-parser-function.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAMjE;;GAEG;AACH,KAAK,qBAAqB,GAAG;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;IAChC;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AA4pCD;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,WACzB,UAAU,YACR,MAAM,YACN,qBAAqB,KAC9B,MAEF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,aAAc,MAAM,KAAG,MAAsC,CAAA;AAEpG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,WACzB,UAAU,YACR,MAAM,iBACD,OAAO,sBAErB,MAyDF,CAAA"}

package/dist/generators/generate-schema-checks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-schema-checks.d.ts","sourceRoot":"","sources":["../../src/generators/generate-schema-checks.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAIjE;;GAEG;AACH,eAAO,MAAM,oBAAoB,aAAc,MAAM,UAAU,UAAU,KAAG,MAAM,EAkGjF,CAAA"}