@amritk/generate-parsers 0.12.2 → 0.13.0

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

@@ -1,10 +1,14 @@
 import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { refToName } from '@amritk/helpers/ref-to-name';
+import { resolveRef } from '@amritk/helpers/resolve-ref';
 import { safeAccessor, safeKey } from '@amritk/helpers/safe-accessor';
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, 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, hasEnum, hasItems, hasOneOf, hasProperties, hasRef, hasType, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
 import { unknownKeyCheck } from '@amritk/helpers/unknown-key-check';
+import { findDiscriminator } from '../helpers/find-discriminator.js';
 import { getDefaultValue } from '../helpers/get-default-value.js';
+import { getDiscriminatorValue } from '../helpers/get-discriminator-value.js';
 import { generateObjectStrictAssertion, generateScalarStrictAssertion } from './generate-strict-assertion.js';
+import { canEnforceUnion, generatePropertyTypeCheck, generateUnionCheck, getUnionBranches, shapeValidatorName, } from './generate-type-checks.js';
 import { generateValidationExpression, scalarItemTypeCheck } from './generate-validation-expression.js';
 /**
  * Generates the parser function name from a type name.
@@ -41,7 +45,10 @@ const generateRequiredRefCall = (key, ref, suffix) => {
 const generateOptionalRefCall = (key, ref, suffix) => {
     const acc = safeAccessor('input', key);
     const parserName = generateParserName(refToName(ref, suffix));
-    return `...(${acc} && { ${safeKey(key)}: ${parserName}(${acc}) })`;
+    // Gate on presence, not truthiness: a `&&` guard skips parsing when the value
+    // is `false`/`0`/`""`/`null`, spreading it raw. `!== undefined` still omits an
+    // absent optional property but coerces every present one, matching the main path.
+    return `...(${acc} !== undefined && { ${safeKey(key)}: ${parserName}(${acc}) })`;
 };
 /**
  * Generates a validateArray call for required array properties with $ref items.
@@ -58,7 +65,8 @@ const generateRequiredArrayRefCall = (key, ref, suffix) => {
 const generateOptionalArrayRefCall = (key, ref, suffix) => {
     const parserName = generateParserName(refToName(ref, suffix));
     const acc = safeAccessor('input', key);
-    return `...(${acc} && { ${safeKey(key)}: validateArray(${acc}, ${parserName}) })`;
+    // Presence gating (not truthiness) so a falsy-but-present value is still parsed.
+    return `...(${acc} !== undefined && { ${safeKey(key)}: validateArray(${acc}, ${parserName}) })`;
 };
 /**
  * Generates a validateRecord call for required object properties with additionalProperties $ref.
@@ -76,7 +84,8 @@ const generateRequiredRecordRefCall = (key, ref, suffix) => {
 const generateOptionalRecordRefCall = (key, ref, suffix) => {
     const acc = safeAccessor('input', key);
     const parserName = generateParserName(refToName(ref, suffix));
-    return `...(${acc} && { ${safeKey(key)}: validateRecord(${acc}, ${parserName}) })`;
+    // Presence gating (not truthiness) so a falsy-but-present value is still parsed.
+    return `...(${acc} !== undefined && { ${safeKey(key)}: validateRecord(${acc}, ${parserName}) })`;
 };
 /**
  * Generates a spread entry for optional inline properties.
@@ -296,8 +305,99 @@ const scalarDefaultLiteral = (schema) => {
     }
     return '{}';
 };
-const generateNonObjectParser = (typeName, schema, strict) => {
+/**
+ * Emits a dispatcher for a top-level `oneOf`/`anyOf` whose branches are `$ref`s,
+ * when the branches share a discriminator (a `const`/`enum` tag such as `kind`).
+ * Each resolved branch's discriminant selects its imported parser, so a recursive
+ * discriminated union (e.g. `Expr = Lit | BinOp`, where `BinOp` has `Expr`
+ * children) is actually validated and dispatched instead of blindly cast. Returns
+ * `null` when it can't be done (no root schema, no discriminator, a non-ref
+ * branch, or ref imports disabled), so the caller keeps its passthrough fallback.
+ */
+const generateRefUnionDispatch = (functionName, typeName, branches, strict, ctx) => {
+    const rootSchema = ctx.rootSchema;
+    if (!ctx.useRefImports || rootSchema === undefined)
+        return null;
+    if (branches.length === 0 || !branches.every((b) => isSchemaObject(b) && hasRef(b)))
+        return null;
+    // Resolve each branch ref so we can read its discriminant tag and derive its
+    // imported parser name.
+    const resolved = branches.map((b) => {
+        const ref = b.$ref;
+        return { parser: generateParserName(refToName(ref, ctx.suffix)), schema: resolveRef(ref, rootSchema) };
+    });
+    if (resolved.some((r) => !isSchemaObject(r.schema)))
+        return null;
+    const discriminator = findDiscriminator(resolved.map((r) => r.schema));
+    if (discriminator === null)
+        return null;
+    const cases = [];
+    for (const r of resolved) {
+        const value = getDiscriminatorValue(r.schema, discriminator);
+        if (value === null)
+            return null;
+        cases.push({ value, parser: r.parser });
+    }
+    // Read the discriminant safely: `null`/`undefined` is guarded (a property read
+    // would throw), and a non-object primitive yields `undefined` (no branch matches).
+    const access = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(discriminator)
+        ? `.${discriminator}`
+        : `[${JSON.stringify(discriminator)}]`;
+    const discExpr = `input == null ? undefined : (input as Record<string, unknown>)${access}`;
+    // Fold branches into a nested ternary in declaration order:
+    // `_disc === "lit" ? parseLit(input) : _disc === "binop" ? parseBinop(input) : <fallback>`.
+    // Unmatched: strict throws (not a member of the union); non-strict coerces via the
+    // first branch's parser, preserving the coercing parser's lenient contract while
+    // still running real validation/coercion instead of a blind cast.
+    const fallback = strict
+        ? `(() => { throw new Error(${JSON.stringify(`[${typeName}] value does not match any union branch`)}); })()`
+        : `${cases[0]?.parser}(input)`;
+    let expr = fallback;
+    for (let i = cases.length - 1; i >= 0; i--) {
+        const c = cases[i];
+        if (c)
+            expr = `_disc === ${JSON.stringify(c.value)} ? ${c.parser}(input) : ${expr}`;
+    }
+    return `export const ${functionName} = (input: unknown): ${typeName} => {\n  const _disc = ${discExpr};\n  return ${expr};\n};`;
+};
+const generateNonObjectParser = (typeName, schema, strict, unionCtx) => {
     const functionName = generateParserName(typeName);
+    // A ref-branch discriminated union dispatches to its branch parsers in *both*
+    // modes (strict throws on an unmatched discriminant; non-strict coerces via the
+    // first branch). This runs before the `!strict` coercion block below so a strict
+    // recursive union is validated instead of blindly cast.
+    if (unionCtx && isSchemaObject(schema) && (hasOneOf(schema) || hasAnyOf(schema))) {
+        const branches = hasOneOf(schema) ? schema.oneOf : hasAnyOf(schema) ? schema.anyOf : [];
+        if (branches.length > 0 && branches.every((b) => isSchemaObject(b) && hasRef(b))) {
+            const dispatch = generateRefUnionDispatch(functionName, typeName, branches, strict, unionCtx);
+            if (dispatch !== null)
+                return dispatch;
+        }
+    }
+    // An alias definition (a bare `$ref` with no shape of its own, e.g. a root
+    // schema that is just `$ref: '#/$defs/expr'`) delegates to the referenced
+    // parser instead of blindly casting, in both modes. Guarded against
+    // self-reference: delegating to ourselves would recurse forever.
+    if (unionCtx?.useRefImports && isSchemaObject(schema) && hasRef(schema) && !hasProperties(schema)) {
+        const refName = refToName(schema.$ref, unionCtx.suffix);
+        if (refName !== typeName) {
+            return `export const ${functionName} = (input: unknown): ${typeName} => ${generateParserName(refName)}(input) as ${typeName};`;
+        }
+    }
+    // Strict union enforcement for inline (or mixed) branches: membership is the
+    // disjunction of per-branch checks, and a non-member throws. Only emitted
+    // when every branch check is false-sound (see canEnforceUnion) — otherwise a
+    // conservative stub validator somewhere in the graph could reject valid
+    // input — and never when stripping unknown keys (see UnionParserContext).
+    if (strict && unionCtx && isSchemaObject(schema)) {
+        const branches = getUnionBranches(schema);
+        if (branches && !unionCtx.stripUnknown && canEnforceUnion(branches, unionCtx.rootSchema)) {
+            const check = generateUnionCheck('input', branches, unionCtx.useRefImports, unionCtx.suffix);
+            if (check !== null) {
+                return `export const ${functionName} = (input: unknown): ${typeName} => {\n  if (!(${check})) throw new Error(${JSON.stringify(`[${typeName}] value does not match any union branch`)});\n  return input as ${typeName};\n};`;
+            }
+        }
+    }
     // `const`/`enum` define the value space directly (the generated type is a
     // literal / literal-union), so a non-member must coerce to a valid member —
     // otherwise the returned value would not be of the declared type. This runs
@@ -322,10 +422,7 @@ const generateNonObjectParser = (typeName, schema, strict) => {
         }
         // A top-level union must validate membership: an unmatched value is not of
         // the declared union type, so coerce it to a member-shaped default. Reuse the
-        // same union validation the property path uses. A `$ref` branch can't be
-        // validated inline here (the membership test would silently drop it and
-        // wrongly coerce a valid ref-shaped value), so fall through to a passthrough
-        // cast rather than discarding valid input.
+        // same union validation the property path uses.
         if (hasOneOf(schema) || hasAnyOf(schema)) {
             const branches = hasOneOf(schema) ? schema.oneOf : hasAnyOf(schema) ? schema.anyOf : [];
             const hasRefBranch = branches.some((b) => isSchemaObject(b) && hasRef(b));
@@ -334,6 +431,9 @@ const generateNonObjectParser = (typeName, schema, strict) => {
                 const expr = generateValidationExpression('', schema, fallback, true, undefined, undefined, 'input', true);
                 return `export const ${functionName} = (input: unknown): ${typeName} => (${expr}) as ${typeName};`;
             }
+            // Ref-branch union: a *discriminated* one was already dispatched above (both
+            // modes). Anything reaching here is non-discriminated, which can't be validated
+            // inline without risking dropping valid input — fall back to a passthrough cast.
             return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
         }
     }
@@ -356,8 +456,10 @@ const generateNonObjectParser = (typeName, schema, strict) => {
         case 'string':
             return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "string" ? input as ${typeName} : "" as ${typeName};`;
         case 'number':
-        case 'integer':
             return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "number" ? input as ${typeName} : 0 as ${typeName};`;
+        case 'integer':
+            // `integer` rejects non-integral numbers; a bare typeof would accept `1.5`.
+            return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "number" && Number.isInteger(input) ? input as ${typeName} : 0 as ${typeName};`;
         case 'boolean':
             return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "boolean" ? input as ${typeName} : false as ${typeName};`;
         case 'array': {
@@ -393,12 +495,6 @@ const toVarName = (key) => {
     const safe = key.replace(/[^a-zA-Z0-9_$]/g, '_');
     return `_${safe}`;
 };
-/**
- * Returns the shape-predicate function name for a given type name.
- * The predicate is generated alongside each parser and tells callers
- * 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
@@ -466,107 +562,6 @@ const hasStrictKeys = (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
- * (e.g. has unions, enums that require more elaborate validation).
- *
- * When `useRefImports` is true, $ref properties (and arrays of $refs) are
- * checked by calling the imported shape predicate, allowing parent parsers
- * to fast-path through nested ref types without recursing into their parsers.
- */
-const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
-    if (!isSchemaObject(schema))
-        return null;
-    // $ref via shape predicate (deep fast-path through nested types).
-    if (useRefImports && hasRef(schema)) {
-        const refName = refToName(schema.$ref, suffix);
-        return `${shapeValidatorName(refName)}(${varName})`;
-    }
-    // Skip fast path for complex schemas that need more elaborate validation
-    if (hasEnum(schema) ||
-        hasOneOf(schema) ||
-        hasAnyOf(schema) ||
-        hasAllOf(schema) ||
-        hasRef(schema) ||
-        'not' in schema) {
-        return null;
-    }
-    if (!hasType(schema))
-        return null;
-    // Array of $refs: each item must satisfy the imported shape predicate.
-    if (useRefImports &&
-        schema.type === 'array' &&
-        hasItems(schema) &&
-        isSchemaObject(schema.items) &&
-        hasRef(schema.items)) {
-        const refName = refToName(schema.items.$ref, suffix);
-        return `Array.isArray(${varName}) && ${varName}.every(${shapeValidatorName(refName)})`;
-    }
-    const checks = [];
-    switch (schema.type) {
-        case 'string': {
-            checks.push(`typeof ${varName} === "string"`);
-            if (hasPattern(schema))
-                checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${varName})`);
-            if (hasMinLength(schema))
-                checks.push(`${varName}.length >= ${schema.minLength}`);
-            if (hasMaxLength(schema))
-                checks.push(`${varName}.length <= ${schema.maxLength}`);
-            break;
-        }
-        case 'number':
-        case 'integer': {
-            checks.push(`typeof ${varName} === "number"`);
-            if (hasMinimum(schema))
-                checks.push(`${varName} >= ${schema.minimum}`);
-            if (hasMaximum(schema))
-                checks.push(`${varName} <= ${schema.maximum}`);
-            if (hasExclusiveMinimum(schema))
-                checks.push(`${varName} > ${schema.exclusiveMinimum}`);
-            if (hasExclusiveMaximum(schema))
-                checks.push(`${varName} < ${schema.exclusiveMaximum}`);
-            if (hasMultipleOf(schema))
-                checks.push(`${varName} % ${schema.multipleOf} === 0`);
-            break;
-        }
-        case 'boolean':
-            checks.push(`typeof ${varName} === "boolean"`);
-            break;
-        case 'array': {
-            checks.push(`Array.isArray(${varName})`);
-            if (hasMinItems(schema))
-                checks.push(`${varName}.length >= ${schema.minItems}`);
-            if (hasMaxItems(schema))
-                checks.push(`${varName}.length <= ${schema.maxItems}`);
-            if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-                checks.push(`new Set(${varName}).size === ${varName}.length`);
-            }
-            // For a scalar item type, every element must already be well-typed to take
-            // the fast path; a mistyped element routes the array to the slow path where
-            // each element is coerced.
-            if (hasItems(schema) && !Array.isArray(schema.items)) {
-                const itemCheck = scalarItemTypeCheck(schema.items, '_it');
-                if (itemCheck)
-                    checks.push(`${varName}.every((_it) => ${itemCheck})`);
-            }
-            break;
-        }
-        case 'object':
-            checks.push(`isObject(${varName})`);
-            break;
-        default:
-            return null;
-    }
-    if (checks.length === 0)
-        return null;
-    // checks[0] is safe: we guard with checks.length === 0 above
-    let result = checks[0];
-    for (let i = 1; i < checks.length; i++) {
-        result += ' && ' + checks[i];
-    }
-    return result;
-};
 /**
  * Determines if a property needs a local variable or can be inlined.
  * Schema-object properties are always cached: the slow-path ternary chain
@@ -587,7 +582,7 @@ 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, exported = true, stripUnknown = false) => {
+const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, exported = true, stripUnknown = false, rootSchema) => {
     const functionName = generateParserName(typeName);
     const exportPrefix = exported ? 'export ' : '';
     if (!hasProperties(schema)) {
@@ -607,7 +602,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         const propSchema = schema.properties[key];
         preamble.push(`type ${subName} = ${typeName}[${JSON.stringify(key)}];`);
         preamble.push(generateShapeValidator(propSchema, subName, useRefImports, suffix, false, stripUnknown));
-        preamble.push(generateObjectParser(propSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown));
+        preamble.push(generateObjectParser(propSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema));
     }
     // 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
@@ -641,9 +636,17 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         schema.allOf.some((entry) => isSchemaObject(entry) && hasRef(entry));
     let canFastPath = !hasAllOfRefParsers;
     const fastPathChecks = [];
+    // `toVarName` collapses distinct keys that differ only in non-identifier chars
+    // (e.g. `a-b` and `a.b` both → `_a_b`), which would emit two `const _a_b`
+    // declarations (TS2451). Dedupe by suffixing `_` until unique — the same
+    // approach `collectInlineObjectProperties` uses — so each key gets its own var.
+    const usedVarNames = new Set();
     for (const [key, propSchema] of properties) {
         const isRequired = isPropertyRequired(key, schema);
-        const varName = toVarName(key);
+        let varName = toVarName(key);
+        while (usedVarNames.has(varName))
+            varName = `${varName}_`;
+        usedVarNames.add(varName);
         propInfo.push({ key, varName, isRequired, propSchema });
         if (!canFastPath)
             continue;
@@ -897,7 +900,12 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         lines.push(...varDeclLines);
         lines.push(...warnLines);
         // The first assertion line is the `isObject` check, already done above.
-        const assertionLines = generateObjectStrictAssertion(schema, typeName).slice(1);
+        const assertionLines = generateObjectStrictAssertion(schema, typeName, {
+            useRefImports,
+            suffix,
+            stripUnknown,
+            ...(rootSchema !== undefined ? { rootSchema } : {}),
+        }).slice(1);
         if (shallowGuard) {
             // stripUnknown: a well-typed input skips the assertions and goes straight
             // to the strip build (which removes extras and recurses into sub-parsers).
@@ -1335,7 +1343,12 @@ const selectParserStrategy = (schema, typeName, options) => {
         (isSchemaObject(schema) && ('patternProperties' in schema || 'additionalProperties' in schema));
     // Handle non-object schemas with type-appropriate validation
     if (!isObjectLikeSchema && !isSchemaObject(schema)) {
-        return generateNonObjectParser(typeName, schema, strict);
+        return generateNonObjectParser(typeName, schema, strict, {
+            useRefImports,
+            suffix,
+            stripUnknown,
+            ...(options?.rootSchema !== undefined ? { rootSchema: options.rootSchema } : {}),
+        });
     }
     // Handle schemas with both properties AND patternProperties.
     // This generates a parser that handles known properties and also iterates
@@ -1348,7 +1361,7 @@ const selectParserStrategy = (schema, typeName, options) => {
     // properties AND conditional keywords use all declared properties rather than
     // only the if/then fragment.
     if (hasProperties(schema)) {
-        return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown);
+        return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, options?.rootSchema);
     }
     // Handle conditional schemas (if/then/else) for schemas without explicit properties.
     if (isSchemaObject(schema) && 'if' in schema && 'then' in schema && 'else' in schema) {
@@ -1362,7 +1375,12 @@ const selectParserStrategy = (schema, typeName, options) => {
     }
     // Handle non-object schemas with type-appropriate validation (no properties, no conditionals)
     if (!isObjectLikeSchema) {
-        return generateNonObjectParser(typeName, schema, strict);
+        return generateNonObjectParser(typeName, schema, strict, {
+            useRefImports,
+            suffix,
+            stripUnknown,
+            ...(options?.rootSchema !== undefined ? { rootSchema: options.rootSchema } : {}),
+        });
     }
     // Handle schemas with patternProperties (but no properties)
     if ('patternProperties' in schema) {
@@ -1421,6 +1439,31 @@ export const generateShapeValidator = (schema, typeName, useRefImports, suffix =
     const stub = `${exportPrefix}const ${fnName} = (_input: unknown): boolean => false;`;
     if (!isSchemaObject(schema))
         return stub;
+    // An alias definition (a bare `$ref` with no shape of its own) delegates to
+    // the referenced type's validator. Guarded against self-reference.
+    if (useRefImports && hasRef(schema) && !hasProperties(schema)) {
+        const refName = refToName(schema.$ref, suffix);
+        if (refName !== typeName) {
+            return `${exportPrefix}const ${fnName} = (input: unknown): boolean => ${shapeValidatorName(refName)}(input);`;
+        }
+        return stub;
+    }
+    // A pure union definition (file-level oneOf/anyOf without properties) gets a
+    // real membership predicate when every branch is checkable. A recursive
+    // union (e.g. `expr` whose branches $ref `expr` itself) works because the
+    // branch checks call this very validator by name at runtime. Skipped under
+    // stripUnknown: the branch checks carry no known-keys terms, so a `true`
+    // could not guarantee the parser's strip build would be a no-op.
+    if (!hasProperties(schema) && !('patternProperties' in schema) && !('if' in schema) && !stripUnknown) {
+        const branches = getUnionBranches(schema);
+        if (branches) {
+            const check = generateUnionCheck('input', branches, useRefImports, suffix);
+            if (check !== null) {
+                return `${exportPrefix}const ${fnName} = (input: unknown): boolean => ${check};`;
+            }
+        }
+        return stub;
+    }
     if (!hasProperties(schema))
         return stub;
     // Composition / conditional schemas can match in many shapes — bail.

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

@@ -1,5 +1,6 @@
 import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
+import { multipleOfPassExpr } from '@amritk/helpers/multiple-of-check';
 import { hasAdditionalProperties, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasRequired, hasType, hasUniqueItems, } from '@amritk/helpers/schema-guards';
 import { generateEnumCheck } from './generate-enum-check.js';
 /**
@@ -37,6 +38,10 @@ export const generateSchemaChecks = (accessor, schema) => {
         case 'number':
         case 'integer':
             checks.push(`typeof ${accessor} === "number"`);
+            // `integer` must reject non-integral numbers (a bare typeof accepts `1.5`).
+            if (schema.type === 'integer') {
+                checks.push(`Number.isInteger(${accessor})`);
+            }
             if (hasMinimum(schema)) {
                 checks.push(`${accessor} >= ${schema.minimum}`);
             }
@@ -50,7 +55,7 @@ export const generateSchemaChecks = (accessor, schema) => {
                 checks.push(`${accessor} < ${schema.exclusiveMaximum}`);
             }
             if (hasMultipleOf(schema)) {
-                checks.push(`${accessor} % ${schema.multipleOf} === 0`);
+                checks.push(multipleOfPassExpr(accessor, schema.multipleOf));
             }
             break;
         case 'boolean':
@@ -73,7 +78,7 @@ export const generateSchemaChecks = (accessor, schema) => {
             // Check required properties exist
             if (hasRequired(schema) && schema.required.length > 0) {
                 for (const requiredKey of schema.required) {
-                    checks.push(`"${requiredKey}" in ${accessor}`);
+                    checks.push(`${JSON.stringify(requiredKey)} in ${accessor}`);
                 }
             }
             // Check minProperties

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

@@ -1,4 +1,19 @@
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * Context for assertions that reach beyond the property's own schema: union
+ * membership checks may call imported `validate{X}Shape` predicates ($ref
+ * branches), which requires knowing the ref-import mode, the type-name suffix,
+ * and the root document (to prove those validators are real — see
+ * canEnforceUnion). `stripUnknown` disables union enforcement entirely, since
+ * shape validators then treat undeclared keys as a mismatch while the
+ * stripUnknown contract is to drop them.
+ */
+export type StrictAssertionContext = {
+    readonly useRefImports?: boolean;
+    readonly suffix?: string;
+    readonly rootSchema?: Record<string, unknown>;
+    readonly stripUnknown?: boolean;
+};
 /**
  * Generates strict-mode assertions for the body of an object parser.
  * Throws on:
@@ -10,7 +25,7 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Properties with a `$ref` are validated by the nested parser's own strict
  * check when that parser is invoked downstream.
  */
-export declare const generateObjectStrictAssertion: (schema: JSONSchema, typeName: string) => string[];
+export declare const generateObjectStrictAssertion: (schema: JSONSchema, typeName: string, context?: StrictAssertionContext) => string[];
 /**
  * Generates a single strict-mode assertion line for a non-object scalar parser.
  * Returns null when the schema has no type information to assert on.