@amritk/validation 0.4.0 → 0.4.1

package/AI.md

@@ -44,14 +44,16 @@ Every mode is reachable from `mjst` without dropping to the programmatic API:
 |:---|:---|
 | `types` | `--types-only` (alone), otherwise always emitted |
 | `guard`, `validate` | `--validators`, or `--validators-only` for no parser |
-| `check` | `--check` |
-| `coerce` | `--coerce` |
-| `repair` | `--repair` (emits `coerceX` too) |
+| `check` | `--validators --check` |
+| `coerce` | `--validators --coerce` |
+| `repair` | `--validators --repair` (emits `coerceX` too) |
 | `parse` | the default on any run that is not `--types-only`/`--validators-only` |
 | `parseStrict` | `--strict` |
 
 `--validators-only` is this package's own default (`['types', 'guard', 'validate']`)
 spelled as a flag: everything that judges a document, nothing that builds one.
+`--check`, `--coerce` and `--repair` shape the validator half, so the CLI rejects
+any of them without one of those two flags.
 
 ## Gotchas — where agents fail
 
@@ -83,10 +85,10 @@ spelled as a flag: everything that judges a document, nothing that builds one.
    validateX(v)` pays for both passes and is no faster than `validateX`.
 
 8. **It emits each engine's exact bytes.** A single-mode build is byte-identical
-   to what that engine emitted when it was its own package, so there is no runtime
-   difference to reason about and no speedup to claim — do not tell a user this is
-   faster. What it changes is that the whole matrix comes out as one type instead
-   of two, and that a build asking for no validator mode ships no
+   to what the engine that owns that mode emits when called directly, so there is
+   no runtime difference to reason about and no speedup to claim — do not tell a
+   user this is faster. What it changes is that the whole matrix comes out as one
+   type instead of two, and that a build asking for no validator mode ships no
    `validation-result.ts`.
 
 9. **`coerceX` is not Ajv's `coerceTypes`, on purpose.** It never modifies its

package/README.md

@@ -74,6 +74,7 @@ so no two can disagree about whether a document is valid.
 | `types` | — | — | — | — |
 | `guard` | `isX(input): input is X` | — | a boolean | the first problem |
 | `validate` | `validateX(input)` | — | every error | the end |
+| `check` | `checkX(input)` | — | the first error | the first problem |
 | `coerce` | `coerceX(input)` | coerced | every error | the end |
 | `repair` | `repairX(input)` | repaired | repairs **and** errors | the end |
 | `parse` | `parseX(input)` | repaired | nothing | never fails |
@@ -84,7 +85,9 @@ it stops at the first thing wrong and builds no error object, which on invalid
 input is dramatically cheaper than reporting. `validate` is the other half: every
 error, each with a JSON Pointer, the keyword that rejected the value, and that
 keyword's own values. Reach for `guard` when the answer is a branch and
-`validate` when a human or an API client has to be told what to fix.
+`validate` when a human or an API client has to be told what to fix. `check` sits
+between them: `checkX` returns the same result type as `validateX`, holding only
+the error `validateX` would have reported first, and walks no further.
 
 **Coerce and repair, with or without the errors.** `coerceX` and `repairX` hand
 back the value *and* the diagnostics; `parseX` hands back only the value and
@@ -92,6 +95,14 @@ never fails. Coercion moves a value that is already right but written in the
 wrong type; repair also substitutes a value the schema supplies for one that
 cannot be coerced, and reports the validator's own errors as the repairs.
 
+That makes `repairX` an autofix tool rather than a stricter validator. It accepts
+documents `validateX` rejects (a missing required name gets one; an unknown
+`enum` value becomes the first member), and accepting only `valid` with an empty
+`repairs` gives exactly the verdicts `coerceX` gives. An empty `repairs` alone is
+not enough: a document nothing could repair comes back with none either, and
+`valid: false`. To reject a bad config, use `coerceX`. To hand back a fixed one,
+use `repairX`.
+
 **`parseX` agrees with `coerceX`.** Wherever `coerceX` accepts a document, the
 coercing `parseX` returns the very same value — through a union, an `allOf`, an
 `if`, a `$ref`, recursion included — and it only repairs what `coerceX` would
@@ -119,11 +130,12 @@ schemas with `anyOf`, `oneOf`, `allOf` and `if`/`then`/`else` checks every
 accepted document against an Ajv that does not coerce. Where the two differ, it
 is on purpose:
 
-- **`null` is never coerced**, in either direction. Ajv reads `null` as `""`, `0`
-  or `false` for a string, number or boolean field, and reads those back as
-  `null`. A `null` usually means "not set", and turning it into a real value
-  erases that. Here it goes to the validator as written, and the validator
-  rejects it.
+- **`null` is never coerced**, in either direction, and it is the difference
+  you will meet most: on a real config corpus it was nearly every case where Ajv
+  accepted and `coerceX` did not. Ajv reads `null` as `""`, `0` or `false` for a
+  string, number or boolean field, and reads those back as `null`. A `null`
+  usually means "not set", and turning it into a real value erases that. Here it
+  goes to the validator as written, and the validator rejects it.
 - **Only clean numerals become numbers.** `" "`, `" 1 "`, `"0x10"`, `"Infinity"`
   and `"1."` are rejected. Ajv turns them into `0`, `1`, `16`, a value JSON
   cannot hold, and `1`. `"007"` and `"1e3"` are still coerced.
@@ -146,8 +158,8 @@ is on purpose:
 document has to clone it first. `coerceX` returns a new value that shares
 everything it did not touch, or the input itself when nothing needed coercing.
 
-**It is faster.** Against Ajv cloning first, so both leave the caller's document
-alone (`bun run bench:validators:coerce`, or
+**It is faster where the input has to survive.** Against Ajv cloning first, so
+both leave the caller's document alone (`bun run bench:validators:coerce`, or
 `bench:validators:coerce:node`):
 
 | schema | runtime | valid input | needs coercing | cannot be coerced |
@@ -166,7 +178,11 @@ each engine timed in its own process (Bun 1.3.11, Node 22.22, Linux x64). A
 valid document is the common case and the widest gap: where `isX` is a
 standalone guard, `coerceX` answers it with that guard and hands the input
 straight back, without walking it. On valid input Ajv rewrites nothing, so it can
-also be timed without the clone; `coerceX` is still ahead there, by 1.2–3.3×.
+also be timed without the clone; `coerceX` is still ahead there on these
+schemas, by 1.2–3.3×, but not on every one: on a large, union-heavy document
+that the caller lets Ajv coerce in place, Ajv can come out modestly ahead. The
+gap above is the clone, so it is real exactly where the caller cannot let Ajv
+mutate its input.
 The config case is the shape `--coerce` exists for: every coercible scalar sits
 inside a union reached through `$ref`, and every union branch is tested by a
 named function rather than a closure built per call.</sub>
@@ -196,10 +212,17 @@ holding it (`/readme`). `params.additionalProperty` names the key in both.
 | `options.readonly` | `boolean` | `false` | Emit `readonly` type members. |
 | `options.caseInsensitive` | `boolean` | `false` | Normalize a mis-cased string onto an `enum` member it matches. |
 | `options.helpersMode` | `'package' \| 'embedded'` | `'package'` | Where the parser half gets its runtime helpers. |
+| `options.helpersImportPrefix` | `string` | `'./'` | Prefix on emitted-helper import specifiers, when `helpersMode` is `'embedded'`. |
 | `options.extensions` | `SchemaExtensions` | — | Schema extensions, passed through to the parser half. |
+| `options.importExt` | `'js' \| 'ts'` | `'js'` | Extension on every emitted relative import. `'ts'` emits the on-disk paths, so the output runs under Node's type stripping with no build step. |
+| `options.logWarnings` | `boolean` | `false` | Print the parser half's warnings about the schema, such as a keyword it cannot enforce. |
 
 Returns: `Promise<GeneratedFile[]>` where `GeneratedFile = { filename: string; content: string }`.
 
+The package also exports `ALL_MODES` (every mode but `parseStrict`, for a caller
+who wants the lot) and the types `Mode`, `GenerateOptions`, `GeneratedFile` and
+`ImportExtension`.
+
 ---
 
 ## Output layout
@@ -208,6 +231,8 @@ Returns: `Promise<GeneratedFile[]>` where `GeneratedFile = { filename: string; c
 config.ts         the type, plus isX / validateX / coerceX / repairX
 config.parse.ts   parseX, importing the type from ./config.js
 validation-result.ts   the shared error and result types, and the runtime helpers
+formats.ts        the format checks, only when `formats` enforces one the schema names
+_helpers/         the parser's runtime helpers, only when `helpersMode` is 'embedded'
 index.ts          a barrel over all of it
 ```
 

package/dist/validators/generators/generate-files.js

@@ -25,7 +25,10 @@ const generateValidatorFile = (schema, typeName, options) => {
     formats,
     standaloneGuard
   }).code : "";
-  const repairer = options?.repair === true ? generateRepairFunction(schema, typeName, typeSuffix).code : "";
+  const repairer = options?.repair === true ? generateRepairFunction(schema, typeName, typeSuffix, {
+    ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
+    formats
+  }).code : "";
   const appended = [checker, coercer, repairer].filter((part) => part !== "");
   const body = validatorFunction + booleanGuard + (appended.length === 0 ? "" : "\n\n" + appended.join("\n\n"));
   const mentions = identifierMentions(typeDefinition + body);

package/dist/validators/generators/generate-repair-function.d.ts

@@ -22,6 +22,11 @@ export declare const repairLookupNameFor: (ref: string, typeSuffix: string) => s
  * then can its own children be judged. A position is repaired at most once, so
  * the loop terminates on progress rather than on the pass cap.
  */
-export declare const generateRepairFunction: (schema: JSONSchema, typeName: string, typeSuffix?: string) => {
+export declare const generateRepairFunction: (schema: JSONSchema, typeName: string, typeSuffix?: string, options?: {
+    /** The whole document, for a `propertyNames` test that reads a `$ref`'s target. */
+    readonly rootSchema?: Record<string, unknown>;
+    /** The `format` names the validator enforces, so a key test agrees with it. */
+    readonly formats?: ReadonlySet<string>;
+}) => {
     code: string;
 };

package/dist/validators/generators/generate-repair-function.js

@@ -1,8 +1,24 @@
+import { regexFlagsFor } from "@amritk/helpers/escape-regex-pattern";
 import { getDefaultValue } from "@amritk/helpers/get-default-value";
 import { readKey } from "@amritk/helpers/read-key";
 import { refToName } from "@amritk/helpers/ref-to-name";
 import { isSchemaObject } from "@amritk/helpers/schema-guards";
+import { NO_FORMATS } from "./enforced-keywords.js";
+import { createSubschemaMatcher } from "./generate-validator-function.js";
 const repairLookupNameFor = (ref, typeSuffix) => `repair${refToName(ref, typeSuffix)}At`;
+const keyTest = (nameSchema, ctx) => {
+  const named = ctx.matcher.named(nameSchema);
+  if (named !== null)
+    return named;
+  const body = ctx.matcher.test(nameSchema);
+  if (typeof body !== "string")
+    return body;
+  const name = `_repairKey${ctx.next()}`;
+  const parameter = /\binput\b/.test(body) ? "input" : "_input";
+  const path = /\b_path\b/.test(body) ? [`  const _path = ''`] : [];
+  ctx.helpers.push([`const ${name} = (${parameter}: unknown): boolean => {`, ...path, body, `}`].join("\n"));
+  return name;
+};
 const fallbackLiteral = (schema) => {
   const literal = getDefaultValue(schema);
   return literal === "undefined" ? null : literal;
@@ -21,12 +37,20 @@ const emitWalker = (schema, ctx) => {
   const own = fallbackLiteral(schema);
   const properties = schemaMap(node, "properties") ?? {};
   const children = Object.entries(properties).map(([key, child]) => [key, emitWalker(child, ctx)]).filter((entry) => entry[1] !== null);
+  const patternProperties = schemaMap(node, "patternProperties") ?? {};
+  const patterns = Object.entries(patternProperties).map(([source, child]) => ({
+    source,
+    walker: emitWalker(child, ctx)
+  }));
+  const additional = readKey(node, "additionalProperties");
+  const additionalWalker = typeof additional === "object" && additional !== null ? emitWalker(additional, ctx) : null;
+  const mapped = additionalWalker !== null || patterns.some((pattern) => pattern.walker !== null);
   const prefixItems = readKey(node, "prefixItems");
   const tuple = Array.isArray(prefixItems) ? prefixItems : [];
   const tupleWalkers = tuple.map((item) => emitWalker(item, ctx));
   const items = readKey(node, "items");
   const itemsWalker = typeof items === "object" && items !== null && !Array.isArray(items) ? emitWalker(items, ctx) : null;
-  const hasChildren = children.length > 0 || itemsWalker !== null || tupleWalkers.some((walker) => walker !== null);
+  const hasChildren = children.length > 0 || mapped || itemsWalker !== null || tupleWalkers.some((walker) => walker !== null);
   if (own === null && !hasChildren)
     return null;
   const id = ctx.next();
@@ -36,15 +60,28 @@ const emitWalker = (schema, ctx) => {
     `  if (segments.length === 0) return ${own === null ? "null" : `() => (${own})`}`
   ];
   if (hasChildren) {
-    lines.push(`  const [head, ...rest] = segments as [string, ...string[]]`);
-    if (children.length > 0) {
+    const declared = mapped ? Object.keys(properties) : children.map(([key]) => key);
+    const indexed = tupleWalkers.some((walker) => walker !== null) || itemsWalker !== null;
+    const arrayKeywords = tuple.length > 0 || typeof items === "object" && items !== null && !Array.isArray(items);
+    const indexBlock = indexed || mapped && arrayKeywords;
+    const nameSchema = readKey(node, "propertyNames");
+    const keyCheck = nameSchema === void 0 ? true : keyTest(nameSchema, ctx);
+    const readsHead = declared.length > 0 || indexBlock || mapped && patterns.length > 0 || typeof keyCheck === "string";
+    lines.push(`  const [${readsHead ? "head" : ""}, ...rest] = segments as [string, ...string[]]`);
+    if (keyCheck === false)
+      lines.push(`  if (rest.length === 0) return null`);
+    if (typeof keyCheck === "string")
+      lines.push(`  if (rest.length === 0 && !${keyCheck}(head)) return null`);
+    if (declared.length > 0) {
+      const walkers = new Map(children);
       lines.push(`  switch (head) {`);
-      for (const [key, walker] of children)
-        lines.push(`    case ${JSON.stringify(key)}: return ${walker}(rest)`);
+      for (const key of declared) {
+        const walker = walkers.get(key);
+        lines.push(`    case ${JSON.stringify(key)}: return ${walker === void 0 ? "null" : `${walker}(rest)`}`);
+      }
       lines.push(`  }`);
     }
-    const indexed = tupleWalkers.some((walker) => walker !== null) || itemsWalker !== null;
-    if (indexed) {
+    if (indexBlock) {
       lines.push(`  const index = Number(head)`);
       lines.push(`  if (Number.isInteger(index) && index >= 0) {`);
       tupleWalkers.forEach((walker, position) => {
@@ -55,21 +92,43 @@ const emitWalker = (schema, ctx) => {
       if (itemsWalker !== null) {
         lines.push(`    if (index >= ${tuple.length}) return ${itemsWalker}(rest)`);
       }
+      if (mapped && arrayKeywords)
+        lines.push(`    return null`);
       lines.push(`  }`);
     }
+    if (mapped && patterns.length > 0) {
+      const regexNames = patterns.map((pattern, index) => {
+        const regexName = `_repairPattern${id}_${index}`;
+        ctx.helpers.push(`const ${regexName} = new RegExp(${JSON.stringify(pattern.source)}, ${JSON.stringify(regexFlagsFor(pattern.source))})`);
+        return regexName;
+      });
+      const answer = (walker) => walker === null ? "null" : `${walker}(rest)`;
+      const only = patterns[0];
+      if (patterns.length === 1 && only !== void 0) {
+        lines.push(`  if (${regexNames[0]}.test(head)) return ${answer(only.walker)}`);
+      } else {
+        lines.push(`  const claims = [${regexNames.join(", ")}].filter((pattern) => pattern.test(head))`);
+        lines.push(`  if (claims.length > 1) return null`);
+        patterns.forEach((pattern, index) => {
+          lines.push(`  if (claims[0] === ${regexNames[index]}) return ${answer(pattern.walker)}`);
+        });
+      }
+    }
   }
-  lines.push(`  return null`, `}`);
+  lines.push(additionalWalker === null ? `  return null` : `  return ${additionalWalker}(rest)`, `}`);
   ctx.helpers.push(lines.join("\n"));
   return name;
 };
-const generateRepairFunction = (schema, typeName, typeSuffix = "") => {
+const generateRepairFunction = (schema, typeName, typeSuffix = "", options = {}) => {
   const helpers = [];
   let counter = 0;
-  const ctx = { typeSuffix, helpers, next: () => counter++ };
+  const matcher = createSubschemaMatcher(typeSuffix, options.rootSchema ?? (isSchemaObject(schema) ? schema : void 0), options.formats ?? NO_FORMATS, "_repair");
+  const ctx = { typeSuffix, helpers, next: () => counter++, matcher };
   const walker = emitWalker(schema, ctx);
   const lookupName = `repair${typeName}At`;
+  const declarations = [...matcher.declarations(helpers.join("\n")), ...helpers];
   const parts = [
-    ...helpers.length > 0 ? [helpers.join("\n\n"), ""] : [],
+    ...declarations.length > 0 ? [declarations.join("\n\n"), ""] : [],
     `export const ${lookupName}: RepairLookup = ${walker === null ? "() => null" : walker}`,
     "",
     `export const repair${typeName} = (input: unknown, _path = ''): RepairResult<${typeName}> => {`,

package/dist/validators/generators/generate-validator-function.js

@@ -292,7 +292,7 @@ const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) =>
     lines.push(`  }`);
   }
   if (hasConst(schema)) {
-    const mismatch = constMismatchCondition(raw, schema.const);
+    const mismatch = constMismatchCondition(typeTestAccessor(raw, ctx), schema.const);
     const msg = JSON.stringify(`must be ${JSON.stringify(schema.const)}`);
     lines.push(`  if (${presence}${mismatch}) {`);
     lines.push(`    ${pushError(ctx.sink, msg, path, "const", JSON.stringify({ allowedValue: schema.const }))}`);
@@ -300,7 +300,7 @@ const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) =>
   }
   if (hasEnum(schema)) {
     const label = schema.enum.map((v) => JSON.stringify(v)).join(", ");
-    lines.push(`  if (${presence}!${enumMembershipExpr(schema.enum, raw)}) {`);
+    lines.push(`  if (${presence}!${enumMembershipExpr(schema.enum, typeTestAccessor(raw, ctx))}) {`);
     lines.push(`    ${pushError(ctx.sink, JSON.stringify(`must be one of: ${label}`), path, "enum", JSON.stringify({ allowedValues: schema.enum }))}`);
     lines.push(`  }`);
   }
@@ -609,7 +609,31 @@ const namedMatcher = (sub, suffix, ctx) => {
   ctx.hoisted.push({ declaration, reference: `${name}(`, calls: true });
   return name;
 };
-const generateMatchesExpr = (raw, sub, suffix, ctx, required = false, branch) => {
+const namedBranchErrors = (sub, suffix, ctx) => {
+  if (!isSchemaObject(sub))
+    return null;
+  const key = `explain:${JSON.stringify(sub)}`;
+  const existing = ctx.namedMatchers.get(key);
+  if (existing !== void 0)
+    return existing;
+  const fnCtx = { ...ctx, objVar: "obj", pathPrefix: "${_path}", depth: 0, sink: MATCH_ERROR_SINK };
+  const checks = generateValueChecks("", "input", "`${_path}`", sub, suffix, fnCtx, true);
+  if (checks.length === 0)
+    return null;
+  const body = checks.join("\n");
+  const name = `${hoistPrefix(ctx)}_explain${ctx.namedMatchers.size}`;
+  const declaration = [
+    `const ${name} = (${readsBinding("input", body) ? "input" : "_input"}: unknown, _path: string): ValidationError[] => {`,
+    `  const ${MATCH_ERROR_SINK}: ValidationError[] = []`,
+    body,
+    `  return ${MATCH_ERROR_SINK}`,
+    `}`
+  ].join("\n");
+  ctx.namedMatchers.set(key, name);
+  ctx.hoisted.push({ declaration, reference: `${name}(`, calls: true });
+  return name;
+};
+const generateMatchesExpr = (raw, sub, suffix, ctx, required = false) => {
   if (sub === true)
     return "true";
   if (sub === false)
@@ -617,31 +641,26 @@ const generateMatchesExpr = (raw, sub, suffix, ctx, required = false, branch) =>
   if (!isSchemaObject(sub))
     return "true";
   const value = NARROWABLE_REFERENCE.test(raw) ? raw : `_mv${ctx.depth}`;
-  const valuePath = branch === void 0 ? "`${_path}`" : branch.path;
+  const valuePath = "`${_path}`";
   const binding = value === raw ? "" : `const ${value}: unknown = ${raw}
 `;
-  if (branch === void 0) {
-    const named = namedMatcher(sub, suffix, ctx);
-    if (named !== null)
-      return named === "true" ? "true" : `${named}(${raw})`;
-    const matchState = { on: ctx.failFast.on, blocked: false };
-    const matchCtx = { ...ctx, sink: MATCH_BOOL_SINK, failFast: matchState, branchErrors: false };
-    const boolChecks = generateValueChecks("", value, valuePath, sub, suffix, matchCtx, required);
-    if (boolChecks.length === 0)
-      return "true";
-    if (!matchState.blocked)
-      return `((): boolean => {
+  const named = namedMatcher(sub, suffix, ctx);
+  if (named !== null)
+    return named === "true" ? "true" : `${named}(${raw})`;
+  const matchState = { on: ctx.failFast.on, blocked: false };
+  const matchCtx = { ...ctx, sink: MATCH_BOOL_SINK, failFast: matchState, branchErrors: false };
+  const boolChecks = generateValueChecks("", value, valuePath, sub, suffix, matchCtx, required);
+  if (boolChecks.length === 0)
+    return "true";
+  if (!matchState.blocked)
+    return `((): boolean => {
 ${binding}${boolChecks.join("\n")}
     return true })()`;
-  }
   const checks = generateValueChecks("", value, valuePath, sub, suffix, { ...ctx, sink: MATCH_ERROR_SINK }, required);
   if (checks.length === 0)
     return "true";
-  const body = checks.join("\n");
-  const collect = branch === void 0 ? "" : `
-    if (_m.length !== 0) (${branch.buffer} ??= []).push(_m)`;
   return `((): boolean => { const _m: ValidationError[] = []
-${binding}${body}${collect}
+${binding}${checks.join("\n")}
     return _m.length === 0 })()`;
 };
 const unevaluatedMatcher = (suffix, ctx) => (accessor, schema, depth) => (
@@ -691,17 +710,18 @@ const generateUnevaluatedChecks = (raw, path, schema, suffix, ctx) => {
   }
   return lines;
 };
-const BRANCH_BUFFER = "_br";
-const selectBranchErrorsLine = (path, ctx) => `for (const _e of selectBranchErrors(${BRANCH_BUFFER} ?? [], ${path})) ${ctx.sink}.push(_e)`;
-const branchBufferBlock = (guard, message, keyword, path, ctx) => [
-  `  {`,
-  `    let ${BRANCH_BUFFER}: ValidationError[][] | null = null`,
-  `    if (${guard}) {`,
-  `      ${pushError(ctx.sink, message, path, keyword)}`,
-  `      ${selectBranchErrorsLine(path, ctx)}`,
-  `    }`,
+const branchErrorsReport = (guard, raw, explain, message, keyword, path, ctx) => [
+  `  if (${guard}) {`,
+  `    ${pushError(ctx.sink, message, path, keyword)}`,
+  ...explain.length === 0 ? [] : [
+    `    const _bp = ${path}`,
+    `    const _br: ValidationError[][] = []`,
+    `    for (const _b of [${explain.map((name) => `${name}(${raw}, _bp)`).join(", ")}]) if (_b.length !== 0) _br.push(_b)`,
+    `    for (const _e of selectBranchErrors(_br, _bp)) ${ctx.sink}.push(_e)`
+  ],
   `  }`
 ];
+const branchExplainers = (branches, suffix, ctx) => branches.map((branch) => namedBranchErrors(branch, suffix, ctx)).filter((name) => name !== null);
 const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
   if (!isSchemaObject(schema))
     return [];
@@ -711,11 +731,10 @@ const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
       lines.push(...generateValueChecks(key, raw, path, branch, suffix, ctx, true));
   }
   if (hasAnyOf(schema) && schema.anyOf.length > 0) {
-    const collector = ctx.branchErrors ? { buffer: BRANCH_BUFFER, path } : void 0;
-    const conds = schema.anyOf.map((b) => generateMatchesExpr(raw, b, suffix, ctx, true, collector));
+    const conds = schema.anyOf.map((b) => generateMatchesExpr(raw, b, suffix, ctx, true));
     if (!conds.includes("true")) {
       if (ctx.branchErrors) {
-        lines.push(...branchBufferBlock(`!(${conds.join(" || ")})`, `'must match a schema in anyOf'`, "anyOf", path, ctx));
+        lines.push(...branchErrorsReport(`!(${conds.join(" || ")})`, raw, branchExplainers(schema.anyOf, suffix, ctx), `'must match a schema in anyOf'`, "anyOf", path, ctx));
       } else {
         const condition = `!(${conds.join(" || ")})`;
         if (LITERAL_CONDITION.test(condition))
@@ -727,20 +746,18 @@ const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
     }
   }
   if (hasOneOf(schema) && schema.oneOf.length > 0) {
-    const collector = ctx.branchErrors ? { buffer: BRANCH_BUFFER, path } : void 0;
-    const conds = schema.oneOf.map((b) => `(${generateMatchesExpr(raw, b, suffix, ctx, true, collector)} ? 1 : 0)`);
+    const conds = schema.oneOf.map((b) => `(${generateMatchesExpr(raw, b, suffix, ctx, true)} ? 1 : 0)`);
     const message = `'must match exactly one schema in oneOf'`;
     if (!ctx.branchErrors) {
       lines.push(`  if ((${conds.join(" + ")}) !== 1) {`);
       lines.push(`    ${pushError(ctx.sink, message, path, "oneOf")}`);
       lines.push(`  }`);
     } else {
+      const explain = branchExplainers(schema.oneOf, suffix, ctx);
       lines.push(`  {`);
-      lines.push(`    let ${BRANCH_BUFFER}: ValidationError[][] | null = null`);
       lines.push(`    const _n = ${conds.join(" + ")}`);
-      lines.push(`    if (_n === 0) {`);
-      lines.push(`      ${pushError(ctx.sink, message, path, "oneOf")}`);
-      lines.push(`      ${selectBranchErrorsLine(path, ctx)}`);
+      const report = branchErrorsReport("_n === 0", raw, explain, message, "oneOf", path, ctx).map((line) => `  ${line}`);
+      lines.push(...report.slice(0, -1));
       lines.push(`    } else if (_n !== 1) {`);
       lines.push(`      ${pushError(ctx.sink, message, path, "oneOf")}`);
       lines.push(`    }`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/validation",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "One generator surface over mjst's types, validators, coercers, repairers and parsers.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",