@amritk/generate-parsers 0.12.1 → 0.12.3

package/README.md

@@ -97,52 +97,42 @@ Returns: `Promise<GeneratedFile[]>`.
 <thead>
 <tr>
 <th>Property</th>
-<th>CLI Flag</th>
 <th>Type</th>
-<th align="center">Required</th>
 <th align="center">Default</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>🏷️ <code>typesOnly</code></td>
-<td>—</td>
 <td><code>boolean</code></td>
-<td align="center">—</td>
 <td align="center"><code>false</code></td>
 </tr>
 <tr>
-<td colspan="5">Generate only TypeScript type definitions without parser functions. Runtime helper files (validators, isObject) are also omitted since they are only needed for parsers.</td>
+<td colspan="3">Generate only TypeScript type definitions without parser functions. Runtime helper files (validators, isObject) are also omitted since they are only needed for parsers.</td>
 </tr>
 <tr>
 <td>⚠️ <code>logWarnings</code></td>
-<td>—</td>
 <td><code>boolean</code></td>
-<td align="center">—</td>
 <td align="center"><code>false</code></td>
 </tr>
 <tr>
-<td colspan="5">Emit a console.warn in the generated parsers for every input key that is not declared in the schema's properties. Useful for detecting schema drift or unexpected data shapes at runtime.</td>
+<td colspan="3">Emit a console.warn in the generated parsers for every input key that is not declared in the schema's properties. Useful for detecting schema drift or unexpected data shapes at runtime.</td>
 </tr>
 <tr>
 <td>🚫 <code>strict</code></td>
-<td>—</td>
 <td><code>boolean</code></td>
-<td align="center">—</td>
 <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. When a schema sets additionalProperties: false, undeclared keys throw too; otherwise they are still allowed.</td>
+<td colspan="3">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>
 <tr>
 <td>🧹 <code>stripUnknown</code></td>
-<td>—</td>
 <td><code>boolean</code></td>
-<td align="center">—</td>
 <td align="center"><code>false</code></td>
 </tr>
 <tr>
-<td colspan="5">Build each parser's result from the schema's declared properties only, silently dropping undeclared input keys at every nesting level (zod's .strip()). Extras are never a validation error, so this composes with strict (which still throws on wrong types and missing required properties) and yields to additionalProperties: false, which rejects rather than strips in strict mode.</td>
+<td colspan="3">Build each parser's result from the schema's declared properties only, silently dropping undeclared input keys at every nesting level (zod's .strip()). Extras are never a validation error, so this composes with strict (which still throws on wrong types and missing required properties) and yields to additionalProperties: false, which rejects rather than strips in strict mode.</td>
 </tr>
 </tbody>
 </table>

package/dist/generators/build-schema.js

@@ -5,13 +5,28 @@ import { generateIndexBarrel } from '@amritk/helpers/generate-index-barrel';
 import { walkRefGraph } from '@amritk/helpers/walk-ref-graph';
 import { applySchemaExtensions } from '../helpers/apply-schema-extensions.js';
 import { generateFile } from './generate-files.js';
-/** Locate the @amritk/helpers package on disk so we can copy its runtime
- * helper source files into the generated output when in embedded mode. */
+/**
+ * Loads a runtime helper's source to copy into `_helpers/` in embedded mode.
+ *
+ * Prefers the TypeScript source (`src/<helper>.ts`), rewriting any extensionless
+ * sibling import (e.g. `validate-record` → `./is-object`) to `./is-object.js` so
+ * the embedded copy resolves under Node ESM, not only Bun. When the resolved
+ * `@amritk/helpers` is a published/cached tarball that ships only `dist/` (its
+ * `files` historically excluded `src/`, which is exactly why `bunx mjst` crashed
+ * on this lookup), it falls back to the always-published compiled `dist/<helper>.js`
+ * — which tsc already emits with `.js`-extension imports — and writes it verbatim.
+ */
 const readHelperSource = async (helper) => {
     const require = createRequire(import.meta.url);
-    const helpersPkgPath = require.resolve('@amritk/helpers/package.json');
-    const helpersRoot = dirname(helpersPkgPath);
-    return readFile(resolvePath(helpersRoot, 'src', `${helper}.ts`), 'utf-8');
+    const helpersRoot = dirname(require.resolve('@amritk/helpers/package.json'));
+    try {
+        const source = await readFile(resolvePath(helpersRoot, 'src', `${helper}.ts`), 'utf-8');
+        return { ext: 'ts', content: source.replace(/from '(/./[^'".]+)'/g, "from '$1.js'") };
+    }
+    catch {
+        const compiled = await readFile(resolvePath(helpersRoot, 'dist', `${helper}.js`), 'utf-8');
+        return { ext: 'js', content: compiled };
+    }
 };
 /**
  * Builds all TypeScript files from a JSON Schema by traversing its entire
@@ -114,8 +129,8 @@ export const buildSchema = async (rootSchema, rootTypeName, extensions, typesOnl
     // typesOnly skips parser generation entirely, so no runtime helpers are needed.
     if (helpersMode === 'embedded' && !typesOnly) {
         for (const helper of usedHelpers) {
-            const source = await readHelperSource(helper);
-            files.push({ filename: `_helpers/${helper}.ts`, content: source });
+            const { ext, content } = await readHelperSource(helper);
+            files.push({ filename: `_helpers/${helper}.${ext}`, content });
         }
     }
     files.push({ filename: 'index.ts', content: generateIndexBarrel(files, { typesOnly: typesOnly ?? false }) });

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

@@ -2,5 +2,14 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
 /**
  * Generates a discriminated union validation expression.
  * Uses a discriminator property to efficiently choose the correct schema.
+ *
+ * The emitted expression is a single *nested* ternary in schema order — for
+ * branches `dog`, `cat` it reads `disc === "dog" ? v : disc === "cat" ? v :
+ * <fallback>`. Each branch tests its discriminant (plus any per-branch shape
+ * checks) and, on a match, passes the value through; the innermost `else` is the
+ * shared fallback taken when no discriminant matches. The previous
+ * `cases[i] + ' : ' + result` folding spliced complete ternaries together
+ * (`c1 ? v : d1 : c0 ? v : d0`), which is a parse error for >=2 branches and
+ * also evaluated branches in reverse with the wrong per-case default.
  */
 export declare const generateDiscriminatedUnionValidation: (accessor: string, schemas: readonly JSONSchema[], discriminatorKey: string, defaultValue: string, isRequired: boolean) => string;

package/dist/generators/generate-discriminated-union-validation.js

@@ -1,38 +1,49 @@
-import { getDefaultValue } from '../helpers/get-default-value.js';
+import { safeAccessor } from '@amritk/helpers/safe-accessor';
 import { getDiscriminatorValue } from '../helpers/get-discriminator-value.js';
 import { generateSchemaChecks } from './generate-schema-checks.js';
 /**
  * Generates a discriminated union validation expression.
  * Uses a discriminator property to efficiently choose the correct schema.
+ *
+ * The emitted expression is a single *nested* ternary in schema order — for
+ * branches `dog`, `cat` it reads `disc === "dog" ? v : disc === "cat" ? v :
+ * <fallback>`. Each branch tests its discriminant (plus any per-branch shape
+ * checks) and, on a match, passes the value through; the innermost `else` is the
+ * shared fallback taken when no discriminant matches. The previous
+ * `cases[i] + ' : ' + result` folding spliced complete ternaries together
+ * (`c1 ? v : d1 : c0 ? v : d0`), which is a parse error for >=2 branches and
+ * also evaluated branches in reverse with the wrong per-case default.
  */
 export const generateDiscriminatedUnionValidation = (accessor, schemas, discriminatorKey, defaultValue, isRequired) => {
-    const cases = [];
+    // A non-identifier discriminator key (e.g. `x-type`) must use bracket access;
+    // `${accessor}?.${key}` would emit broken TS. `safeAccessor` picks dot vs
+    // bracket notation and JSON.stringifies the literal so quotes-in-keys are safe.
+    const discAccessor = safeAccessor(`${accessor}?`, discriminatorKey);
+    // Each branch contributes its guard condition and the value to yield on a
+    // match; the value is `accessor` because `generateSchemaChecks` has already
+    // proven the branch's shape (no coercion happens here).
+    const branches = [];
     for (const schema of schemas) {
         const discriminatorValue = getDiscriminatorValue(schema, discriminatorKey);
-        if (discriminatorValue !== null) {
-            const schemaDefault = getDefaultValue(schema);
-            const checks = generateSchemaChecks(accessor, schema);
-            if (checks.length > 0) {
-                // checks[0] is safe: we guard with checks.length > 0 above
-                let combinedChecks = checks[0];
-                for (let i = 1; i < checks.length; i++) {
-                    combinedChecks += ' && ' + checks[i];
-                }
-                cases.push(`${accessor}?.${discriminatorKey} === ${JSON.stringify(discriminatorValue)} && ${combinedChecks} ? ${accessor} : ${schemaDefault}`);
-            }
-            else {
-                cases.push(`${accessor}?.${discriminatorKey} === ${JSON.stringify(discriminatorValue)} ? ${accessor} : ${schemaDefault}`);
-            }
+        if (discriminatorValue === null)
+            continue;
+        let condition = `${discAccessor} === ${JSON.stringify(discriminatorValue)}`;
+        const checks = generateSchemaChecks(accessor, schema);
+        for (const check of checks) {
+            condition += ' && ' + check;
         }
+        branches.push(condition);
     }
-    if (cases.length === 0) {
+    if (branches.length === 0) {
         return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
     }
-    // Chain the cases together with ternary operators using a for loop instead of .reduce()
-    // cases[0] is safe: we guard with cases.length === 0 above
-    let result = cases[0];
-    for (let i = 1; i < cases.length; i++) {
-        result = cases[i] + ' : ' + result;
+    // When no discriminant matches, a required union coerces to the shared default;
+    // an optional one keeps the raw value untouched.
+    let result = isRequired ? defaultValue : accessor;
+    // Fold from the last branch inward so the final text lists branches in schema
+    // order: `cond0 ? accessor : cond1 ? accessor : <fallback>`.
+    for (let i = branches.length - 1; i >= 0; i--) {
+        result = `${branches[i]} ? ${accessor} : ${result}`;
     }
     return result;
 };

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

@@ -1,5 +1,13 @@
 /**
  * Generates an enum validation check expression.
  * Returns a string that checks if the value is in the allowed enum values.
+ *
+ * For the common all-primitive case this emits a parenthesized `x === a || x ===
+ * b` chain rather than `[a, b].includes(x)`. The `.includes` form allocates a
+ * fresh array on every call (this expression runs on the parser hot path); the
+ * `===` chain is allocation-free and matches the validators package's
+ * `enumMembershipExpr`. It falls back to `.includes` when a member is an
+ * object/array (reference equality) or `NaN` (where `includes`'s SameValueZero
+ * differs from `===`), so the verdict is unchanged.
  */
 export declare const generateEnumCheck: (accessor: string, enumValues: readonly unknown[]) => string;

package/dist/generators/generate-enum-check.js

@@ -1,8 +1,22 @@
 /**
  * Generates an enum validation check expression.
  * Returns a string that checks if the value is in the allowed enum values.
+ *
+ * For the common all-primitive case this emits a parenthesized `x === a || x ===
+ * b` chain rather than `[a, b].includes(x)`. The `.includes` form allocates a
+ * fresh array on every call (this expression runs on the parser hot path); the
+ * `===` chain is allocation-free and matches the validators package's
+ * `enumMembershipExpr`. It falls back to `.includes` when a member is an
+ * object/array (reference equality) or `NaN` (where `includes`'s SameValueZero
+ * differs from `===`), so the verdict is unchanged.
  */
 export const generateEnumCheck = (accessor, enumValues) => {
+    const allPrimitive = enumValues.length > 0 &&
+        enumValues.every((v) => (v === null || typeof v !== 'object') && typeof v !== 'function') &&
+        !enumValues.some((v) => typeof v === 'number' && Number.isNaN(v));
+    if (allPrimitive) {
+        return `(${enumValues.map((v) => `${accessor} === ${JSON.stringify(v)}`).join(' || ')})`;
+    }
     const serializedEnum = JSON.stringify(enumValues);
     return `${serializedEnum}.includes(${accessor} as never)`;
 };

package/dist/generators/generate-files.js

@@ -55,6 +55,7 @@ export const generateFile = (schema, typeName, options) => {
     const parserFunction = generateParserFunction(schema, typeName, {
         useRefImports: true,
         typeSuffix,
+        ...(rootSchema !== undefined ? { rootSchema } : {}),
         ...(options?.logWarnings !== undefined ? { logWarnings: options.logWarnings } : {}),
         ...(options?.strict !== undefined ? { strict: options.strict } : {}),
         ...(options?.stripUnknown !== undefined ? { stripUnknown: options.stripUnknown } : {}),

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

@@ -36,6 +36,12 @@ type GenerateParserOptions = {
      * the suffix used when generating the referenced files. Defaults to `''`.
      */
     readonly typeSuffix?: string;
+    /**
+     * The root schema document. When present, a top-level `oneOf`/`anyOf` whose
+     * branches are `$ref`s can be resolved to find a shared discriminator and emit a
+     * dispatch to the branch parsers, instead of falling back to a passthrough cast.
+     */
+    readonly rootSchema?: Record<string, unknown>;
 };
 /**
  * Generates a safe parser as an arrow function that never throws.

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

@@ -1,9 +1,13 @@
 import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
+import { multipleOfPassExpr } from '@amritk/helpers/multiple-of-check';
 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 { 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 { generateValidationExpression, scalarItemTypeCheck } from './generate-validation-expression.js';
 /**
@@ -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,75 @@ 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;
+        }
+    }
     // `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 +398,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 +407,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 +432,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': {
@@ -492,6 +570,14 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
         'not' in schema) {
         return null;
     }
+    // A `const` property (the usual discriminated-union tag, e.g. `kind: "lit"`) has
+    // no `type`, but is fast-path predicable via strict equality. Handling it here is
+    // what lets a discriminated branch's shape validator be a real predicate instead
+    // of the `=> false` stub. Structural consts need deep equality, so skip those.
+    if (hasConst(schema)) {
+        const c = schema.const;
+        return c === null || typeof c !== 'object' ? `${varName} === ${JSON.stringify(c)}` : null;
+    }
     if (!hasType(schema))
         return null;
     // Array of $refs: each item must satisfy the imported shape predicate.
@@ -518,6 +604,10 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
         case 'number':
         case 'integer': {
             checks.push(`typeof ${varName} === "number"`);
+            // `integer` must reject non-integral numbers on the fast path too, otherwise
+            // `1.5` would pass through uncoerced.
+            if (schema.type === 'integer')
+                checks.push(`Number.isInteger(${varName})`);
             if (hasMinimum(schema))
                 checks.push(`${varName} >= ${schema.minimum}`);
             if (hasMaximum(schema))
@@ -527,7 +617,7 @@ const generatePropertyTypeCheck = (varName, schema, useRefImports, suffix) => {
             if (hasExclusiveMaximum(schema))
                 checks.push(`${varName} < ${schema.exclusiveMaximum}`);
             if (hasMultipleOf(schema))
-                checks.push(`${varName} % ${schema.multipleOf} === 0`);
+                checks.push(multipleOfPassExpr(varName, schema.multipleOf));
             break;
         }
         case 'boolean':
@@ -641,9 +731,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;
@@ -1335,7 +1433,11 @@ 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,
+            ...(options?.rootSchema !== undefined ? { rootSchema: options.rootSchema } : {}),
+        });
     }
     // Handle schemas with both properties AND patternProperties.
     // This generates a parser that handles known properties and also iterates
@@ -1362,7 +1464,11 @@ 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,
+            ...(options?.rootSchema !== undefined ? { rootSchema: options.rootSchema } : {}),
+        });
     }
     // Handle schemas with patternProperties (but no properties)
     if ('patternProperties' in schema) {

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.js

@@ -1,7 +1,8 @@
 import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
+import { multipleOfFailExpr } from '@amritk/helpers/multiple-of-check';
 import { safeAccessor } from '@amritk/helpers/safe-accessor';
-import { hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaximum, hasMaxLength, hasMinimum, hasMinLength, hasMultipleOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject, } from '@amritk/helpers/schema-guards';
 /**
  * Returns the inline condition that is true when `accessor` is the wrong type
  * for the given JSON Schema primitive type.
@@ -11,8 +12,10 @@ const wrongTypeCondition = (accessor, type) => {
         case 'string':
             return `typeof ${accessor} !== "string"`;
         case 'number':
-        case 'integer':
             return `typeof ${accessor} !== "number"`;
+        case 'integer':
+            // `integer` also rejects non-integral numbers; a bare typeof accepts `1.5`.
+            return `(typeof ${accessor} !== "number" || !Number.isInteger(${accessor}))`;
         case 'boolean':
             return `typeof ${accessor} !== "boolean"`;
         case 'array':
@@ -28,6 +31,18 @@ const wrongTypeCondition = (accessor, type) => {
  * `integer` collapses to `number` since both are validated via `typeof === "number"`.
  */
 const typeLabel = (type) => (type === 'integer' ? 'number' : type);
+/**
+ * Emits `throw new Error(<message>[ + <suffixExpr>])`. The static message may
+ * contain schema-controlled text (property names, patterns, enum values), so it
+ * is always serialized with `JSON.stringify` — a key like `it's` or a pattern
+ * containing a quote or newline can no longer break out of the string literal or
+ * inject code. `suffixExpr`, when given, is a runtime expression appended to the
+ * message (e.g. `typeof input`).
+ */
+const throwError = (message, suffixExpr) => {
+    const literal = JSON.stringify(message);
+    return suffixExpr ? `throw new Error(${literal} + (${suffixExpr}))` : `throw new Error(${literal})`;
+};
 /**
  * Generates strict-mode constraint checks for a typed property
  * (pattern, length, min/max, multipleOf).
@@ -37,33 +52,47 @@ const generateConstraintChecks = (acc, propSchema, typeName, key) => {
         return [];
     const t = propSchema.type;
     const lines = [];
+    const field = `[${typeName}] field '${key}'`;
     if (t === 'string') {
         if (hasPattern(propSchema)) {
             const pattern = escapeRegexPattern(propSchema.pattern);
-            lines.push(`  if (typeof ${acc} === "string" && !/${pattern}/.test(${acc})) throw new Error('[${typeName}] field "${key}" must match pattern ${propSchema.pattern}');`);
+            lines.push(`  if (typeof ${acc} === "string" && !/${pattern}/.test(${acc})) ${throwError(`${field} must match pattern ${propSchema.pattern}`)};`);
         }
         if (hasMinLength(propSchema)) {
-            lines.push(`  if (typeof ${acc} === "string" && ${acc}.length < ${propSchema.minLength}) throw new Error('[${typeName}] field "${key}" must have at least ${propSchema.minLength} characters');`);
+            lines.push(`  if (typeof ${acc} === "string" && ${acc}.length < ${propSchema.minLength}) ${throwError(`${field} must have at least ${propSchema.minLength} characters`)};`);
         }
         if (hasMaxLength(propSchema)) {
-            lines.push(`  if (typeof ${acc} === "string" && ${acc}.length > ${propSchema.maxLength}) throw new Error('[${typeName}] field "${key}" must have at most ${propSchema.maxLength} characters');`);
+            lines.push(`  if (typeof ${acc} === "string" && ${acc}.length > ${propSchema.maxLength}) ${throwError(`${field} must have at most ${propSchema.maxLength} characters`)};`);
         }
     }
     if (t === 'number' || t === 'integer') {
         if (hasMinimum(propSchema)) {
-            lines.push(`  if (typeof ${acc} === "number" && ${acc} < ${propSchema.minimum}) throw new Error('[${typeName}] field "${key}" must be >= ${propSchema.minimum}');`);
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} < ${propSchema.minimum}) ${throwError(`${field} must be >= ${propSchema.minimum}`)};`);
         }
         if (hasMaximum(propSchema)) {
-            lines.push(`  if (typeof ${acc} === "number" && ${acc} > ${propSchema.maximum}) throw new Error('[${typeName}] field "${key}" must be <= ${propSchema.maximum}');`);
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} > ${propSchema.maximum}) ${throwError(`${field} must be <= ${propSchema.maximum}`)};`);
         }
         if (hasExclusiveMinimum(propSchema)) {
-            lines.push(`  if (typeof ${acc} === "number" && ${acc} <= ${propSchema.exclusiveMinimum}) throw new Error('[${typeName}] field "${key}" must be > ${propSchema.exclusiveMinimum}');`);
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} <= ${propSchema.exclusiveMinimum}) ${throwError(`${field} must be > ${propSchema.exclusiveMinimum}`)};`);
         }
         if (hasExclusiveMaximum(propSchema)) {
-            lines.push(`  if (typeof ${acc} === "number" && ${acc} >= ${propSchema.exclusiveMaximum}) throw new Error('[${typeName}] field "${key}" must be < ${propSchema.exclusiveMaximum}');`);
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} >= ${propSchema.exclusiveMaximum}) ${throwError(`${field} must be < ${propSchema.exclusiveMaximum}`)};`);
         }
         if (hasMultipleOf(propSchema)) {
-            lines.push(`  if (typeof ${acc} === "number" && ${acc} % ${propSchema.multipleOf} !== 0) throw new Error('[${typeName}] field "${key}" must be a multiple of ${propSchema.multipleOf}');`);
+            lines.push(`  if (typeof ${acc} === "number" && ${multipleOfFailExpr(acc, propSchema.multipleOf)}) ${throwError(`${field} must be a multiple of ${propSchema.multipleOf}`)};`);
+        }
+    }
+    if (t === 'array') {
+        if (hasMinItems(propSchema)) {
+            lines.push(`  if (Array.isArray(${acc}) && ${acc}.length < ${propSchema.minItems}) ${throwError(`${field} must have at least ${propSchema.minItems} items`)};`);
+        }
+        if (hasMaxItems(propSchema)) {
+            lines.push(`  if (Array.isArray(${acc}) && ${acc}.length > ${propSchema.maxItems}) ${throwError(`${field} must have at most ${propSchema.maxItems} items`)};`);
+        }
+        if (hasUniqueItems(propSchema) && propSchema.uniqueItems === true) {
+            // Deep-equality dedupe via JSON keys, matching the interpreter's semantics —
+            // a plain `new Set` would only catch primitive duplicates, not equal objects.
+            lines.push(`  if (Array.isArray(${acc}) && new Set(${acc}.map((_u) => JSON.stringify(_u))).size !== ${acc}.length) ${throwError(`${field} must NOT have duplicate items`)};`);
         }
     }
     return lines;
@@ -75,9 +104,10 @@ const generateConstraintChecks = (acc, propSchema, typeName, key) => {
  */
 const generatePropertyAssertion = (key, propSchema, isRequired, typeName) => {
     const acc = safeAccessor('input', key);
+    const field = `[${typeName}] field '${key}'`;
     const lines = [];
     if (isRequired) {
-        lines.push(`  if (!(${JSON.stringify(key)} in input)) throw new Error('[${typeName}] missing required property "${key}"');`);
+        lines.push(`  if (!(${JSON.stringify(key)} in input)) ${throwError(`[${typeName}] missing required property '${key}'`)};`);
     }
     if (!isSchemaObject(propSchema))
         return lines;
@@ -86,20 +116,20 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName) => {
     const instanceOf = getMjstInstanceOf(propSchema);
     if (instanceOf) {
         if (isRequired) {
-            lines.push(`  if (!(${acc} instanceof ${instanceOf})) throw new Error('[${typeName}] field "${key}" must be ${instanceOf}');`);
+            lines.push(`  if (!(${acc} instanceof ${instanceOf})) ${throwError(`${field} must be ${instanceOf}`)};`);
         }
         else {
-            lines.push(`  if (${acc} !== undefined && !(${acc} instanceof ${instanceOf})) throw new Error('[${typeName}] field "${key}" must be ${instanceOf}');`);
+            lines.push(`  if (${acc} !== undefined && !(${acc} instanceof ${instanceOf})) ${throwError(`${field} must be ${instanceOf}`)};`);
         }
         return lines;
     }
     const primitive = getMjstPrimitive(propSchema);
     if (primitive) {
         if (isRequired) {
-            lines.push(`  if (typeof ${acc} !== "${primitive}") throw new Error('[${typeName}] field "${key}" must be ${primitive}');`);
+            lines.push(`  if (typeof ${acc} !== "${primitive}") ${throwError(`${field} must be ${primitive}`)};`);
         }
         else {
-            lines.push(`  if (${acc} !== undefined && typeof ${acc} !== "${primitive}") throw new Error('[${typeName}] field "${key}" must be ${primitive}');`);
+            lines.push(`  if (${acc} !== undefined && typeof ${acc} !== "${primitive}") ${throwError(`${field} must be ${primitive}`)};`);
         }
         return lines;
     }
@@ -107,10 +137,10 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName) => {
         const allowed = JSON.stringify(propSchema.enum);
         const label = propSchema.enum.map((v) => JSON.stringify(v)).join(', ');
         if (isRequired) {
-            lines.push(`  if (!(${allowed} as readonly unknown[]).includes(${acc})) throw new Error('[${typeName}] field "${key}" must be one of: ${label}');`);
+            lines.push(`  if (!(${allowed} as readonly unknown[]).includes(${acc})) ${throwError(`${field} must be one of: ${label}`)};`);
         }
         else {
-            lines.push(`  if (${acc} !== undefined && !(${allowed} as readonly unknown[]).includes(${acc})) throw new Error('[${typeName}] field "${key}" must be one of: ${label}');`);
+            lines.push(`  if (${acc} !== undefined && !(${allowed} as readonly unknown[]).includes(${acc})) ${throwError(`${field} must be one of: ${label}`)};`);
         }
         return lines;
     }
@@ -118,11 +148,12 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName) => {
         const t = propSchema.type;
         const wrongType = wrongTypeCondition(acc, t);
         if (wrongType) {
+            const expected = throwError(`${field} expected ${typeLabel(t)}, got `, `typeof ${acc}`);
             if (isRequired) {
-                lines.push(`  if (${wrongType}) throw new Error(\`[${typeName}] field "${key}" expected ${typeLabel(t)}, got \${typeof ${acc}}\`);`);
+                lines.push(`  if (${wrongType}) ${expected};`);
             }
             else {
-                lines.push(`  if (${acc} !== undefined && (${wrongType})) throw new Error(\`[${typeName}] field "${key}" expected ${typeLabel(t)}, got \${typeof ${acc}}\`);`);
+                lines.push(`  if (${acc} !== undefined && (${wrongType})) ${expected};`);
             }
         }
         lines.push(...generateConstraintChecks(acc, propSchema, typeName, key));
@@ -142,7 +173,7 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName) => {
  */
 export const generateObjectStrictAssertion = (schema, typeName) => {
     const lines = [];
-    lines.push(`  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`);
+    lines.push(`  if (!isObject(input)) ${throwError(`[${typeName}] expected object, got `, 'input === null ? "null" : typeof input')};`);
     if (!hasProperties(schema) || !isSchemaObject(schema))
         return lines;
     const required = new Set(hasRequired(schema) ? schema.required : []);
@@ -156,13 +187,14 @@ export const generateObjectStrictAssertion = (schema, typeName) => {
  * Returns null when the schema has no type information to assert on.
  */
 export const generateScalarStrictAssertion = (schema, typeName) => {
+    const got = 'input === null ? "null" : typeof input';
     const instanceOf = getMjstInstanceOf(schema);
     if (instanceOf) {
-        return `  if (!(input instanceof ${instanceOf})) throw new Error(\`[${typeName}] expected ${instanceOf}, got \${input === null ? "null" : typeof input}\`);`;
+        return `  if (!(input instanceof ${instanceOf})) ${throwError(`[${typeName}] expected ${instanceOf}, got `, got)};`;
     }
     const primitive = getMjstPrimitive(schema);
     if (primitive) {
-        return `  if (typeof input !== "${primitive}") throw new Error(\`[${typeName}] expected ${primitive}, got \${input === null ? "null" : typeof input}\`);`;
+        return `  if (typeof input !== "${primitive}") ${throwError(`[${typeName}] expected ${primitive}, got `, got)};`;
     }
     if (!isSchemaObject(schema) || !hasType(schema))
         return null;
@@ -170,5 +202,5 @@ export const generateScalarStrictAssertion = (schema, typeName) => {
     const wrongType = wrongTypeCondition('input', t);
     if (!wrongType)
         return null;
-    return `  if (${wrongType}) throw new Error(\`[${typeName}] expected ${typeLabel(t)}, got \${input === null ? "null" : typeof input}\`);`;
+    return `  if (${wrongType}) ${throwError(`[${typeName}] expected ${typeLabel(t)}, got `, got)};`;
 };

package/dist/generators/generate-validation-expression.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 { resolveRef } from '@amritk/helpers/resolve-ref';
 import { 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';
@@ -33,16 +34,55 @@ export const scalarItemTypeCheck = (itemSchema, accessor) => {
         case 'string':
             return `typeof ${accessor} === "string"`;
         case 'number':
+            return `typeof ${accessor} === "number"`;
         case 'integer':
+            // `integer` items reject non-integral numbers; a bare typeof accepts `1.5`.
+            return `typeof ${accessor} === "number" && Number.isInteger(${accessor})`;
+        case 'boolean':
+            return `typeof ${accessor} === "boolean"`;
+        case 'null':
+            return `${accessor} === null`;
+        default:
+            return null;
+    }
+};
+/**
+ * A boolean type check for a single JSON Schema primitive type name. Unlike
+ * {@link scalarItemTypeCheck} this also covers `array`/`object` (as inline shape
+ * checks, so no `isObject` import is assumed) and enforces `integer` with
+ * `Number.isInteger` — a bare `typeof === "number"` accepts `1.5`. Used to build
+ * the disjunction for an array-form `type` (e.g. `["string","null"]`).
+ */
+const singleTypeCheck = (accessor, type) => {
+    switch (type) {
+        case 'string':
+            return `typeof ${accessor} === "string"`;
+        case 'number':
             return `typeof ${accessor} === "number"`;
+        case 'integer':
+            return `typeof ${accessor} === "number" && Number.isInteger(${accessor})`;
         case 'boolean':
             return `typeof ${accessor} === "boolean"`;
         case 'null':
             return `${accessor} === null`;
+        case 'array':
+            return `Array.isArray(${accessor})`;
+        case 'object':
+            return `typeof ${accessor} === "object" && ${accessor} !== null && !Array.isArray(${accessor})`;
         default:
             return null;
     }
 };
+/**
+ * Returns the list of type names when `schema.type` is an array (the JSON Schema
+ * multi-type / nullable idiom, e.g. `["string","null"]`), or `null` for a single
+ * or absent type. Multi-type is validated as a *disjunction* of per-type checks.
+ */
+const getTypeArray = (schema) => {
+    if (!isSchemaObject(schema) || !('type' in schema) || !Array.isArray(schema.type))
+        return null;
+    return schema.type;
+};
 /**
  * Generates a type coercion expression for converting a value to the expected type.
  */
@@ -171,6 +211,20 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
             ? `${accessor} === ${constLiteral} ? ${accessor} : ${constLiteral}`
             : `${accessor} === ${constLiteral} ? ${accessor} : (${accessor} !== undefined ? ${constLiteral} : undefined)`;
     }
+    // Array-form `type` (multi-type / nullable, e.g. `["string","null"]`). `hasType`
+    // is false for an array `type`, so without this the value would fall through
+    // every branch below and emit NO validation — not even a required-presence
+    // check. Emit a disjunction: the value is accepted when it matches ANY listed
+    // type, otherwise it is coerced to the default (required) or dropped (optional).
+    // A missing value fails every disjunct, so `required` presence is still enforced.
+    const typeArray = getTypeArray(schema);
+    if (typeArray && !hasEnum(schema)) {
+        const checks = typeArray.map((t) => singleTypeCheck(accessor, t)).filter((c) => c !== null);
+        if (checks.length > 0) {
+            const combined = checks.map((c) => `(${c})`).join(' || ');
+            return isRequired ? `${combined} ? ${accessor} : ${defaultValue}` : `${combined} ? ${accessor} : undefined`;
+        }
+    }
     if (!hasType(schema) && !hasEnum(schema)) {
         return `${accessor} ?? ${defaultValue}`;
     }
@@ -207,6 +261,11 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
             case 'number':
             case 'integer': {
                 checks.push(`typeof ${accessor} === "number"`);
+                // `integer` must reject non-integral numbers; a bare `typeof === "number"`
+                // accepts `1.5`. Matches the validators package (which uses Number.isInteger).
+                if (schema.type === 'integer') {
+                    checks.push(`Number.isInteger(${accessor})`);
+                }
                 if (hasMinimum(schema)) {
                     checks.push(`${accessor} >= ${schema.minimum}`);
                 }
@@ -220,7 +279,7 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
                     checks.push(`${accessor} < ${schema.exclusiveMaximum}`);
                 }
                 if (hasMultipleOf(schema)) {
-                    checks.push(`${accessor} % ${schema.multipleOf} === 0`);
+                    checks.push(multipleOfPassExpr(accessor, schema.multipleOf));
                 }
                 break;
             }
@@ -248,7 +307,7 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
                 // 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/helpers/collect-helpers.js

@@ -11,7 +11,9 @@ const EMBEDDED_NAMED_EXPORTS = {
     'validate-record': 'validateRecord',
     'has-ref': 'hasRef',
 };
-const embeddedImport = (helper, prefix) => `import { ${EMBEDDED_NAMED_EXPORTS[helper]} } from '${prefix}_helpers/${helper}';`;
+const embeddedImport = (helper, prefix) => 
+// `.js` extension so the embedded-helper import resolves under Node ESM, not only Bun.
+`import { ${EMBEDDED_NAMED_EXPORTS[helper]} } from '${prefix}_helpers/${helper}.js';`;
 /**
  * Detects which runtime helpers a generated parser body references.
  *

package/dist/helpers/collect-imports.js

@@ -2,7 +2,11 @@ import { refToFilename } from '@amritk/helpers/ref-to-filename';
 import { refToName } from '@amritk/helpers/ref-to-name';
 import { resolveRef } from '@amritk/helpers/resolve-ref';
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasItems, hasOneOf, hasRef } from '@amritk/helpers/schema-guards';
-const getImportPathForFilename = (filename) => `./${filename}`;
+// Emit an explicit `.js` extension on the relative specifier. Node's ESM resolver
+// requires it (extensionless relative imports only work under a bundler or Bun),
+// and `./x.js` pointing at a sibling `x.ts` is the standard TS NodeNext form —
+// accepted by Bun, esbuild, webpack, and tsc alike.
+const getImportPathForFilename = (filename) => `./${filename}.js`;
 /**
  * Collects all import statements needed for a schema by finding $ref references
  * that are directly used in the type definition (from properties, items, etc.).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -48,8 +48,8 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.10.1",
-    "@amritk/generate-markdown": "0.3.0"
+    "@amritk/helpers": "0.10.2",
+    "@amritk/generate-markdown": "0.4.1"
   },
   "devDependencies": {
     "@sinclair/typebox": "^0.34.49",