@amritk/generate-parsers 0.16.3 → 0.17.1

package/AI.md

@@ -0,0 +1,36 @@
+# @amritk/generate-parsers — notes for AI coding agents
+
+Programmatic API: turn a JSON Schema (Draft 2020-12) into TypeScript type
+definitions plus optional runtime parser functions. Full reference is
+[README.md](./README.md). (Most users want the [`mjst` CLI](../cli) instead.)
+
+> Pre-alpha: APIs and generated output change pre-1.0.
+
+## Minimal example
+
+```ts
+import { buildSchema } from '@amritk/generate-parsers'
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
+
+const schema: JSONSchema = { type: 'object', properties: { title: { type: 'string' } } }
+
+const files = await buildSchema(schema, 'Document')
+// files → [{ filename: 'document.ts', content: '…' }, { filename: 'index.ts', content: '…' }, …]
+```
+
+## Gotchas — where agents fail
+
+1. **`buildSchema` is `async` and takes POSITIONAL args, no options object.** The
+   full signature is
+   `buildSchema(rootSchema, rootTypeName, extensions?, typesOnly?, logWarnings?, strict?, helpersMode?, helpersImportPrefix?, readonly?, stripUnknown?, typeSuffix?, importExt?, caseInsensitive?)`.
+   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.
+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;
+   pass `strict: true` (the 6th positional) to make them throw.
+
+Only the `.` entry (`buildSchema`, `GeneratedFile`, `ImportExtension`).
+Install: `bun add @amritk/generate-parsers`.

package/dist/generators/assert-supported-keywords.js

@@ -1,74 +1,47 @@
-import { isSchemaObject } from '@amritk/helpers/schema-guards';
-import { canMatchSubschema } from './subschema-match.js';
-/**
- * Throws when a schema (anywhere in its subtree) uses a keyword the *strict*
- * parser generator cannot enforce but which narrows the set of valid documents.
- * Mirrors generate-validators' `assertNoUnsupportedKeywords`: failing loudly at
- * generation time is strictly better than silently emitting a parser that
- * accepts input the schema forbids — a strict parser promises to "throw on
- * violations".
- *
- * Two families are rejected:
- *
- *  - `unevaluatedProperties` / `unevaluatedItems` with a constraining value
- *    (`false` or a subschema). The generator has no support for the "which
- *    properties/items were evaluated" bookkeeping these require; only the
- *    runtime interpreter does. A `true` value permits everything and is allowed.
- *
- *  - `contains`, `propertyNames`, or `dependentSchemas` whose subschema uses a
- *    form {@link canMatchSubschema} cannot prove inline (a `$ref`, a combinator,
- *    a schema-valued record, …). The parser enforces these keywords only for
- *    subschemas it can match exactly; anything else would be silently ignored.
- *
- * This runs for strict generation only — coercing parsers are documented to be
- * permissive (they repair rather than reject), so ignoring these keywords there
- * is the contract, not a lie.
- */
-export const assertNoUnsupportedKeywords = (schema, typeName) => {
-    const fail = (keyword, detail) => {
-        throw new Error(`[${typeName}] unsupported keyword "${keyword}": the strict parser generator ${detail}, and would ` +
-            `silently accept documents the schema rejects. Generate a coercing (non-strict) parser, validate this ` +
-            `schema with @amritk/generate-validators, or remove the keyword.`);
-    };
-    const visit = (node) => {
-        if (typeof node !== 'object' || node === null)
-            return;
-        if (Array.isArray(node)) {
-            for (const item of node)
-                visit(item);
-            return;
+import { isSchemaObject } from "@amritk/helpers/schema-guards";
+import { canMatchSubschema } from "./subschema-match.js";
+const assertNoUnsupportedKeywords = (schema, typeName) => {
+  const fail = (keyword, detail) => {
+    throw new Error(`[${typeName}] unsupported keyword "${keyword}": the strict parser generator ${detail}, and would silently accept documents the schema rejects. Generate a coercing (non-strict) parser, validate this schema with @amritk/generate-validators, or remove the keyword.`);
+  };
+  const visit = (node) => {
+    if (typeof node !== "object" || node === null)
+      return;
+    if (Array.isArray(node)) {
+      for (const item of node)
+        visit(item);
+      return;
+    }
+    const record = node;
+    if ("unevaluatedProperties" in record && record["unevaluatedProperties"] !== true) {
+      fail("unevaluatedProperties", "does not implement it");
+    }
+    if ("unevaluatedItems" in record && record["unevaluatedItems"] !== true) {
+      fail("unevaluatedItems", "does not implement it");
+    }
+    if ("contains" in record && !canMatchSubschema(record["contains"])) {
+      fail("contains", "cannot prove its subschema inline");
+    }
+    if ("propertyNames" in record && isSchemaObject(record["propertyNames"])) {
+      if (!canMatchSubschema(record["propertyNames"])) {
+        fail("propertyNames", "cannot prove its subschema inline");
+      }
+    }
+    const dependentSchemas = record["dependentSchemas"];
+    if (typeof dependentSchemas === "object" && dependentSchemas !== null && !Array.isArray(dependentSchemas)) {
+      for (const sub of Object.values(dependentSchemas)) {
+        if (typeof sub === "boolean")
+          continue;
+        if (!canMatchSubschema(sub)) {
+          fail("dependentSchemas", "cannot prove one of its subschemas inline");
         }
-        const record = node;
-        // `true` permits everything → no constraint → safe to ignore.
-        if ('unevaluatedProperties' in record && record['unevaluatedProperties'] !== true) {
-            fail('unevaluatedProperties', 'does not implement it');
-        }
-        if ('unevaluatedItems' in record && record['unevaluatedItems'] !== true) {
-            fail('unevaluatedItems', 'does not implement it');
-        }
-        if ('contains' in record && !canMatchSubschema(record['contains'])) {
-            fail('contains', 'cannot prove its subschema inline');
-        }
-        if ('propertyNames' in record && isSchemaObject(record['propertyNames'])) {
-            if (!canMatchSubschema(record['propertyNames'])) {
-                fail('propertyNames', 'cannot prove its subschema inline');
-            }
-        }
-        const dependentSchemas = record['dependentSchemas'];
-        if (typeof dependentSchemas === 'object' && dependentSchemas !== null && !Array.isArray(dependentSchemas)) {
-            for (const sub of Object.values(dependentSchemas)) {
-                // Boolean subschemas are enforced directly (see generateDependentSchemasChecks).
-                if (typeof sub === 'boolean')
-                    continue;
-                if (!canMatchSubschema(sub)) {
-                    fail('dependentSchemas', 'cannot prove one of its subschemas inline');
-                }
-            }
-        }
-        // `for..in` (not `Object.values`) to recurse without allocating an array per
-        // node — this walk runs for every strict parser generated.
-        for (const key in record)
-            visit(record[key]);
-    };
-    visit(schema);
+      }
+    }
+    for (const key in record)
+      visit(record[key]);
+  };
+  visit(schema);
+};
+export {
+  assertNoUnsupportedKeywords
 };

package/dist/generators/build-schema.js

@@ -1,174 +1,62 @@
-import { readFile } from 'node:fs/promises';
-import { createRequire } from 'node:module';
-import { dirname, resolve as resolvePath } from 'node:path';
-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';
-/**
- * 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.
- */
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, resolve as resolvePath } from "node:path";
+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";
 const readHelperSource = async (helper, importExt) => {
-    const require = createRequire(import.meta.url);
-    const helpersRoot = dirname(require.resolve('@amritk/helpers/package.json'));
-    try {
-        const source = await readFile(resolvePath(helpersRoot, 'src', `${helper}.ts`), 'utf-8');
-        // The leading `\b` in this pattern is load-bearing beyond its regex meaning.
-        // Our build runs tsc-alias --resolveFullPaths over the compiled output, and its
-        // scanner rewrites anything that looks like `from '<path>'` — even inside a
-        // regex literal. Without the `\b`, normalize-path turned this pattern's
-        // backslashes into slashes and v0.12.3 shipped with an unparseable regex that
-        // crashed the CLI on load. The `\b` blocks that scan (in the emitted text,
-        // `from` is preceded by the word character `b`, so tsc-alias's own `\bfrom`
-        // never matches) and is also semantically correct: an import keyword always
-        // sits at a word boundary. The dist smoke test (scripts/dist-smoke.test.ts)
-        // fails the build if this ever regresses.
-        return { ext: 'ts', content: source.replace(/\bfrom '(\.\/[^'".]+)'/g, `from '$1.${importExt}'`) };
-    }
-    catch {
-        const compiled = await readFile(resolvePath(helpersRoot, 'dist', `${helper}.js`), 'utf-8');
-        // With `.ts` import specifiers the on-disk file must literally be `.ts`, so
-        // ship the compiled JS (valid TS) under that name and retarget its own
-        // sibling imports to match. The pattern keeps the same `\bfrom` shape as
-        // above so tsc-alias's scanner can't corrupt it (see the comment there).
-        if (importExt === 'ts') {
-            return { ext: 'ts', content: compiled.replace(/\bfrom '(\.\/[^'"]+)\.js'/g, "from '$1.ts'") };
-        }
-        return { ext: 'js', content: compiled };
+  const require2 = createRequire(import.meta.url);
+  const helpersRoot = dirname(require2.resolve("@amritk/helpers/package.json"));
+  try {
+    const source = await readFile(resolvePath(helpersRoot, "src", `${helper}.ts`), "utf-8");
+    return { ext: "ts", content: source.replace(/\bfrom '(\.\/[^'".]+)'/g, `from '$1.${importExt}'`) };
+  } catch {
+    const compiled = await readFile(resolvePath(helpersRoot, "dist", `${helper}.js`), "utf-8");
+    if (importExt === "ts") {
+      return { ext: "ts", content: compiled.replace(/\bfrom '(\.\/[^'"]+)\.js'/g, "from '$1.ts'") };
     }
+    return { ext: "js", content: compiled };
+  }
 };
-/**
- * Builds all TypeScript files from a JSON Schema by traversing its entire
- * `$ref` / `$dynamicRef` graph (via the shared `@amritk/helpers/walk-ref-graph`
- * walker, which also seeds `$dynamicAnchor` definitions and rewrites
- * `$dynamicRef` to `$ref`).
- *
- * For the root schema and each reachable definition this function generates a
- * 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 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
- *   type and parser generation.
- * @param typesOnly - When true, only generate TypeScript type definitions without parser functions.
- * @param logWarnings - When true, the generated parsers emit a console.warn for every input key
- *   that is not declared in the schema's properties.
- * @param strict - When true, the generated parsers throw on type/shape mismatches
- *   (wrong type, missing required property, enum/pattern/min/max violations) instead
- *   of coercing invalid input to default values.
- * @param helpersMode - `'package'` (default) emits `import ... from '@amritk/helpers/...'`.
- *   `'embedded'` emits `import ... from './_helpers/...'` and appends the helper sources
- *   as additional `GeneratedFile` entries so the output directory is self-contained.
- * @param helpersImportPrefix - Relative path prefix to the `_helpers/` directory in
- *   embedded mode. Defaults to `'./'`. The recursive multi-schema build passes `'../'`,
- *   `'../../'`, etc. so nested parsers can import from a single shared `_helpers/`
- *   directory while the helper sources are emitted once at the output root.
- * @param readonly - When true, every property, array, and record in the generated type
- *   definitions is emitted as `readonly`.
- * @param stripUnknown - When true, the generated parsers build their result from declared
- *   properties only, silently dropping undeclared input keys at every nesting level (zod's
- *   `.strip()`) without treating extras as a validation error. Composes with `strict` and
- *   yields to `additionalProperties: false` (which rejects rather than strips in strict mode).
- * @param typeSuffix - Suffix appended to every type/parser name derived from a `$ref`
- *   (e.g. `'Object'` → `ContactObject`). Defaults to `''` (no suffix). The root type name
- *   is used verbatim and is not affected by this suffix.
- * @param importExt - Extension used on every relative import specifier in the generated
- *   output (cross-file `$ref` imports, the index barrel, and embedded-helper imports).
- *   `'js'` (this function's default) is the standard TS NodeNext form; `'ts'` emits the
- *   literal on-disk paths so the generated sources run directly under Node's type
- *   stripping. Note the `mjst` CLI defaults this to `'ts'` (falling back to `'js'` only
- *   under `--build`, where tsc must compile the sources) so generated output runs under
- *   Node without a build step; direct callers of `buildSchema` opt in explicitly.
- * @param caseInsensitive - When true, the generated coercing parsers normalize a mis-cased
- *   string to the exact casing of a declared `enum`/`const` member it matches
- *   case-insensitively (e.g. `hElLo` → `hello`) instead of coercing to the default. Coerce
- *   mode only — strict parsers still reject a casing mismatch. The normalization lives on
- *   the coercion failure branch, so correctly-cased input keeps the exact-match fast path
- *   and the hot path is unaffected.
- * @returns An array of generated TypeScript files
- *
- * @example
- * ```typescript
- * const schema = {
- *   type: "object",
- *   properties: {
- *     info: { $ref: "#/$defs/info" }
- *   },
- *   $defs: {
- *     info: {
- *       type: "object",
- *       properties: {
- *         title: { type: "string" }
- *       }
- *     }
- *   }
- * };
- *
- * const files = buildSchema(schema, "Document");
- *
- * // Types-only mode — no parser functions or runtime helpers included:
- * const typesFiles = buildSchema(schema, "Document", undefined, true);
- *
- * // With extensions:
- * const filesWithExtensions = buildSchema(schema, "Document", {
- *   info: {
- *     'x-internal': { type: 'boolean' },
- *   },
- * });
- * ```
- */
-export const buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict, helpersMode = 'package', helpersImportPrefix = './', readonly = false, stripUnknown = false, typeSuffix = '', importExt = 'js', caseInsensitive = false) => {
-    const files = [];
-    const usedHelpers = new Set();
-    walkRefGraph(rootSchema, rootTypeName, { typeSuffix }, (node) => {
-        // `index` is reserved for the barrel below, so never let a definition of
-        // that name overwrite it.
-        if (node.filename === 'index')
-            return;
-        // Extensions are keyed by definition name, which is the node's filename for
-        // both the root (the lowercased root type name) and every `$ref` target.
-        const extended = extensions ? applySchemaExtensions(node.schema, node.filename, extensions) : node.schema;
-        const result = generateFile(extended, node.typeName, {
-            typesOnly: typesOnly ?? false,
-            rootSchema: node.rootSchema,
-            helpersMode,
-            helpersImportPrefix,
-            readonly,
-            typeSuffix,
-            importExt,
-            isRoot: node.isRoot,
-            ...(node.ref !== undefined ? { selfRef: node.ref } : {}),
-            ...(logWarnings !== undefined ? { logWarnings } : {}),
-            ...(strict !== undefined ? { strict } : {}),
-            ...(stripUnknown ? { stripUnknown } : {}),
-            ...(caseInsensitive ? { caseInsensitive } : {}),
-        });
-        files.push({ filename: `${node.filename}.ts`, content: result.content });
-        for (const helper of result.usedHelpers)
-            usedHelpers.add(helper);
+const buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict, helpersMode = "package", helpersImportPrefix = "./", readonly = false, stripUnknown = false, typeSuffix = "", importExt = "js", caseInsensitive = false) => {
+  const files = [];
+  const usedHelpers = /* @__PURE__ */ new Set();
+  walkRefGraph(rootSchema, rootTypeName, { typeSuffix }, (node) => {
+    if (node.filename === "index")
+      return;
+    const extended = extensions ? applySchemaExtensions(node.schema, node.filename, extensions) : node.schema;
+    const result = generateFile(extended, node.typeName, {
+      typesOnly: typesOnly ?? false,
+      rootSchema: node.rootSchema,
+      helpersMode,
+      helpersImportPrefix,
+      readonly,
+      typeSuffix,
+      importExt,
+      isRoot: node.isRoot,
+      ...node.ref !== void 0 ? { selfRef: node.ref } : {},
+      ...logWarnings !== void 0 ? { logWarnings } : {},
+      ...strict !== void 0 ? { strict } : {},
+      ...stripUnknown ? { stripUnknown } : {},
+      ...caseInsensitive ? { caseInsensitive } : {}
     });
-    // In embedded mode, ship the runtime helper source files alongside the parsers so
-    // the output directory is self-contained (no `@amritk/helpers` install required).
-    // typesOnly skips parser generation entirely, so no runtime helpers are needed.
-    if (helpersMode === 'embedded' && !typesOnly) {
-        for (const helper of usedHelpers) {
-            const { ext, content } = await readHelperSource(helper, importExt);
-            files.push({ filename: `_helpers/${helper}.${ext}`, content });
-        }
+    files.push({ filename: `${node.filename}.ts`, content: result.content });
+    for (const helper of result.usedHelpers)
+      usedHelpers.add(helper);
+  });
+  if (helpersMode === "embedded" && !typesOnly) {
+    for (const helper of usedHelpers) {
+      const { ext, content } = await readHelperSource(helper, importExt);
+      files.push({ filename: `_helpers/${helper}.${ext}`, content });
     }
-    files.push({
-        filename: 'index.ts',
-        content: generateIndexBarrel(files, { typesOnly: typesOnly ?? false, importExt }),
-    });
-    return files;
+  }
+  files.push({
+    filename: "index.ts",
+    content: generateIndexBarrel(files, { typesOnly: typesOnly ?? false, importExt })
+  });
+  return files;
+};
+export {
+  buildSchema
 };

package/dist/generators/generate-default-from-pattern.js

@@ -1,33 +1,26 @@
-/**
- * Generates a best-guess default value from a regex pattern.
- * Recognizes common patterns and returns appropriate defaults.
- */
-export const generateDefaultFromPattern = (pattern) => {
-    // Email pattern
-    if (pattern.includes('@') || (pattern.includes('[a-zA-Z0-9]') && pattern.includes('\\.'))) {
-        return '"user@example.com"';
+const generateDefaultFromPattern = (pattern) => {
+  if (pattern.includes("@") || pattern.includes("[a-zA-Z0-9]") && pattern.includes("\\.")) {
+    return '"user@example.com"';
+  }
+  if (pattern.includes("[0-9a-f]") && pattern.includes("{8}") || pattern.includes("\\-")) {
+    if (pattern.match(/[0-9a-f].*\{8\}/i) || pattern.match(/[0-9a-fA-F]{8}/)) {
+      return '"00000000-0000-0000-0000-000000000000"';
     }
-    // UUID pattern
-    if ((pattern.includes('[0-9a-f]') && pattern.includes('{8}')) || pattern.includes('\\-')) {
-        if (pattern.match(/[0-9a-f].*\{8\}/i) || pattern.match(/[0-9a-fA-F]{8}/)) {
-            return '"00000000-0000-0000-0000-000000000000"';
-        }
-    }
-    // URL pattern
-    if (pattern.includes('https?') || pattern.includes('http')) {
-        return '"https://example.com"';
-    }
-    // Semver pattern (3.1.x, x.y.z, etc)
-    if (pattern.match(/\d.*\\\.\.*\d/)) {
-        return '"1.0.0"';
-    }
-    // ISO date pattern
-    if (pattern.includes('\\d{4}') && pattern.includes('\\d{2}')) {
-        return '"2000-01-01"';
-    }
-    // Phone number patterns
-    if (pattern.includes('\\d{3}') && (pattern.includes('\\d{4}') || pattern.includes('\\d{7}'))) {
-        return '"+1234567890"';
-    }
-    return null;
+  }
+  if (pattern.includes("https?") || pattern.includes("http")) {
+    return '"https://example.com"';
+  }
+  if (pattern.match(/\d.*\\\.\.*\d/)) {
+    return '"1.0.0"';
+  }
+  if (pattern.includes("\\d{4}") && pattern.includes("\\d{2}")) {
+    return '"2000-01-01"';
+  }
+  if (pattern.includes("\\d{3}") && (pattern.includes("\\d{4}") || pattern.includes("\\d{7}"))) {
+    return '"+1234567890"';
+  }
+  return null;
+};
+export {
+  generateDefaultFromPattern
 };

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

@@ -1,49 +1,29 @@
-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) => {
-    // 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)
-            continue;
-        let condition = `${discAccessor} === ${JSON.stringify(discriminatorValue)}`;
-        const checks = generateSchemaChecks(accessor, schema);
-        for (const check of checks) {
-            condition += ' && ' + check;
-        }
-        branches.push(condition);
+import { safeAccessor } from "@amritk/helpers/safe-accessor";
+import { getDiscriminatorValue } from "../helpers/get-discriminator-value.js";
+import { generateSchemaChecks } from "./generate-schema-checks.js";
+const generateDiscriminatedUnionValidation = (accessor, schemas, discriminatorKey, defaultValue, isRequired) => {
+  const discAccessor = safeAccessor(`${accessor}?`, discriminatorKey);
+  const branches = [];
+  for (const schema of schemas) {
+    const discriminatorValue = getDiscriminatorValue(schema, discriminatorKey);
+    if (discriminatorValue === null)
+      continue;
+    let condition = `${discAccessor} === ${JSON.stringify(discriminatorValue)}`;
+    const checks = generateSchemaChecks(accessor, schema);
+    for (const check of checks) {
+      condition += " && " + check;
     }
-    if (branches.length === 0) {
-        return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
-    }
-    // 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;
+    branches.push(condition);
+  }
+  if (branches.length === 0) {
+    return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
+  }
+  let result = isRequired ? defaultValue : accessor;
+  for (let i = branches.length - 1; i >= 0; i--) {
+    result = `${branches[i]} ? ${accessor} : ${result}`;
+  }
+  return result;
+};
+export {
+  generateDiscriminatedUnionValidation
 };

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

@@ -1,63 +1,29 @@
-/**
- * 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)`;
+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)`;
 };
-/**
- * Builds a case-insensitive coercion expression for a string `enum`/`const`
- * value whose exact-match check has already failed. Only the *string* members
- * participate (a number/boolean/null member has no case to fold): a value that
- * matches one case-insensitively normalizes to that member's exact casing, and
- * everything else yields `fallback`.
- *
- * This is emitted ONLY on the already-invalid branch of the coercion ternary, so
- * a correctly-cased value never reaches it — the exact `===` fast path (and the
- * shape validators / deep guards built on it) is unchanged, so the hot path pays
- * nothing. Only a mis-cased value, which today coerces straight to the default,
- * now takes a single `toLowerCase()` and an O(1) map lookup instead.
- *
- * Returns `null` when no member is a string (nothing to fold), so the caller
- * keeps its plain fallback and emits no extra code.
- */
-export const generateEnumCaseInsensitiveCoercion = (accessor, enumValues, fallback) => {
-    const entries = [];
-    const seen = new Set();
-    for (const value of enumValues) {
-        if (typeof value !== 'string')
-            continue;
-        const lower = value.toLowerCase();
-        // First writer wins, so declaration order breaks ties between members that
-        // fold to the same key (e.g. `"on"` and `"ON"`). `Set` membership is used
-        // instead of `lower in obj` so a member folding to an inherited name like
-        // `constructor` or `toString` is not wrongly treated as already-present.
-        if (seen.has(lower))
-            continue;
-        seen.add(lower);
-        entries.push([lower, value]);
-    }
-    if (entries.length === 0)
-        return null;
-    // A `Map` — not a plain object — so a folded key that collides with an
-    // inherited member (`constructor`, `toString`, `__proto__`, …) resolves to
-    // `undefined` (→ `fallback`) rather than an `Object.prototype` value. A
-    // plain-object lookup would return the inherited function/object for such a key.
-    const map = `new Map(${JSON.stringify(entries)})`;
-    return `(typeof ${accessor} === "string" ? (${map}.get((${accessor} as string).toLowerCase()) ?? ${fallback}) : ${fallback})`;
+const generateEnumCaseInsensitiveCoercion = (accessor, enumValues, fallback) => {
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of enumValues) {
+    if (typeof value !== "string")
+      continue;
+    const lower = value.toLowerCase();
+    if (seen.has(lower))
+      continue;
+    seen.add(lower);
+    entries.push([lower, value]);
+  }
+  if (entries.length === 0)
+    return null;
+  const map = `new Map(${JSON.stringify(entries)})`;
+  return `(typeof ${accessor} === "string" ? (${map}.get((${accessor} as string).toLowerCase()) ?? ${fallback}) : ${fallback})`;
+};
+export {
+  generateEnumCaseInsensitiveCoercion,
+  generateEnumCheck
 };