@amritk/validation 0.4.1 → 0.6.0

package/dist/validators/generators/collect-validator-imports.js

@@ -10,20 +10,23 @@ const buildImport = (ref, suffix, reads, importExt) => {
   const checkerName = `check${typeName}`;
   const coercerName = `coerce${typeName}Value`;
   const repairerName = `repair${typeName}At`;
-  const { type, validator, guard = false, checker = false, coercer = false, repairer = false } = reads({
+  const walkerName = `walk${typeName}Repair`;
+  const { type, validator, guard = false, checker = false, coercer = false, repairer = false, walker = false } = reads({
     typeName,
     validatorName,
     guardName,
     checkerName,
     coercerName,
-    repairerName
+    repairerName,
+    walkerName
   });
   const values = [
     ...validator ? [validatorName] : [],
     ...guard ? [guardName] : [],
     ...checker ? [checkerName] : [],
     ...coercer ? [coercerName] : [],
-    ...repairer ? [repairerName] : []
+    ...repairer ? [repairerName] : [],
+    ...walker ? [walkerName] : []
   ];
   if (type && values.length > 0)
     return `import { type ${typeName}, ${values.join(", ")} } from './${filename}.${importExt}'`;

package/dist/validators/generators/generate-files.d.ts

@@ -53,6 +53,12 @@ type GenerateValidatorFileOptions = {
      * validator ever sees it, and never shows up as a repair.
      */
     readonly repair?: boolean;
+    /**
+     * Whether the repairing half also gets the single-pass walk, which `repairX`
+     * then runs instead of the validate-and-repair loop. Decided over the whole
+     * schema graph by the caller, since one walk calls another across files.
+     */
+    readonly repairWalk?: boolean;
     /** Extension on every emitted relative specifier: `'js'` (default) or `'ts'`. */
     readonly importExt?: 'js' | 'ts';
     /**

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

@@ -17,7 +17,7 @@ const generateValidatorFile = (schema, typeName, options) => {
   const importExt = options?.importExt ?? "js";
   const formats = options?.formats ?? NO_FORMATS;
   const validatorFunction = generateValidatorFunction(schema, typeName, typeSuffix, options?.rootSchema, unknownKeys, formats, options?.branchErrors === true);
-  const { code: booleanGuard, standalone: standaloneGuard } = generateBooleanGuardSource(schema, typeName, unknownKeys, formats);
+  const { code: booleanGuard, standalone: standaloneGuard } = generateBooleanGuardSource(schema, typeName, unknownKeys, formats, { suffix: typeSuffix, ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {} });
   const checker = options?.check === true ? generateCheckFunction(schema, typeName, typeSuffix, options?.rootSchema, unknownKeys, formats) : "";
   const wantsCoerce = options?.coerce === true || options?.repair === true;
   const coercer = wantsCoerce ? generateCoerceFunction(schema, typeName, typeSuffix, {
@@ -27,7 +27,8 @@ const generateValidatorFile = (schema, typeName, options) => {
   }).code : "";
   const repairer = options?.repair === true ? generateRepairFunction(schema, typeName, typeSuffix, {
     ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
-    formats
+    formats,
+    walk: options.repairWalk === true
   }).code : "";
   const appended = [checker, coercer, repairer].filter((part) => part !== "");
   const body = validatorFunction + booleanGuard + (appended.length === 0 ? "" : "\n\n" + appended.join("\n\n"));
@@ -37,13 +38,14 @@ const generateValidatorFile = (schema, typeName, options) => {
     rootSchema: options?.rootSchema,
     typeSuffix,
     importExt,
-    reads: ({ typeName: name, validatorName, guardName, checkerName, coercerName, repairerName }) => ({
+    reads: ({ typeName: name, validatorName, guardName, checkerName, coercerName, repairerName, walkerName }) => ({
       type: mentions(name),
       validator: mentions(validatorName),
       guard: mentions(guardName),
       checker: mentions(checkerName),
       coercer: mentions(coercerName),
-      repairer: mentions(repairerName)
+      repairer: mentions(repairerName),
+      walker: mentions(walkerName)
     })
   });
   const resultTypes = [
@@ -51,7 +53,7 @@ const generateValidatorFile = (schema, typeName, options) => {
     .../\bValidationError\b/.test(body) ? ["ValidationError"] : [],
     .../\bCoercionResult\b/.test(body) ? ["CoercionResult"] : [],
     .../\bRepairResult\b/.test(body) ? ["RepairResult"] : [],
-    .../\bRepairLookup\b/.test(body) ? ["RepairLookup"] : []
+    ...["RepairLookup", "RepairOptions", "RepairThunk", "RepairWalk", "RepairRun"].filter((name) => new RegExp(`\\b${name}\\b`).test(body))
   ];
   let result = `import type { ${resultTypes.join(", ")} } from './validation-result.${importExt}'
 `;
@@ -63,10 +65,33 @@ const generateValidatorFile = (schema, typeName, options) => {
     "selectBranchErrors",
     "coerceScalar",
     "coerceUnion",
-    "applyRepairs"
-  ].filter((name) => body.includes(`${name}(`));
-  if (body.includes("MAX_REPAIR_PASSES"))
-    runtimeHelpers.push("MAX_REPAIR_PASSES");
+    "runRepairLoop",
+    "runRepairWalk",
+    "childAt",
+    "fillKey",
+    "fillInto",
+    "walkError",
+    "walkPath",
+    "walkRepair",
+    "walkVerified",
+    "walkSet",
+    "walkSetItem",
+    "walkCompact",
+    "walkMissing",
+    "walkScope",
+    "walkUnscope",
+    "fillBegin",
+    "walkExtra",
+    "walkProto",
+    "walkHalt",
+    "walkMemo",
+    "walkRef",
+    "isPlainObject"
+  ].filter((name) => body.includes(`${name}(`) || body.includes(`${name}<`));
+  for (const name of ["REPAIR_DROP", "NO_SEGMENTS", "MAX_FILL_DEPTH"]) {
+    if (new RegExp(`\\b${name}\\b`).test(body))
+      runtimeHelpers.push(name);
+  }
   if (runtimeHelpers.length > 0) {
     result += `import { ${runtimeHelpers.join(", ")} } from './validation-result.${importExt}'
 `;

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

@@ -5,28 +5,24 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  */
 export declare const repairLookupNameFor: (ref: string, typeSuffix: string) => string;
 /**
- * Generates the repairing half of a validator file: the position lookup, and the
- * `repairX` that drives validate-repair-revalidate over it.
+ * Generates the repairing half of a validator file: the position lookup, the
+ * single-pass walk when the schema is one it covers, and the `repairX` that runs
+ * one or the other.
  *
- * The loop is the whole design. Coercion runs first, so anything that was only
- * written in the wrong type is already right and never counts as a repair. What
- * is left is judged by the very same `validateX` the package already emits, and
- * *its errors* are what drive the repair: each one names a position and a
- * reason, the lookup answers with a value for that position, and the error the
- * repair came from is what gets reported. Nothing second-guesses the validator,
- * and there is no parallel set of rules about what is wrong that could disagree
- * with it.
- *
- * Re-validating after a round is what catches the cases one pass cannot see: a
- * required object that was missing entirely is repaired into existence, and only
- * 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.
+ * The lookup answers what a position repairs to, and both engines ask it, so
+ * they cannot land on different values. The walk checks and repairs every
+ * position in one pass; the loop — validate, repair the reported positions,
+ * validate again — is what every other schema gets. Either way, what is
+ * reported is the error the validator would have produced, and nothing
+ * second-guesses it.
  */
 export declare const generateRepairFunction: (schema: JSONSchema, typeName: string, typeSuffix?: string, options?: {
-    /** The whole document, for a `propertyNames` test that reads a `$ref`'s target. */
+    /** The whole document, for a 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. */
+    /** The `format` names the validator enforces, so a test agrees with it. */
     readonly formats?: ReadonlySet<string>;
+    /** Whether to emit the single-pass walk, decided over the whole schema graph. */
+    readonly walk?: boolean;
 }) => {
     code: string;
 };

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

@@ -1,157 +1,263 @@
 import { regexFlagsFor } from "@amritk/helpers/escape-regex-pattern";
 import { getDefaultValue } from "@amritk/helpers/get-default-value";
-import { readKey } from "@amritk/helpers/read-key";
+import { declaresKey, 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 { emitRepairWalk, repairWalkNameFor } from "./generate-repair-walk.js";
 import { createSubschemaMatcher } from "./generate-validator-function.js";
+import { namedTest, schemaMap, subschema } from "./repair-context.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 isObjectish = (node) => {
+  const type = readKey(node, "type");
+  if (type === "object")
+    return true;
+  return type === void 0 && (declaresKey(node, "properties") || declaresKey(node, "required"));
+};
+const namesItsValue = (node) => declaresKey(node, "default") || declaresKey(node, "const") || declaresKey(node, "enum");
+const requiredKeys = (node) => {
+  const required = readKey(node, "required");
+  return Array.isArray(required) ? required.filter((key) => typeof key === "string") : [];
+};
+const dropLookup = (ctx) => {
+  if (ctx.drop !== null)
+    return ctx.drop;
+  ctx.drop = "_repairDrop";
+  ctx.helpers.push(`const _repairDrop: RepairLookup = (segments, i) => (i === segments.length ? REPAIR_DROP : null)`);
+  return ctx.drop;
+};
+const conditionalBranches = (node, ctx) => {
+  const ifSchema = subschema(node, "if");
+  if (ifSchema === void 0)
+    return null;
+  const thenSchema = subschema(node, "then");
+  const elseSchema = subschema(node, "else");
+  if (thenSchema === void 0 && elseSchema === void 0)
+    return null;
+  const test = namedTest(ifSchema, ctx);
+  const thenLookup = test !== false && thenSchema !== void 0 ? emitLookup(thenSchema, ctx) : null;
+  const elseLookup = test !== true && elseSchema !== void 0 ? emitLookup(elseSchema, ctx) : null;
+  return thenLookup === null && elseLookup === null ? null : { test, thenLookup, elseLookup };
+};
+const conditionalAnswer = (node, ctx) => {
+  const parts = [];
+  const call = (lookup) => lookup === null ? "null" : `${lookup}(segments, i, value)`;
+  const branches = conditionalBranches(node, ctx);
+  if (branches !== null) {
+    const { test, thenLookup, elseLookup } = branches;
+    if (test === true) {
+      if (thenLookup !== null)
+        parts.push(call(thenLookup));
+    } else if (test === false) {
+      if (elseLookup !== null)
+        parts.push(call(elseLookup));
+    } else {
+      parts.push(`(${test}(value) ? ${call(thenLookup)} : ${call(elseLookup)})`);
+    }
+  }
+  const allOf = readKey(node, "allOf");
+  if (Array.isArray(allOf)) {
+    for (const entry of allOf) {
+      const lookup = emitLookup(entry, ctx);
+      if (lookup !== null)
+        parts.push(call(lookup));
+    }
+  }
+  return parts.length === 0 ? null : parts.join(" ?? ");
 };
-const fallbackLiteral = (schema) => {
-  const literal = getDefaultValue(schema);
-  return literal === "undefined" ? null : literal;
+const emitFill = (node, self, id, ctx) => {
+  const literal = namesItsValue(node) ? getDefaultValue(node) : "{}";
+  const base = literal.startsWith("{") ? literal : "{}";
+  const steps = requiredKeys(node).map((key) => `fillKey(o, ${JSON.stringify(key)}, ${self}, depth)`);
+  const branches = conditionalBranches(node, ctx);
+  if (branches !== null) {
+    const { test, thenLookup, elseLookup } = branches;
+    const answer = (lookup) => lookup === null ? "null" : `${lookup}(NO_SEGMENTS, 0, o)`;
+    if (test === true && thenLookup !== null)
+      steps.push(`fillInto(o, ${answer(thenLookup)}, depth)`);
+    else if (test === false && elseLookup !== null)
+      steps.push(`fillInto(o, ${answer(elseLookup)}, depth)`);
+    else if (typeof test === "string") {
+      steps.push(`fillInto(o, ${test}(o) ? ${answer(thenLookup)} : ${answer(elseLookup)}, depth)`);
+    }
+  }
+  const allOf = readKey(node, "allOf");
+  if (Array.isArray(allOf)) {
+    for (const entry of allOf) {
+      const lookup = emitLookup(entry, ctx);
+      if (lookup !== null)
+        steps.push(`fillInto(o, ${lookup}(NO_SEGMENTS, 0, o), depth)`);
+    }
+  }
+  const name = `_repairFill${id}`;
+  const lines = steps.length === 0 ? [`const ${name}: RepairThunk = (_depth, into) => into ?? ${base}`] : [
+    `const ${name}: RepairThunk = (depth, into) => {`,
+    // The outermost fill starts the budget every level of it shares.
+    `  if (into === undefined && depth === 0) fillBegin()`,
+    `  const o: Record<string, unknown> = into ?? ${base}`,
+    `  if (depth < MAX_FILL_DEPTH) {`,
+    ...steps.map((step) => `    ${step}`),
+    `  }`,
+    `  return o`,
+    `}`
+  ];
+  ctx.helpers.push(lines.join("\n"));
+  return name;
 };
-const schemaMap = (schema, key) => {
-  const value = readKey(schema, key);
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+const ownAnswer = (node, self, id, ctx) => {
+  const marker = readKey(node, "x-repair");
+  if (marker === "drop")
+    return "REPAIR_DROP";
+  if (isObjectish(node))
+    return emitFill(node, self, id, ctx);
+  if (readKey(node, "type") === void 0 && !namesItsValue(node)) {
+    const conditional = conditionalAnswer(node, ctx);
+    if (conditional !== null)
+      return conditional;
+  }
+  const literal = getDefaultValue(node);
+  if (literal === "undefined")
+    return null;
+  const name = `_repairValue${id}`;
+  ctx.helpers.push(`const ${name}: RepairThunk = () => (${literal})`);
+  return name;
 };
-const emitWalker = (schema, ctx) => {
+const emitLookup = (schema, ctx) => {
+  if (schema === false)
+    return dropLookup(ctx);
   if (!isSchemaObject(schema))
     return null;
+  if (ctx.lookups.has(schema))
+    return ctx.lookups.get(schema) ?? null;
   const node = schema;
   const ref = readKey(node, "$ref");
-  if (typeof ref === "string")
-    return repairLookupNameFor(ref, ctx.typeSuffix);
-  const own = fallbackLiteral(schema);
+  if (typeof ref === "string") {
+    const name2 = repairLookupNameFor(ref, ctx.typeSuffix);
+    ctx.lookups.set(schema, name2);
+    return name2;
+  }
+  const id = ctx.next();
+  const name = `_repairAt${id}`;
+  ctx.lookups.set(schema, name);
+  const own = ownAnswer(node, name, id, ctx);
+  const descent = emitDescent(node, id, ctx);
+  const conditional = conditionalAnswer(node, ctx);
+  if (own === null && descent === null && conditional === null) {
+    ctx.lookups.set(schema, null);
+    return null;
+  }
+  const deeper = descent !== null && conditional !== null ? `${conditional} ?? ${descent}(segments, i, value)` : descent !== null ? `${descent}(segments, i, value)` : conditional ?? "null";
+  const body = [`  if (i === segments.length) return ${own ?? "null"}`, `  return ${deeper}`];
+  const parameter = body.some((line) => /\bvalue\b/.test(line)) ? "value" : "_value";
+  ctx.helpers.push([`const ${name}: RepairLookup = (segments, i, ${parameter}) => {`, ...body, `}`].join("\n"));
+  return name;
+};
+const emitDescent = (node, id, ctx) => {
   const properties = schemaMap(node, "properties") ?? {};
-  const children = Object.entries(properties).map(([key, child]) => [key, emitWalker(child, ctx)]).filter((entry) => entry[1] !== null);
+  const children = Object.entries(properties).map(([key, child2]) => [key, emitLookup(child2, ctx)]).filter((entry) => entry[1] !== null);
   const patternProperties = schemaMap(node, "patternProperties") ?? {};
-  const patterns = Object.entries(patternProperties).map(([source, child]) => ({
+  const patterns = Object.entries(patternProperties).map(([source, child2]) => ({
     source,
-    walker: emitWalker(child, ctx)
+    lookup: emitLookup(child2, 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 additional = subschema(node, "additionalProperties");
+  const additionalLookup = additional === void 0 ? null : emitLookup(additional, ctx);
+  const mapped = additionalLookup !== null || patterns.some((pattern) => pattern.lookup !== null);
   const prefixItems = readKey(node, "prefixItems");
   const tuple = Array.isArray(prefixItems) ? prefixItems : [];
-  const tupleWalkers = tuple.map((item) => emitWalker(item, ctx));
+  const tupleLookups = tuple.map((item) => emitLookup(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 || mapped || itemsWalker !== null || tupleWalkers.some((walker) => walker !== null);
-  if (own === null && !hasChildren)
+  const itemsSchema = typeof items === "boolean" || typeof items === "object" && items !== null && !Array.isArray(items);
+  const itemsLookup = itemsSchema ? emitLookup(items, ctx) : null;
+  const indexed = tupleLookups.some((lookup) => lookup !== null) || itemsLookup !== null;
+  if (children.length === 0 && !mapped && !indexed)
     return null;
-  const id = ctx.next();
-  const name = `_repairAt${id}`;
-  const lines = [
-    `const ${name}: RepairLookup = (segments) => {`,
-    `  if (segments.length === 0) return ${own === null ? "null" : `() => (${own})`}`
-  ];
-  if (hasChildren) {
-    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 of declared) {
-        const walker = walkers.get(key);
-        lines.push(`    case ${JSON.stringify(key)}: return ${walker === void 0 ? "null" : `${walker}(rest)`}`);
-      }
-      lines.push(`  }`);
-    }
-    if (indexBlock) {
-      lines.push(`  const index = Number(head)`);
-      lines.push(`  if (Number.isInteger(index) && index >= 0) {`);
-      tupleWalkers.forEach((walker, position) => {
-        if (walker === null)
-          return;
-        lines.push(`    if (index === ${position}) return ${walker}(rest)`);
-      });
-      if (itemsWalker !== null) {
-        lines.push(`    if (index >= ${tuple.length}) return ${itemsWalker}(rest)`);
-      }
-      if (mapped && arrayKeywords)
-        lines.push(`    return null`);
-      lines.push(`  }`);
+  const name = `_repairChild${id}`;
+  const lines = [`const ${name}: RepairLookup = (segments, i, value) => {`];
+  lines.push(`  const head = segments[i] as string`);
+  lines.push(`  const next = i + 1`);
+  const declared = mapped ? Object.keys(properties) : children.map(([key]) => key);
+  const arrayKeywords = tuple.length > 0 || itemsSchema;
+  const indexBlock = indexed || mapped && arrayKeywords;
+  const nameSchema = readKey(node, "propertyNames");
+  const keyCheck = nameSchema === void 0 ? true : namedTest(nameSchema, ctx);
+  if (keyCheck === false)
+    lines.push(`  if (next === segments.length) return null`);
+  if (typeof keyCheck === "string")
+    lines.push(`  if (next === segments.length && !${keyCheck}(head)) return null`);
+  const child = `childAt(value, head)`;
+  if (declared.length > 0) {
+    const lookups = new Map(children);
+    lines.push(`  switch (head) {`);
+    for (const key of declared) {
+      const lookup = lookups.get(key);
+      lines.push(`    case ${JSON.stringify(key)}: return ${lookup === void 0 ? "null" : `${lookup}(segments, next, ${child})`}`);
     }
-    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;
+    lines.push(`  }`);
+  }
+  if (indexBlock) {
+    lines.push(`  const index = Number(head)`);
+    lines.push(`  if (Number.isInteger(index) && index >= 0) {`);
+    tupleLookups.forEach((lookup, position) => {
+      if (lookup === null)
+        return;
+      lines.push(`    if (index === ${position}) return ${lookup}(segments, next, ${child})`);
+    });
+    if (itemsLookup !== null)
+      lines.push(`    if (index >= ${tuple.length}) return ${itemsLookup}(segments, next, ${child})`);
+    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 = (lookup) => lookup === null ? "null" : `${lookup}(segments, next, ${child})`;
+    const only = patterns[0];
+    if (patterns.length === 1 && only !== void 0) {
+      lines.push(`  if (${regexNames[0]}.test(head)) return ${answer(only.lookup)}`);
+    } 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.lookup)}`);
       });
-      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(additionalWalker === null ? `  return null` : `  return ${additionalWalker}(rest)`, `}`);
-  ctx.helpers.push(lines.join("\n"));
+  lines.push(additionalLookup === null ? `  return null` : `  return ${additionalLookup}(segments, next, ${child})`, `}`);
+  const text = lines.join("\n");
+  ctx.helpers.push(/\bvalue\b/.test(text.slice(text.indexOf("\n"))) ? text : text.replace("i, value) => {", "i, _value) => {"));
   return name;
 };
 const generateRepairFunction = (schema, typeName, typeSuffix = "", options = {}) => {
   const helpers = [];
   let counter = 0;
-  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 rootSchema = options.rootSchema ?? (isSchemaObject(schema) ? schema : void 0);
+  const matcher = createSubschemaMatcher(typeSuffix, rootSchema, options.formats ?? NO_FORMATS, "_repair");
+  const ctx = {
+    typeSuffix,
+    helpers,
+    next: () => counter++,
+    matcher,
+    lookups: /* @__PURE__ */ new Map(),
+    tests: /* @__PURE__ */ new Map(),
+    drop: null
+  };
+  const lookup = emitLookup(schema, ctx);
   const lookupName = `repair${typeName}At`;
+  const walkName = repairWalkNameFor(typeName);
+  const walker = options.walk === true ? emitRepairWalk(schema, { repair: ctx, typeName, rootSchema, lookupFor: (node) => emitLookup(node, ctx) }) : null;
   const declarations = [...matcher.declarations(helpers.join("\n")), ...helpers];
   const parts = [
     ...declarations.length > 0 ? [declarations.join("\n\n"), ""] : [],
-    `export const ${lookupName}: RepairLookup = ${walker === null ? "() => null" : walker}`,
+    `export const ${lookupName}: RepairLookup = ${lookup === null ? "() => null" : lookup}`,
     "",
-    `export const repair${typeName} = (input: unknown, _path = ''): RepairResult<${typeName}> => {`,
-    `  let value = coerce${typeName}Value(input)`,
-    `  const repairs: ValidationError[] = []`,
-    `  const done = new Set<string>()`,
-    ``,
-    `  for (let pass = 0; pass < MAX_REPAIR_PASSES; pass++) {`,
-    `    const result = validate${typeName}(value, _path)`,
-    `    if (result === true) return { valid: true, value: value as ${typeName}, repairs }`,
-    ``,
-    `    const applied = applyRepairs(value, result.errors, ${lookupName}, done)`,
-    `    // Nothing moved, so nothing on a further pass would either.`,
-    `    if (applied.repaired.length === 0) return { valid: false, value, errors: result.errors, repairs }`,
-    `    value = applied.value`,
-    `    repairs.push(...applied.repaired)`,
-    `  }`,
-    ``,
-    `  const final = validate${typeName}(value, _path)`,
-    `  return final === true`,
-    `    ? { valid: true, value: value as ${typeName}, repairs }`,
-    `    : { valid: false, value, errors: final.errors, repairs }`,
-    `}`
+    ...options.walk === true ? [`export const ${walkName}: RepairWalk = ${walker ?? "(value) => value"}`, ""] : [],
+    `export const repair${typeName} = (input: unknown, options?: RepairOptions | string): RepairResult<${typeName}> =>`,
+    options.walk === true ? `  runRepairWalk<${typeName}>(input, options, ${walkName})` : `  runRepairLoop<${typeName}>(input, options, validate${typeName}, ${lookupName}, coerce${typeName}Value)`
   ];
   return { code: parts.join("\n") };
 };

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

@@ -0,0 +1,24 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+import { type RepairContext } from './repair-context.js';
+/**
+ * The name of the walk a file exports for its definition. Not `repairXWalk`:
+ * that is the `repairX` of a definition named `XWalk`, and the barrel would
+ * export one name twice.
+ */
+export declare const repairWalkNameFor: (typeName: string) => string;
+type WalkContext = {
+    /** The lookup's context: declarations, numbering and the shared tests. */
+    readonly repair: RepairContext;
+    /** The definition this file is for, which names the type of its root position. */
+    readonly typeName: string;
+    /** The whole document, to see through a `$ref` to a Reference schema. */
+    readonly rootSchema: Record<string, unknown> | undefined;
+    /** The lookup for a node — the one `repairXAt` reaches it through. */
+    readonly lookupFor: (schema: JSONSchema) => string | null;
+};
+/**
+ * Emits the single-pass repair walk for a definition and answers the name of its
+ * root walker, or `null` when nothing in it is checked.
+ */
+export declare const emitRepairWalk: (schema: JSONSchema, ctx: WalkContext) => string | null;
+export {};