@amritk/generate-parsers 0.19.4 → 0.20.0

package/AI.md

@@ -26,7 +26,11 @@ const files = await buildSchema(schema, 'Document')
    To set a later flag you must pass every intervening positional. (The README's
    short form omits the trailing seven.)
 2. **It returns files in memory — it does NOT write to disk.** You write the
-   `GeneratedFile[]` (`{ filename, content }`) yourself.
+   `GeneratedFile[]` (`{ filename, content }`) yourself. `rootTypeName` becomes
+   that filename (lowercased) as well as the `export type` name, so it must be a
+   TypeScript identifier — `buildSchema` throws otherwise rather than hand you a
+   path that escapes your output directory. Derive it with `@amritk/helpers`'
+   `deriveRootTypeName`, which always produces one.
 3. **Output is more than one file per `$def`:** always an `index.ts` barrel, and
    (unless `typesOnly`) runtime helper files.
 4. **Default parsers COERCE invalid input to defaults** rather than throwing;

package/README.md

@@ -82,7 +82,7 @@ Every option after the first two is **positional** — pass them in this order:
 | # | Parameter | Type | Default | Description |
 |--:|:---|:---|:---|:---|
 | 1 | `rootSchema` | `JSONSchema` | — | The root schema to traverse. `$ref` and `$dynamicRef` are resolved recursively. |
-| 2 | `rootTypeName` | `string` | — | Name used for the root type (e.g. `"Document"`). |
+| 2 | `rootTypeName` | `string` | — | Name used for the root type (e.g. `"Document"`). Must be a TypeScript identifier: it is emitted verbatim as `export type <name>` and, lowercased, becomes the output filename, so a name derived from an untrusted document is refused rather than written outside your output directory. `@amritk/helpers`' `deriveRootTypeName` always produces one. |
 | 3 | `extensions` | `SchemaExtensions` | — | Map of definition name → extra optional properties to merge in before generation. |
 | 4 | `typesOnly` | `boolean` | — | Only emit `.ts` type definitions — skip parser functions and runtime helpers. |
 | 5 | `logWarnings` | `boolean` | — | Generated parsers emit a `console.warn` for every input key not declared in the schema's properties. |
@@ -296,23 +296,32 @@ 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.3 (Linux
+[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 | ~3M ops/s | ~1.6M ops/s |
-| order (nested + array) | parseSafe | **~7.2M** ops/s | ~0.59M ops/s | ~0.18M ops/s |
-| user (4 fields) | parseStrict | **~15M** ops/s | ~2M ops/s | ~2.05M ops/s |
-| order (nested + array) | parseStrict | **~8.5M** ops/s | ~0.38M ops/s | ~0.29M ops/s |
+| 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 — ~44M ops/s strict, ~97M safe — but at that size the numbers swing enough
+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
-~6–30× ahead of zod across every case above.
+~5–29× ahead of zod across every case above.
+
+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
+core (direct calls over a pool of distinct inputs, median of many trials) and
+are not comparable with the public leaderboard, which measures every operation
+through benny and reports something an order of magnitude smaller for the same
+function. `@amritk/generate-validators` carries the side-by-side and a
+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.15–1 ms** per schema here (zod and TypeBox
+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
 and run the emitted code forever.

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

@@ -19,7 +19,10 @@ export type GeneratedFile = {
  * TypeScript file, then emits an `index.ts` barrel re-exporting them all.
  *
  * @param rootSchema - The root JSON Schema to build from
- * @param rootTypeName - The name for the root type (e.g., "Document")
+ * @param rootTypeName - The name for the root type (e.g., "Document"). Must be a TypeScript
+ *   identifier: it is emitted verbatim as `export type <name>` and, lowercased, becomes the
+ *   output filename, so a name derived from an untrusted document is refused rather than
+ *   written outside the output directory.
  * @param extensions - Optional map of custom extension properties to add to specific definitions.
  *   Keys are definition names (matching $defs keys), values are records of extension property
  *   names to their JSON Schema definitions. Extensions are merged as optional properties before

package/dist/generators/build-schema.js

@@ -20,7 +20,14 @@ const readHelperSource = async (helper, importExt) => {
     return { ext: "js", content: compiled };
   }
 };
+const ROOT_TYPE_NAME = /^[\p{ID_Start}_$][\p{ID_Continue}$]*$/u;
+const assertRootTypeName = (rootTypeName) => {
+  if (ROOT_TYPE_NAME.test(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) => {
+  assertRootTypeName(rootTypeName);
   const files = [];
   const usedHelpers = /* @__PURE__ */ new Set();
   const foldedSchema = foldNullable(rootSchema);

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

@@ -151,7 +151,25 @@ const generateFallbackValue = (_, propSchema, useRefImports, suffix) => {
   return getDefaultValue(propSchema);
 };
 const PROTOTYPE_MEMBER_NAMES = new Set(Object.getOwnPropertyNames(Object.prototype));
-const declaresPrototypeMemberProperty = (schema) => hasProperties(schema) && Object.keys(schema.properties).some((key) => PROTOTYPE_MEMBER_NAMES.has(key));
+const declaresPrototypeMemberProperty = (schema, depth = 4) => {
+  if (!isSchemaObject(schema) || depth < 0)
+    return false;
+  if (hasProperties(schema) && Object.keys(schema.properties).some((key) => PROTOTYPE_MEMBER_NAMES.has(key)))
+    return true;
+  const record = schema;
+  const children = [];
+  if (hasProperties(schema))
+    children.push(...Object.values(schema.properties));
+  const items = record["items"];
+  if (Array.isArray(items))
+    children.push(...items);
+  else if (items !== void 0)
+    children.push(items);
+  const prefixItems = record["prefixItems"];
+  if (Array.isArray(prefixItems))
+    children.push(...prefixItems);
+  return children.some((child) => declaresPrototypeMemberProperty(child, depth - 1));
+};
 const generateFallbackObject = (schema, useRefImports, typeName, suffix, subTypeNames) => {
   if (!hasProperties(schema)) {
     return `{} as ${typeName}`;
@@ -183,33 +201,11 @@ const generateFallbackObject = (schema, useRefImports, typeName, suffix, subType
     }
   }
   result += "\n      }";
-  return declaresPrototypeMemberProperty(schema) ? `${result} as ${typeName}` : result;
+  return declaresPrototypeMemberProperty(schema) ? `${result} as unknown as ${typeName}` : result;
 };
 const scalarDefaultLiteral = (schema) => {
-  if (!isSchemaObject(schema))
-    return "{}";
-  if (hasConst(schema))
-    return JSON.stringify(schema.const);
-  if (hasEnum(schema) && schema.enum.length > 0)
-    return JSON.stringify(schema.enum[0]);
-  if (hasType(schema)) {
-    switch (schema.type) {
-      case "string":
-        return '""';
-      case "number":
-      case "integer":
-        return "0";
-      case "boolean":
-        return "false";
-      case "null":
-        return "null";
-      case "array":
-        return "[]";
-      case "object":
-        return "{}";
-    }
-  }
-  return "{}";
+  const value = getDefaultValue(schema);
+  return value === "undefined" ? "{}" : value;
 };
 const generateRefUnionDispatch = (functionName, typeName, schema, branches, strict, ctx) => {
   const rootSchema = ctx.rootSchema;
@@ -552,9 +548,57 @@ const exactKeyCountOf = (schema) => {
     return null;
   return declaredCount;
 };
-const shouldCacheVariable = (propSchema, _canFastPath, _useRefImports) => {
+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) => {
+  if (!isSchemaObject(childSchema) || !hasProperties(childSchema))
+    return null;
+  if (!stripUnknown)
+    return null;
+  if (hasAdditionalProperties(childSchema) && childSchema.additionalProperties === false)
+    return null;
+  if (hasAllOf(childSchema) || hasOneOf(childSchema) || hasAnyOf(childSchema))
+    return null;
+  if (hasFastPathBlockingKeyword(childSchema))
+    return null;
+  if (hasMinProperties(childSchema) || hasMaxProperties(childSchema))
+    return null;
+  if (exactKeyCountOf(childSchema) === null)
+    return null;
+  const { objects, arrayItems } = collectInlineSubTypes(childSchema, childTypeName, reservedNames);
+  if (objects.size > 0 || arrayItems.size > 0)
+    return null;
+  const props = childSchema.properties;
+  const keys = Object.keys(props);
+  if (keys.length === 0 || keys.length > INLINE_NESTED_MAX_PROPERTIES)
+    return null;
+  const checks = [];
+  const fields = [];
+  const readRoot = `(${objectExpr} as Record<string, any>)`;
+  for (const key of keys) {
+    const propSchema = props[key];
+    if (shouldUseRefImport(propSchema, useRefImports) || shouldUseArrayRefImport(propSchema, useRefImports) || shouldUseRecordRefImport(propSchema, useRefImports)) {
+      return null;
+    }
+    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 generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, exported = true, stripUnknown = false, rootSchema, reservedNames = NO_RESERVED_NAMES, caseInsensitive = false, shapeValidatorSource) => {
   const functionName = generateParserName(typeName);
   const exportPrefix = exported ? "export " : "";
@@ -592,9 +636,15 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
   }
   const strictKeys = hasStrictKeys(schema);
   const stripKeys = strictKeys || stripUnknown;
-  const exactKeyCount = stripKeys ? exactKeyCountOf(schema) : null;
+  const rejectsUnknownKeys = strict && isSchemaObject(schema) && hasAdditionalProperties(schema) && schema.additionalProperties === false && !("patternProperties" in schema) || false;
+  const guardKeys = stripKeys || rejectsUnknownKeys;
+  const fastPathBuildsDeclaredLiteral = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema));
+  const fastPathNeedsKnownKeys = guardKeys && (rejectsUnknownKeys || !fastPathBuildsDeclaredLiteral);
+  const droppedKnownKeysTerm = guardKeys && !fastPathNeedsKnownKeys;
+  const exactKeyCount = guardKeys ? exactKeyCountOf(schema) : null;
   const strictKeyCheck = unknownKeyCheck(propertyKeys, `_knownKeys${typeName}`);
-  if (stripKeys && exactKeyCount === null) {
+  const shapeValidatorNeedsKnownKeys = shapeValidatorSource?.includes(`_hasOnlyKnownKeys${typeName}(`) ?? false;
+  if ((fastPathNeedsKnownKeys || shapeValidatorNeedsKnownKeys) && exactKeyCount === null) {
     for (const declaration of strictKeyCheck.declarations) {
       preamble.push(`${declaration};`);
     }
@@ -602,7 +652,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
   for (const _k in input) if (${strictKeyCheck.isUnknown("_k")}) return false;
   return true;
 };`);
-  } else if (strict && strictKeys) {
+  } else if (rejectsUnknownKeys) {
     for (const declaration of strictKeyCheck.declarations) {
       preamble.push(`${declaration};`);
     }
@@ -661,13 +711,13 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       fastPathAccessorChecks.push(`Object.keys(input).length <= ${schema.maxProperties}`);
     }
   }
-  if (stripKeys) {
+  if (fastPathNeedsKnownKeys) {
     fastPathChecks.push(exactKeyCount !== null ? `Object.getPrototypeOf(input) === Object.prototype && Object.keys(input).length === ${exactKeyCount}` : `_hasOnlyKnownKeys${typeName}(input)`);
   }
   const deepGuard = canFastPath && fastPathChecks.length > 0 ? fastPathChecks.join(" && ") : null;
   const literalReturnUsesVars = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema)) && exported;
   let deepGuardExpr = deepGuard;
-  if (deepGuard !== null && shapeValidatorSource !== void 0 && !literalReturnUsesVars) {
+  if (deepGuard !== null && shapeValidatorSource !== void 0 && !literalReturnUsesVars && !droppedKnownKeysTerm) {
     const shapeFnName = shapeValidatorName(typeName);
     const shapeStrictKeysGuard = stripKeys && exactKeyCount === null ? `
   if (!_hasOnlyKnownKeys${typeName}(input)) return false;` : "";
@@ -710,7 +760,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
   const shallowGuard = canShallowGuard && shallowChecks.length > 0 ? shallowChecks.join(" && ") : null;
   const varDeclLines = [];
   for (const { key, varName, propSchema } of propInfo) {
-    if (shouldCacheVariable(propSchema, canFastPath, useRefImports)) {
+    if (shouldCacheVariable(propSchema)) {
       varDeclLines.push(`  const ${varName} = ${safeAccessor("input", key)};`);
     }
   }
@@ -728,6 +778,8 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
   }
   const buildObjectLines = (directAssign) => {
     const objectLines = [];
+    let inlinedSites = 0;
+    let inlinedProperties = 0;
     if (!stripKeys) {
       objectLines.push("    ...input,");
     }
@@ -740,12 +792,21 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       }
     }
     for (const { key, varName, isRequired, propSchema } of propInfo) {
-      const shouldCache = shouldCacheVariable(propSchema, canFastPath, useRefImports);
+      const shouldCache = shouldCacheVariable(propSchema);
       const accessor = shouldCache ? varName : safeAccessor("input", key);
       const subName = subTypeNames.get(key);
       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;
+          if (inlined !== null && inlinedProperties + inlined.propertyCount <= INLINE_NESTED_MAX_TOTAL_PROPERTIES) {
+            inlinedSites++;
+            inlinedProperties += inlined.propertyCount;
+            objectLines.push(`    ${safeLiteralKey(key)}: (${inlined.condition})
+      ? ${inlined.literal}
+      : ${subParserName}(${accessor}),`);
+            continue;
+          }
           objectLines.push(`    ${safeLiteralKey(key)}: ${subParserName}(${accessor}),`);
         } else {
           objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${subParserName}(${accessor}) }),`);
@@ -828,12 +889,11 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
     lines2.push(`  } as unknown as ${typeName};`);
   };
   const emitDeepGuardReturn = (lines2) => {
-    const canLiteral = stripKeys && !(isSchemaObject(schema) && hasAllOf(schema));
-    if (!canLiteral) {
+    if (!fastPathBuildsDeclaredLiteral) {
       lines2.push(`  if (${deepGuardExpr}) return { ...input } as ${typeName};`);
       return;
     }
-    if (!exported) {
+    if (!exported && fastPathNeedsKnownKeys) {
       lines2.push(`  if (${deepGuardExpr}) return input as ${typeName};`);
       return;
     }
@@ -848,12 +908,12 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         }
         continue;
       }
-      const accessor = shouldCacheVariable(propSchema, canFastPath, useRefImports) ? varName : safeAccessor("input", key);
+      const accessor = shouldCacheVariable(propSchema) ? varName : safeAccessor("input", key);
       fields.push(isRequired ? `    ${safeLiteralKey(key)}: ${accessor},` : `    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${accessor} }),`);
     }
     lines2.push(`  if (${deepGuardExpr}) return {`);
     lines2.push(fields.join("\n"));
-    lines2.push(`  } as ${typeName};`);
+    lines2.push(`  } as unknown as ${typeName};`);
   };
   const lines = [];
   lines.push(`${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {`);
@@ -870,7 +930,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       ...rootSchema !== void 0 ? { rootSchema } : {}
     }).slice(1);
     if (shallowGuard) {
-      if (!exported && deepGuard) {
+      if (!exported && deepGuard && fastPathNeedsKnownKeys) {
         const residual = [];
         for (let i = 0; i < fastPathChecks.length; i++) {
           const deep = fastPathChecks[i];
@@ -903,7 +963,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       for (const assertionLine of assertionLines) {
         lines.push(assertionLine);
       }
-      if (strictKeys) {
+      if (rejectsUnknownKeys) {
         lines.push(`  for (const _k in input) {`);
         lines.push(`    if (${strictKeyCheck.isUnknown("_k")}) throw new Error(\`[${typeName}] unknown property "\${_k}"\`);`);
         lines.push(`  }`);
@@ -1280,6 +1340,7 @@ const selectParserStrategy = (schema, typeName, options) => {
     stripUnknown,
     ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {}
   };
+  const copyLoopContext = { ...context, subParsers: false };
   if (!options?.isRoot && typeName === `Schema${suffix}`) {
     return generateSchemaObjectParser(typeName);
   }
@@ -1296,7 +1357,7 @@ const selectParserStrategy = (schema, typeName, options) => {
     });
   }
   if (hasProperties(schema) && isSchemaObject(schema) && "patternProperties" in schema) {
-    return generateCombinedObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown, caseInsensitive, context);
+    return generateCombinedObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown, caseInsensitive, copyLoopContext);
   }
   if (strict && isSchemaObject(schema) && Array.isArray(schema.type) && schema.type.includes("null")) {
     return generateNonObjectParser(typeName, schema, strict, {
@@ -1342,14 +1403,14 @@ const selectParserStrategy = (schema, typeName, options) => {
     });
   }
   if ("patternProperties" in schema) {
-    return generatePatternPropertiesParser(schema, typeName, useRefImports, suffix, strict, context);
+    return generatePatternPropertiesParser(schema, typeName, useRefImports, suffix, strict, copyLoopContext);
   }
   if ("additionalProperties" in schema && !hasProperties(schema)) {
     const additionalProps = schema.additionalProperties;
     if (additionalProps === true || additionalProps === false) {
       return generateEmptyObjectParser(typeName, strict, schema, context);
     }
-    return generateAdditionalPropertiesParser(schema, typeName, useRefImports, suffix, strict, context);
+    return generateAdditionalPropertiesParser(schema, typeName, useRefImports, suffix, strict, copyLoopContext);
   }
   if ("type" in schema && schema.type === "object" && !hasProperties(schema)) {
     return generateEmptyObjectParser(typeName, strict, schema, context);

package/dist/generators/generate-schema-checks.js

@@ -3,6 +3,8 @@ import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extens
 import { multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
 import { hasOwnCheck } from "@amritk/helpers/safe-accessor";
 import { hasAdditionalProperties, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { maxLengthPassExpr, minLengthPassExpr } from "@amritk/helpers/string-length-check";
+import { generateDeepEqualCheck } from "./generate-deep-equal-check.js";
 import { generateEnumCheck } from "./generate-enum-check.js";
 import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
 const OBJECT_KEYWORDS = [
@@ -95,10 +97,10 @@ const generateInferredChecks = (accessor, schema, type) => {
         checks.push(`${regexLiteral(schema.pattern)}.test(${accessor})`);
       }
       if (hasMinLength(schema)) {
-        checks.push(`${accessor}.length >= ${schema.minLength}`);
+        checks.push(minLengthPassExpr(accessor, schema.minLength));
       }
       if (hasMaxLength(schema)) {
-        checks.push(`${accessor}.length <= ${schema.maxLength}`);
+        checks.push(maxLengthPassExpr(accessor, schema.maxLength));
       }
       break;
     case "number":
@@ -140,6 +142,23 @@ const generateSchemaChecks = (accessor, schema) => {
   if (primitive) {
     return [`typeof ${accessor} === "${primitive}"`];
   }
+  if (hasConst(schema)) {
+    return [generateDeepEqualCheck(accessor, schema.const)];
+  }
+  if (isSchemaObject(schema) && Array.isArray(schema.type)) {
+    const branches = [];
+    for (const type of schema.type) {
+      if (typeof type !== "string")
+        continue;
+      const branch = generateSchemaChecks(accessor, { ...schema, type });
+      if (branch.length === 0)
+        continue;
+      branches.push(branch.length === 1 ? branch[0] : `(${branch.join(" && ")})`);
+    }
+    if (branches.length === 0)
+      return checks;
+    return [branches.length === 1 ? branches[0] : `(${branches.join(" || ")})`];
+  }
   if (!hasType(schema)) {
     const inferred = inferSchemaType(schema);
     if (!inferred) {
@@ -158,10 +177,10 @@ const generateSchemaChecks = (accessor, schema) => {
         checks.push(`${regexLiteral(schema.pattern)}.test(${accessor})`);
       }
       if (hasMinLength(schema)) {
-        checks.push(`${accessor}.length >= ${schema.minLength}`);
+        checks.push(minLengthPassExpr(accessor, schema.minLength));
       }
       if (hasMaxLength(schema)) {
-        checks.push(`${accessor}.length <= ${schema.maxLength}`);
+        checks.push(maxLengthPassExpr(accessor, schema.maxLength));
       }
       break;
     }
@@ -190,6 +209,13 @@ const generateSchemaChecks = (accessor, schema) => {
     case "boolean":
       checks.push(`typeof ${accessor} === "boolean"`);
       break;
+    // Without this the `null` branch of a union produced NO check, which reads
+    // as "this branch matches nothing": `{ anyOf: [{ type: 'string' },
+    // { type: 'null' }] }` rejected `null` — the one value the branch exists to
+    // admit — and the coercing build dropped the property instead of keeping it.
+    case "null":
+      checks.push(`${accessor} === null`);
+      break;
     case "array":
       checks.push(`Array.isArray(${accessor})`);
       if (hasMinItems(schema)) {

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

@@ -13,6 +13,17 @@ export type StrictAssertionContext = {
     readonly suffix?: string;
     readonly rootSchema?: Record<string, unknown>;
     readonly stripUnknown?: boolean;
+    /**
+     * Whether the parser these assertions run inside also emits the private
+     * sub-parsers for its inline object properties (and inline-object array
+     * items). `generateObjectParser` does, so the shape of such a property is
+     * proven by the call it delegates to and asserting it here would be
+     * redundant. The pattern-property parsers do NOT — they build their result
+     * with a copy loop — so a nested object property there is proven by nobody
+     * unless these assertions prove it. Defaults to true, the historical
+     * assumption.
+     */
+    readonly subParsers?: boolean;
 };
 /**
  * Why a node needs the whole-schema backstop, or `null` when the specialized

package/dist/generators/generate-strict-assertion.js

@@ -10,8 +10,9 @@ import { generateDeepEqualCheck } from "./generate-deep-equal-check.js";
 import { generateEnumCheck } from "./generate-enum-check.js";
 import { canEnforceUnion, generateUnionCheck, getUnionBranches, isExclusiveUnion, isInlineObjectProperty, multiTypeCheck } from "./generate-type-checks.js";
 import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
-import { everyTailItem, getPrefixItems, prefixItemsCapsLength, scalarItemTypeCheck } from "./generate-validation-expression.js";
+import { everyTailItem, getPrefixItems, plainScalarItemCheck, prefixItemsCapsLength } from "./generate-validation-expression.js";
 import { hasConstrainingRefSibling, subschemaMatchExpr } from "./subschema-match.js";
+const shapeIsDelegated = (schema, context) => (context.subParsers ?? true) && isInlineObjectProperty(schema);
 const matchContext = (context) => context.rootSchema ? { rootSchema: context.rootSchema } : {};
 const TYPELESS_CONSTRAINT_KEYWORDS = [
   "minimum",
@@ -212,11 +213,11 @@ const generateItemCheck = (schema, context) => {
     const label = items.enum.map((v) => JSON.stringify(v)).join(", ");
     return { check: generateEnumCheck("_it", items.enum), message: `items must be one of: ${label}` };
   }
-  const scalarCheck = scalarItemTypeCheck(items, "_it");
+  const scalarCheck = plainScalarItemCheck(items, "_it");
   if (scalarCheck !== null && isSchemaObject(items) && hasType(items)) {
     return { check: scalarCheck, message: `items expected ${typeLabel(items.type)}` };
   }
-  if (hasRef(items) && context.useRefImports === true || isInlineObjectProperty(items))
+  if (hasRef(items) && context.useRefImports === true || shapeIsDelegated(items, context))
     return null;
   const match = subschemaMatchExpr("_it", items, matchContext(context));
   if (match === null || match === "true")
@@ -232,6 +233,34 @@ const nullableObjectShapeChecks = (acc, schema, type, label, optional, context)
   const presence = optional ? `${acc} !== undefined && ${acc} !== null` : `${acc} !== null`;
   return [`  if (${presence} && !(${match})) ${throwError(`${label} does not match the declared object shape`)};`];
 };
+const objectShapeResidual = (schema, context) => {
+  if (!isSchemaObject(schema) || !hasType(schema) || schema.type !== "object")
+    return null;
+  if (shapeIsDelegated(schema, context))
+    return null;
+  const record = schema;
+  const residual = { type: "object" };
+  if (hasProperties(schema))
+    residual["properties"] = record["properties"];
+  if (hasRequired(schema))
+    residual["required"] = record["required"];
+  if (record["additionalProperties"] === false) {
+    residual["additionalProperties"] = false;
+    if ("patternProperties" in record)
+      residual["patternProperties"] = record["patternProperties"];
+  }
+  return "properties" in residual || "required" in residual || "additionalProperties" in residual ? residual : null;
+};
+const declaredObjectShapeChecks = (acc, schema, label, optional, context) => {
+  const residual = objectShapeResidual(schema, context);
+  if (residual === null)
+    return [];
+  const match = subschemaMatchExpr(acc, residual, matchContext(context));
+  if (match === null || match === "true")
+    return [];
+  const presence = optional ? `${acc} !== undefined && ` : "";
+  return [`  if (${presence}!(${match})) ${throwError(`${label} does not match the declared object shape`)};`];
+};
 const generateNotCheck = (acc, schema, label, optional, context) => {
   if (!isSchemaObject(schema) || !("not" in schema))
     return [];
@@ -518,6 +547,7 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName, contex
   lines.push(...generateAllOfChecks(acc, propSchema, field, !isRequired, context));
   lines.push(...generateUnionMatchChecks(acc, propSchema, field, !isRequired, context));
   lines.push(...generateConditionalChecks(acc, propSchema, field, context));
+  lines.push(...declaredObjectShapeChecks(acc, propSchema, field, !isRequired, context));
   const unionBranches = getUnionBranches(propSchema);
   if (unionBranches) {
     if (!context.stripUnknown && canEnforceUnion(unionBranches, context.rootSchema)) {

package/dist/generators/generate-type-checks.js

@@ -3,10 +3,11 @@ import { multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
 import { refToName } from "@amritk/helpers/ref-to-name";
 import { resolveRef } from "@amritk/helpers/resolve-ref";
 import { hasOwnCheck, safeAccessor } from "@amritk/helpers/safe-accessor";
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasType, hasUniqueItems, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { maxLengthPassExpr, minLengthPassExpr } from "@amritk/helpers/string-length-check";
 import { generateEnumCheck } from "./generate-enum-check.js";
 import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
-import { everyTailItem, getPrefixItems, prefixItemsCapsLength, scalarItemTypeCheck, singleTypeCheck } from "./generate-validation-expression.js";
+import { everyTailItem, getPrefixItems, plainScalarItemCheck, prefixItemsCapsLength, singleTypeCheck } from "./generate-validation-expression.js";
 import { hasConstrainingRefSibling, subschemaMatchExpr } from "./subschema-match.js";
 const shapeValidatorName = (typeName) => `validate${typeName}Shape`;
 const isInlineObjectProperty = (propSchema) => {
@@ -92,6 +93,10 @@ const CONSTRAINT_KEYWORDS = [
   "minProperties",
   "maxProperties"
 ];
+const hasBranchSiblingConstraint = (schema) => {
+  const record = schema;
+  return "type" in record || CONSTRAINT_KEYWORDS.some((keyword) => keyword in record);
+};
 const multiTypeCheck = (varName, schema, options = {}) => {
   if (!isSchemaObject(schema) || !Array.isArray(schema.type))
     return void 0;
@@ -125,6 +130,8 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
   }
   const branches = getUnionBranches(schema);
   if (branches) {
+    if (hasBranchSiblingConstraint(schema))
+      return null;
     return generateUnionCheck(varName, branches, useRefImports, suffix, isExclusiveUnion(schema));
   }
   if (hasOneOf(schema) || hasAnyOf(schema) || hasAllOf(schema) || "not" in schema) {
@@ -150,9 +157,9 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
       if (hasPattern(schema))
         checks.push(`${regexLiteral(schema.pattern)}.test(${varName})`);
       if (hasMinLength(schema))
-        checks.push(`${varName}.length >= ${schema.minLength}`);
+        checks.push(minLengthPassExpr(varName, schema.minLength));
       if (hasMaxLength(schema))
-        checks.push(`${varName}.length <= ${schema.maxLength}`);
+        checks.push(maxLengthPassExpr(varName, schema.maxLength));
       break;
     }
     case "number":
@@ -186,7 +193,7 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
       }
       if (hasItems(schema) && !Array.isArray(schema.items)) {
         const items = schema.items;
-        const itemCheck = scalarItemTypeCheck(items, "_it") ?? (isSchemaObject(items) && hasEnum(items) && items.enum.length > 0 ? generateEnumCheck("_it", items.enum) : null);
+        const itemCheck = plainScalarItemCheck(items, "_it") ?? (isSchemaObject(items) && hasEnum(items) && items.enum.length > 0 ? generateEnumCheck("_it", items.enum) : null);
         if (itemCheck) {
           checks.push(everyTailItem(varName, itemCheck, schema));
         } else if (!(isSchemaObject(items) && (hasRef(items) || isInlineObjectProperty(items)))) {
@@ -211,6 +218,8 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
       break;
     }
     case "object":
+      if (hasProperties(schema) || hasRequired(schema))
+        return null;
       checks.push(`isObject(${varName})`);
       if (hasMinProperties(schema))
         checks.push(`Object.keys(${varName}).length >= ${schema.minProperties}`);

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

@@ -6,6 +6,16 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * objects, arrays, unions, `$ref`s, and anything richer.
  */
 export declare const scalarItemTypeCheck: (itemSchema: JSONSchema, accessor: string) => string | null;
+/**
+ * {@link scalarItemTypeCheck}, but only for an item schema whose `type` is the
+ * *whole* constraint — the one case where the bare `typeof` test is an exact
+ * match rather than a weakening of it. Emit sites that need a check they can
+ * trust in both directions (a true-sound fast-path guard, a strict assertion
+ * that throws) take this one; the coercion path keeps the looser
+ * {@link isCoercibleItemSchema}, which coerces each element through the full
+ * per-element expression and so applies the constraints anyway.
+ */
+export declare const plainScalarItemCheck: (itemSchema: JSONSchema, accessor: string) => string | null;
 /**
  * True when an array's `items` schema can be coerced element-by-element by the
  * mapping slow path: single scalar types (via {@link scalarItemTypeCheck}) and

package/dist/generators/generate-validation-expression.js

@@ -4,6 +4,7 @@ import { multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
 import { resolveRef } from "@amritk/helpers/resolve-ref";
 import { hasOwnCheck, safeAccessor } from "@amritk/helpers/safe-accessor";
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { maxLengthPassExpr, minLengthPassExpr } from "@amritk/helpers/string-length-check";
 import { findDiscriminator } from "../helpers/find-discriminator.js";
 import { getDefaultValue } from "../helpers/get-default-value.js";
 import { generateDiscriminatedUnionValidation } from "./generate-discriminated-union-validation.js";
@@ -34,10 +35,43 @@ const scalarItemTypeCheck = (itemSchema, accessor) => {
       return null;
   }
 };
+const SCALAR_ITEM_CONSTRAINTS = [
+  "pattern",
+  "minLength",
+  "maxLength",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "const",
+  "$ref",
+  "not",
+  "allOf",
+  "anyOf",
+  "oneOf",
+  "if"
+];
+const plainScalarItemCheck = (itemSchema, accessor) => {
+  if (!isSchemaObject(itemSchema))
+    return null;
+  const record = itemSchema;
+  if (SCALAR_ITEM_CONSTRAINTS.some((keyword) => keyword in record))
+    return null;
+  return scalarItemTypeCheck(itemSchema, accessor);
+};
 const isCoercibleItemSchema = (itemSchema) => {
   if (scalarItemTypeCheck(itemSchema, "_it") !== null)
     return true;
-  return isSchemaObject(itemSchema) && hasEnum(itemSchema) && itemSchema.enum.length > 0;
+  if (!isSchemaObject(itemSchema))
+    return false;
+  const itemTypes = itemSchema["type"];
+  if (Array.isArray(itemTypes) && itemTypes.length > 0) {
+    return itemTypes.every((type) => typeof type === "string" && scalarItemTypeCheck({ type }, "_it") !== null);
+  }
+  if (hasConst(itemSchema))
+    return true;
+  return hasEnum(itemSchema) && itemSchema.enum.length > 0;
 };
 const getPrefixItems = (schema) => {
   if (!isSchemaObject(schema))
@@ -50,7 +84,7 @@ const getPrefixItems = (schema) => {
 const everyTailItem = (accessor, itemCheck, schema) => {
   const prefix = isSchemaObject(schema) ? schema["prefixItems"] : void 0;
   const tailStart = Array.isArray(prefix) ? prefix.length : 0;
-  return tailStart === 0 ? `${accessor}.every((_it) => ${itemCheck})` : `${accessor}.every((_it, _ix) => _ix < ${tailStart} || (${itemCheck}))`;
+  return tailStart === 0 ? `${accessor}.every((_it: unknown) => ${itemCheck})` : `${accessor}.every((_it: unknown, _ix: number) => _ix < ${tailStart} || (${itemCheck}))`;
 };
 const prefixItemsCapsLength = (schema) => {
   if (!isSchemaObject(schema))
@@ -83,25 +117,55 @@ const getTypeArray = (schema) => {
     return null;
   return schema.type;
 };
+const stringBoundChecks = (valueExpr, schema) => {
+  const checks = [];
+  if (hasPattern(schema))
+    checks.push(`${regexLiteral(schema.pattern)}.test(${valueExpr})`);
+  if (hasMinLength(schema))
+    checks.push(minLengthPassExpr(valueExpr, schema.minLength));
+  if (hasMaxLength(schema))
+    checks.push(maxLengthPassExpr(valueExpr, schema.maxLength));
+  return checks;
+};
+const numberBoundChecks = (valueExpr, schema) => {
+  const checks = [];
+  if (hasMinimum(schema))
+    checks.push(`${valueExpr} >= ${schema.minimum}`);
+  if (hasMaximum(schema))
+    checks.push(`${valueExpr} <= ${schema.maximum}`);
+  if (hasExclusiveMinimum(schema))
+    checks.push(`${valueExpr} > ${schema.exclusiveMinimum}`);
+  if (hasExclusiveMaximum(schema))
+    checks.push(`${valueExpr} < ${schema.exclusiveMaximum}`);
+  if (hasMultipleOf(schema))
+    checks.push(multipleOfPassExpr(valueExpr, schema.multipleOf));
+  return checks;
+};
 const getTypeCoercion = (accessor, schema, defaultValue) => {
   if (!hasType(schema)) {
     return null;
   }
   switch (schema.type) {
-    case "string":
-      return `String(${accessor})`;
-    case "number": {
-      const n = `Number(${accessor})`;
-      return `(Number.isFinite(${n}) ? ${n} : ${defaultValue})`;
+    case "string": {
+      const coerced = `String(${accessor})`;
+      const bounds = stringBoundChecks("_s", schema);
+      if (bounds.length === 0)
+        return coerced;
+      return `((_s) => ${bounds.join(" && ")} ? _s : ${defaultValue})(${coerced})`;
     }
+    case "number":
     case "integer": {
+      const wellFormed = schema.type === "integer" ? "Number.isInteger" : "Number.isFinite";
+      const bounds = numberBoundChecks("_n", schema);
       const n = `Number(${accessor})`;
-      return `(Number.isInteger(${n}) ? ${n} : ${defaultValue})`;
+      if (bounds.length === 0)
+        return `(${wellFormed}(${n}) ? ${n} : ${defaultValue})`;
+      return `((_n) => ${[`${wellFormed}(_n)`, ...bounds].join(" && ")} ? _n : ${defaultValue})(${n})`;
     }
     case "boolean":
       return `Boolean(${accessor})`;
     case "array":
-      return `[]`;
+      return defaultValue;
     case "object":
       return `typeof ${accessor} === "object" && ${accessor} !== null ? ${accessor} : ${defaultValue}`;
     default:
@@ -166,9 +230,9 @@ const generateValidationExpression = (key, schema, defaultValue, isRequired, roo
       for (let i = 1; i < allChecks.length; i++) {
         combinedCheck2 += " && " + allChecks[i];
       }
-      return `${combinedCheck2} ? ${accessor} : ${defaultValue}`;
+      return `${combinedCheck2} ? ${accessor} : ${isRequired ? defaultValue : "undefined"}`;
     }
-    return `${accessor} ?? ${defaultValue}`;
+    return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
   }
   if ("not" in schema && schema.not) {
     const notChecks = generateSchemaChecks(accessor, schema.not);
@@ -177,7 +241,7 @@ const generateValidationExpression = (key, schema, defaultValue, isRequired, roo
       for (let i = 1; i < notChecks.length; i++) {
         combinedNotCheck += " && " + notChecks[i];
       }
-      return `!(${combinedNotCheck}) ? ${accessor} : ${defaultValue}`;
+      return `!(${combinedNotCheck}) ? ${accessor} : ${isRequired ? defaultValue : "undefined"}`;
     }
   }
   if (hasConst(schema)) {
@@ -193,7 +257,7 @@ const generateValidationExpression = (key, schema, defaultValue, isRequired, roo
     }
   }
   if (!hasType(schema) && !hasEnum(schema)) {
-    return `${accessor} ?? ${defaultValue}`;
+    return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
   }
   const prefixItems = getPrefixItems(schema);
   if (hasType(schema) && schema.type === "array" && prefixItems) {
@@ -215,10 +279,10 @@ const generateValidationExpression = (key, schema, defaultValue, isRequired, roo
           checks.push(`${regexLiteral(schema.pattern)}.test(${accessor})`);
         }
         if (hasMinLength(schema)) {
-          checks.push(`${accessor}.length >= ${schema.minLength}`);
+          checks.push(minLengthPassExpr(accessor, schema.minLength));
         }
         if (hasMaxLength(schema)) {
-          checks.push(`${accessor}.length <= ${schema.maxLength}`);
+          checks.push(maxLengthPassExpr(accessor, schema.maxLength));
         }
         break;
       }
@@ -336,6 +400,7 @@ export {
   generateValidationExpression,
   getPrefixItems,
   isCoercibleItemSchema,
+  plainScalarItemCheck,
   prefixItemsCapsLength,
   scalarItemTypeCheck,
   singleTypeCheck

package/dist/generators/subschema-match.js

@@ -73,7 +73,7 @@ const ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
 const depthOf = (ctx) => ctx.depth ?? 0;
 const nest = (ctx) => ({ ...ctx, depth: depthOf(ctx) + 1 });
 const isObjectExpr = (acc) => `typeof ${acc} === "object" && ${acc} !== null && !Array.isArray(${acc})`;
-const recordOf = (acc) => `(${acc} as Record<string, unknown>)`;
+const recordOf = (acc) => `(${acc} as Record<string, any>)`;
 const patternEntriesOf = (schema) => {
   const source = schema["patternProperties"];
   if (typeof source !== "object" || source === null || Array.isArray(source))
@@ -118,7 +118,7 @@ const tupleShape = (schema) => {
 const arrayConstraints = (acc, schema, ctx) => {
   const c = [];
   const d = depthOf(ctx);
-  const elements = `(${acc} as unknown[])`;
+  const elements = `(${acc} as any[])`;
   if (hasMinItems(schema))
     c.push(`${acc}.length >= ${schema.minItems}`);
   if (hasMaxItems(schema))
@@ -182,7 +182,7 @@ const containsConstraint = (acc, schema, ctx) => {
   const match = subschemaMatchExpr(el, s["contains"], nest(ctx));
   if (match === null)
     return null;
-  const count = `(${acc} as unknown[]).filter((${el}) => ${match}).length`;
+  const count = `(${acc} as any[]).filter((${el}) => ${match}).length`;
   const bounds = [];
   if (min > 0)
     bounds.push(`${count} >= ${min}`);

package/dist/generators/unevaluated-match.js

@@ -52,7 +52,7 @@ const ownItemCoverage = (schema, indexVar, ignoreOwnUnevaluated) => {
 const containsCoverage = (schema, indexVar, acc, ctx, match) => {
   if (!("contains" in schema))
     return NONE;
-  const itemMatch = match(`(${acc} as unknown[])[${indexVar}]`, schema["contains"], nest(ctx));
+  const itemMatch = match(`(${acc} as any[])[${indexVar}]`, schema["contains"], nest(ctx));
   if (itemMatch === null)
     return null;
   if (itemMatch === "true")
@@ -186,7 +186,7 @@ const unevaluatedItemsExpr = (acc, schema, ctx, match) => {
     return null;
   if (coverage.all)
     return void 0;
-  const elements = `(${acc} as unknown[])`;
+  const elements = `(${acc} as any[])`;
   const covered = coverage.terms.length > 0 ? orJoin(coverage.terms) : null;
   if (unevaluated === false) {
     if (covered === null)

package/dist/helpers/get-default-value.js

@@ -44,6 +44,40 @@ const arrayFallback = (schema) => {
   }
   return `[${elements.join(", ")}]`;
 };
+const MAX_FALLBACK_LENGTH = 256;
+const stringFallback = (schema) => {
+  if (hasPattern(schema)) {
+    const patternDefault = generateDefaultFromPattern(schema.pattern);
+    if (patternDefault)
+      return patternDefault;
+    return '""';
+  }
+  const minLength = schema["minLength"];
+  if (typeof minLength !== "number" || !(minLength > 0))
+    return '""';
+  return JSON.stringify("x".repeat(Math.min(minLength, MAX_FALLBACK_LENGTH)));
+};
+const finiteKeyword = (schema, keyword) => {
+  const value = schema[keyword];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+};
+const numberFallback = (schema, integer) => {
+  const minimum = finiteKeyword(schema, "minimum");
+  const maximum = finiteKeyword(schema, "maximum");
+  const exclusiveMinimum = finiteKeyword(schema, "exclusiveMinimum");
+  const exclusiveMaximum = finiteKeyword(schema, "exclusiveMaximum");
+  const multipleOf = finiteKeyword(schema, "multipleOf");
+  const low = Math.max(minimum ?? -Infinity, exclusiveMinimum !== void 0 ? exclusiveMinimum + 1 : -Infinity);
+  const high = Math.min(maximum ?? Infinity, exclusiveMaximum !== void 0 ? exclusiveMaximum - 1 : Infinity);
+  let candidate = Math.min(Math.max(0, low), high);
+  if (integer)
+    candidate = Math.ceil(candidate);
+  if (multipleOf !== void 0 && multipleOf > 0 && candidate !== 0) {
+    candidate = Math.ceil(candidate / multipleOf) * multipleOf;
+  }
+  const satisfies = Number.isFinite(candidate) && (minimum === void 0 || candidate >= minimum) && (maximum === void 0 || candidate <= maximum) && (exclusiveMinimum === void 0 || candidate > exclusiveMinimum) && (exclusiveMaximum === void 0 || candidate < exclusiveMaximum) && (!integer || Number.isInteger(candidate)) && (multipleOf === void 0 || multipleOf <= 0 || Number.isInteger(candidate / multipleOf));
+  return satisfies ? String(candidate) : "0";
+};
 const getDefaultValue = (schema) => {
   if (!isSchemaObject(schema)) {
     return "undefined";
@@ -89,18 +123,11 @@ const getDefaultValue = (schema) => {
     return "undefined";
   }
   switch (schema.type) {
-    case "string": {
-      if (hasPattern(schema)) {
-        const patternDefault = generateDefaultFromPattern(schema.pattern);
-        if (patternDefault) {
-          return patternDefault;
-        }
-      }
-      return '""';
-    }
+    case "string":
+      return stringFallback(schema);
     case "number":
     case "integer":
-      return "0";
+      return numberFallback(schema, schema.type === "integer");
     case "boolean":
       return "false";
     case "null":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.19.4",
+  "version": "0.20.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -56,10 +56,10 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "^0.15.4"
+    "@amritk/helpers": "^0.17.0"
   },
   "devDependencies": {
-    "@amritk/generate-markdown": "^0.4.9",
+    "@amritk/generate-markdown": "^0.5.0",
     "@sinclair/typebox": "^0.34.49",
     "ajv": "^8.17.1",
     "zod": "^4.4.3"