@amritk/generate-validators 0.16.1 → 0.17.0

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

@@ -11,7 +11,8 @@ import { unknownKeyCheck } from "@amritk/helpers/unknown-key-check";
 import { DEFAULT_UNKNOWN_KEYS } from "@amritk/helpers/unknown-keys-strategy";
 import { assertGeneratableRefs } from "./assert-generatable-refs.js";
 import { assertUnevaluatedGeneratable, UNPROVABLE_COVERAGE_MESSAGE } from "./assert-unevaluated-generatable.js";
-import { declaresKeywordOutside } from "./enforced-keywords.js";
+import { formatCheckName, formatFamily } from "./emit-format-checks.js";
+import { declaresKeywordOutside, enforcesFormat, NO_FORMATS } from "./enforced-keywords.js";
 import { tupleShapeOf } from "./tuple-shape.js";
 import { unevaluatedItemsExpr, unevaluatedPropertiesExpr } from "./unevaluated-match.js";
 const validatorName = (typeName) => `validate${typeName}`;
@@ -97,14 +98,17 @@ const getTypeArray = (schema) => {
   return schema.type;
 };
 const ROOT_ERROR_SINK = "(errors ??= [])";
+const pushError = (sink, message, path, keyword, params = "{}") => `${sink}.push({ message: ${message}, path: ${path}, keyword: ${JSON.stringify(keyword)}, params: ${params} })`;
+const returnError = (message, path, keyword, params = "{}") => `return { valid: false, errors: [{ message: ${message}, path: ${path}, keyword: ${JSON.stringify(keyword)}, params: ${params} }] }`;
 const MATCH_ERROR_SINK = "_m";
-const createRootContext = (rootSchema) => ({
+const createRootContext = (rootSchema, formats = NO_FORMATS) => ({
   objVar: "obj",
   pathPrefix: "${_path}",
   depth: 0,
   hoisted: [],
   rootSchema,
-  sink: ROOT_ERROR_SINK
+  sink: ROOT_ERROR_SINK,
+  formats
 });
 const pointerSegment = (key) => {
   const pointer = key.replace(/~/g, "~0").replace(/\//g, "~1");
@@ -157,7 +161,7 @@ const generateStrictKeyChecks = (schema, ctx) => {
   return [
     `  for (const _key${d} in ${ctx.objVar}) {`,
     `    if (${unknownTest}${patternGuard}) {`,
-    `      ${ctx.sink}.push({ message: 'must NOT have additional properties', path: \`${ctx.pathPrefix}/\${escapePointer(_key${d})}\` })`,
+    `      ${pushError(ctx.sink, "'must NOT have additional properties'", `\`${ctx.pathPrefix}/\${escapePointer(_key${d})}\``, "additionalProperties", `{ additionalProperty: _key${d} }`)}`,
     `    }`,
     `  }`
   ];
@@ -172,7 +176,7 @@ const generateMissingRequiredChecks = (schema, ctx) => {
     if (Object.hasOwn(props, key))
       continue;
     lines.push(`  if (${missingCheck(ctx.objVar, key)}) {`);
-    lines.push(`    ${ctx.sink}.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
+    lines.push(`    ${pushError(ctx.sink, JSON.stringify(`must have required property '${key}'`), parentPath, "required", JSON.stringify({ missingProperty: key }))}`);
     lines.push(`  }`);
   }
   return lines;
@@ -184,15 +188,15 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
     if (isRequired) {
       return [
         `  if (${missingCheck(ctx.objVar, key)}) {`,
-        `    ${ctx.sink}.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`,
+        `    ${pushError(ctx.sink, JSON.stringify(`must have required property '${key}'`), parentPath, "required", JSON.stringify({ missingProperty: key }))}`,
         `  } else {`,
-        `    ${ctx.sink}.push({ message: ${JSON.stringify(FALSE_SCHEMA_MESSAGE)}, path: ${path} })`,
+        `    ${pushError(ctx.sink, JSON.stringify(FALSE_SCHEMA_MESSAGE), path, "false schema")}`,
         `  }`
       ];
     }
     return [
       `  if (${hasOwnCheck(ctx.objVar, key)}) {`,
-      `    ${ctx.sink}.push({ message: ${JSON.stringify(FALSE_SCHEMA_MESSAGE)}, path: ${path} })`,
+      `    ${pushError(ctx.sink, JSON.stringify(FALSE_SCHEMA_MESSAGE), path, "false schema")}`,
       `  }`
     ];
   }
@@ -236,26 +240,26 @@ const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) =>
   const instanceOf = getMjstInstanceOf(schema);
   if (instanceOf) {
     lines.push(`  if (${presence}!(${raw} instanceof ${instanceOf})) {`);
-    lines.push(`    ${ctx.sink}.push({ message: 'must be ${instanceOf}', path: ${path} })`);
+    lines.push(`    ${pushError(ctx.sink, `'must be ${instanceOf}'`, path, "type", JSON.stringify({ type: instanceOf }))}`);
     lines.push(`  }`);
   }
   const primitive = getMjstPrimitive(schema);
   if (primitive) {
     lines.push(`  if (${presence}typeof ${raw} !== "${primitive}") {`);
-    lines.push(`    ${ctx.sink}.push({ message: 'must be ${primitive}', path: ${path} })`);
+    lines.push(`    ${pushError(ctx.sink, `'must be ${primitive}'`, path, "type", JSON.stringify({ type: primitive }))}`);
     lines.push(`  }`);
   }
   if (hasConst(schema)) {
     const mismatch = constMismatchCondition(raw, schema.const);
     const msg = JSON.stringify(`must be ${JSON.stringify(schema.const)}`);
     lines.push(`  if (${presence}${mismatch}) {`);
-    lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${path} })`);
+    lines.push(`    ${pushError(ctx.sink, msg, path, "const", JSON.stringify({ allowedValue: schema.const }))}`);
     lines.push(`  }`);
   }
   if (hasEnum(schema)) {
     const label = schema.enum.map((v) => JSON.stringify(v)).join(", ");
     lines.push(`  if (${presence}!${enumMembershipExpr(schema.enum, raw)}) {`);
-    lines.push(`    ${ctx.sink}.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
+    lines.push(`    ${pushError(ctx.sink, JSON.stringify(`must be one of: ${label}`), path, "enum", JSON.stringify({ allowedValues: schema.enum }))}`);
     lines.push(`  }`);
   }
   if (instanceOf === void 0 && primitive === void 0) {
@@ -264,7 +268,7 @@ const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) =>
       const wrongType = wrongTypeCondition(raw, t);
       if (wrongType) {
         lines.push(`  if (${presence === "" ? wrongType : `${presence}(${wrongType})`}) {`);
-        lines.push(`    ${ctx.sink}.push({ message: 'must be ${typeofString(t)}', path: ${path} })`);
+        lines.push(`    ${pushError(ctx.sink, `'must be ${typeofString(t)}'`, path, "type", JSON.stringify({ type: t }))}`);
         lines.push(`  }`);
       }
     }
@@ -274,7 +278,7 @@ const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) =>
       if (allWrong) {
         const label = typeArray.map((t) => typeofString(t)).join(" or ");
         lines.push(`  if (${presence === "" ? allWrong : `${presence}(${allWrong})`}) {`);
-        lines.push(`    ${ctx.sink}.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${path} })`);
+        lines.push(`    ${pushError(ctx.sink, JSON.stringify(`must be ${label}`), path, "type", JSON.stringify({ type: schema.type }))}`);
         lines.push(`  }`);
       }
     }
@@ -293,7 +297,7 @@ const generatePropertyCheckLines = (key, propSchema, isRequired, suffix, ctx) =>
   const parentPath = ctx.depth === 0 ? "_path" : `\`${ctx.pathPrefix}\``;
   const missing = [
     `  if (${missingCheck(ctx.objVar, key)}) {`,
-    `    ${ctx.sink}.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`
+    `    ${pushError(ctx.sink, JSON.stringify(`must have required property '${key}'`), parentPath, "required", JSON.stringify({ missingProperty: key }))}`
   ];
   if (!isSchemaObject(propSchema)) {
     if (isRequired && propSchema === true)
@@ -318,22 +322,31 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
     return [];
   const sp = propSchema;
   const lines = [];
+  if (isSchemaObject(propSchema) && enforcesFormat(propSchema, ctx.formats)) {
+    const format = propSchema.format;
+    const family = formatFamily(format);
+    if (family !== void 0) {
+      lines.push(`  if (typeof ${raw} === '${family}' && !${formatCheckName(format)}(${raw})) {`);
+      lines.push(`    ${pushError(ctx.sink, JSON.stringify(`must match format "${format}"`), path, "format", JSON.stringify({ format }))}`);
+      lines.push(`  }`);
+    }
+  }
   if (hasPattern(propSchema) || hasMinLength(propSchema) || hasMaxLength(propSchema)) {
     if (hasPattern(propSchema)) {
       const re = regexLiteral(propSchema.pattern);
       const msg = JSON.stringify(`must match pattern ${propSchema.pattern}`);
       lines.push(`  if (typeof ${raw} === 'string' && !${re}.test(${raw})) {`);
-      lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, msg, path, "pattern", JSON.stringify({ pattern: propSchema.pattern }))}`);
       lines.push(`  }`);
     }
     if (hasMinLength(propSchema) && propSchema.minLength > 0) {
       lines.push(`  if (typeof ${raw} === 'string' && ${minLengthFailExpr(raw, propSchema.minLength)}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must have at least ${propSchema.minLength} characters', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must have at least ${propSchema.minLength} characters'`, path, "minLength", JSON.stringify({ limit: propSchema.minLength }))}`);
       lines.push(`  }`);
     }
     if (hasMaxLength(propSchema)) {
       lines.push(`  if (typeof ${raw} === 'string' && ${maxLengthFailExpr(raw, propSchema.maxLength)}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must have at most ${propSchema.maxLength} characters', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must have at most ${propSchema.maxLength} characters'`, path, "maxLength", JSON.stringify({ limit: propSchema.maxLength }))}`);
       lines.push(`  }`);
     }
   }
@@ -341,28 +354,28 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
     if (hasMinimum(propSchema)) {
       const strict = hasStrictExclusiveMinimum(propSchema);
       lines.push(`  if (typeof ${raw} === 'number' && ${boundFailExpr(raw, "minimum", propSchema.minimum, strict)}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must be ${boundOperator("minimum", strict)} ${propSchema.minimum}', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must be ${boundOperator("minimum", strict)} ${propSchema.minimum}'`, path, strict ? "exclusiveMinimum" : "minimum", JSON.stringify({ comparison: boundOperator("minimum", strict), limit: propSchema.minimum }))}`);
       lines.push(`  }`);
     }
     if (hasMaximum(propSchema)) {
       const strict = hasStrictExclusiveMaximum(propSchema);
       lines.push(`  if (typeof ${raw} === 'number' && ${boundFailExpr(raw, "maximum", propSchema.maximum, strict)}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must be ${boundOperator("maximum", strict)} ${propSchema.maximum}', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must be ${boundOperator("maximum", strict)} ${propSchema.maximum}'`, path, strict ? "exclusiveMaximum" : "maximum", JSON.stringify({ comparison: boundOperator("maximum", strict), limit: propSchema.maximum }))}`);
       lines.push(`  }`);
     }
     if (hasExclusiveMinimum(propSchema)) {
       lines.push(`  if (typeof ${raw} === 'number' && ${boundFailExpr(raw, "minimum", propSchema.exclusiveMinimum, true)}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must be > ${propSchema.exclusiveMinimum}', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must be > ${propSchema.exclusiveMinimum}'`, path, "exclusiveMinimum", JSON.stringify({ comparison: ">", limit: propSchema.exclusiveMinimum }))}`);
       lines.push(`  }`);
     }
     if (hasExclusiveMaximum(propSchema)) {
       lines.push(`  if (typeof ${raw} === 'number' && ${boundFailExpr(raw, "maximum", propSchema.exclusiveMaximum, true)}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must be < ${propSchema.exclusiveMaximum}', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must be < ${propSchema.exclusiveMaximum}'`, path, "exclusiveMaximum", JSON.stringify({ comparison: "<", limit: propSchema.exclusiveMaximum }))}`);
       lines.push(`  }`);
     }
     if (hasMultipleOf(propSchema)) {
       lines.push(`  if (typeof ${raw} === 'number' && ${multipleOfFailExpr(raw, propSchema.multipleOf)}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must be a multiple of ${propSchema.multipleOf}', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must be a multiple of ${propSchema.multipleOf}'`, path, "multipleOf", JSON.stringify({ multipleOf: propSchema.multipleOf }))}`);
       lines.push(`  }`);
     }
   }
@@ -397,23 +410,23 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
   if (hasMinItems(propSchema) || hasMaxItems(propSchema) || hasUniqueItems(propSchema) && propSchema.uniqueItems === true || declaresKey(sp, "contains") || tuple !== void 0 || tail === false && tuple === void 0) {
     if (tail === false && tuple === void 0) {
       lines.push(`  if (Array.isArray(${raw}) && ${raw}.length > 0) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must NOT have more than 0 items', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must NOT have more than 0 items'`, path, "items", "{ limit: 0 }")}`);
       lines.push(`  }`);
     }
     if (hasMinItems(propSchema)) {
       lines.push(`  if (Array.isArray(${raw}) && ${raw}.length < ${propSchema.minItems}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must have at least ${propSchema.minItems} items', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must have at least ${propSchema.minItems} items'`, path, "minItems", JSON.stringify({ limit: propSchema.minItems }))}`);
       lines.push(`  }`);
     }
     if (hasMaxItems(propSchema)) {
       lines.push(`  if (Array.isArray(${raw}) && ${raw}.length > ${propSchema.maxItems}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must have at most ${propSchema.maxItems} items', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must have at most ${propSchema.maxItems} items'`, path, "maxItems", JSON.stringify({ limit: propSchema.maxItems }))}`);
       lines.push(`  }`);
     }
     if (hasUniqueItems(propSchema) && propSchema.uniqueItems === true) {
       const dupCond = arrayItemsAreScalarOnly(sp) ? `new Set(${raw} as unknown[]).size !== ${raw}.length` : `!allUnique(${raw} as unknown[])`;
       lines.push(`  if (Array.isArray(${raw}) && ${dupCond}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must NOT have duplicate items', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must NOT have duplicate items'`, path, "uniqueItems")}`);
       lines.push(`  }`);
     }
     if (declaresKey(sp, "contains")) {
@@ -423,7 +436,7 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       const max = typeof declaredMax === "number" ? declaredMax : void 0;
       if (min > 0 || max !== void 0) {
         const matchExpr = generateMatchesExpr("_c", readKey(sp, "contains"), suffix, ctx, true);
-        const report = `${ctx.sink}.push({ message: 'array does not contain the required matching items', path: ${path} })`;
+        const report = pushError(ctx.sink, `'array does not contain the required matching items'`, path, "contains");
         if (matchExpr === "true") {
           const bound = max !== void 0 ? `${raw}.length < ${min} || ${raw}.length > ${max}` : `${raw}.length < ${min}`;
           lines.push(`  if (Array.isArray(${raw}) && (${bound})) {`);
@@ -465,7 +478,7 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
       }
       if (tailIsClosed) {
         lines.push(`    if (${raw}.length > ${tuple.length}) {`);
-        lines.push(`      ${ctx.sink}.push({ message: 'must NOT have more than ${tuple.length} items', path: ${path} })`);
+        lines.push(`      ${pushError(ctx.sink, `'must NOT have more than ${tuple.length} items'`, path, "items", JSON.stringify({ limit: tuple.length }))}`);
         lines.push(`    }`);
       }
       lines.push(`  }`);
@@ -485,7 +498,7 @@ const generateValueChecks = (key, raw, path, propSchema, suffix, ctx, required =
 const generateValueCheckLines = (_key, raw, path, propSchema, suffix, ctx, required = false) => {
   const lines = [];
   if (propSchema === false) {
-    const report = `${ctx.sink}.push({ message: ${JSON.stringify(FALSE_SCHEMA_MESSAGE)}, path: ${path} })`;
+    const report = pushError(ctx.sink, JSON.stringify(FALSE_SCHEMA_MESSAGE), path, "false schema");
     if (required)
       return [`  {`, `    ${report}`, `  }`];
     return [`  if (${raw} !== undefined) {`, `    ${report}`, `  }`];
@@ -499,7 +512,8 @@ const generateValueCheckLines = (_key, raw, path, propSchema, suffix, ctx, requi
     depth: ctx.depth + 1,
     hoisted: ctx.hoisted,
     rootSchema: ctx.rootSchema,
-    sink: ctx.sink
+    sink: ctx.sink,
+    formats: ctx.formats
   };
   lines.push(...generateKeywordChecks("", raw, path, propSchema, suffix, valueCtx, presence));
   return lines;
@@ -548,7 +562,7 @@ const generateUnevaluatedChecks = (raw, path, schema, suffix, ctx) => {
     for (const statement of properties.setup)
       lines.push(`    ${statement}`);
     lines.push(`    if (!(${properties.expr})) {`);
-    lines.push(`      ${ctx.sink}.push({ message: 'must NOT have unevaluated properties', path: ${path} })`);
+    lines.push(`      ${pushError(ctx.sink, `'must NOT have unevaluated properties'`, path, "unevaluatedProperties")}`);
     lines.push(`    }`);
     lines.push(`  }`);
   }
@@ -560,7 +574,7 @@ const generateUnevaluatedChecks = (raw, path, schema, suffix, ctx) => {
     for (const statement of items.setup)
       lines.push(`    ${statement}`);
     lines.push(`    if (!(${items.expr})) {`);
-    lines.push(`      ${ctx.sink}.push({ message: 'must NOT have unevaluated items', path: ${path} })`);
+    lines.push(`      ${pushError(ctx.sink, `'must NOT have unevaluated items'`, path, "unevaluatedItems")}`);
     lines.push(`    }`);
     lines.push(`  }`);
   }
@@ -578,14 +592,14 @@ const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
     const conds = schema.anyOf.map((b) => generateMatchesExpr(raw, b, suffix, ctx, true));
     if (!conds.includes("true")) {
       lines.push(`  if (!(${conds.join(" || ")})) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must match a schema in anyOf', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must match a schema in anyOf'`, path, "anyOf")}`);
       lines.push(`  }`);
     }
   }
   if (hasOneOf(schema) && schema.oneOf.length > 0) {
     const conds = schema.oneOf.map((b) => `(${generateMatchesExpr(raw, b, suffix, ctx, true)} ? 1 : 0)`);
     lines.push(`  if ((${conds.join(" + ")}) !== 1) {`);
-    lines.push(`    ${ctx.sink}.push({ message: 'must match exactly one schema in oneOf', path: ${path} })`);
+    lines.push(`    ${pushError(ctx.sink, `'must match exactly one schema in oneOf'`, path, "oneOf")}`);
     lines.push(`  }`);
   }
   const not = readKey(schema, "not");
@@ -593,7 +607,7 @@ const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
     const cond = generateMatchesExpr(raw, not, suffix, ctx, true);
     if (cond !== "false") {
       lines.push(`  if (${cond}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must NOT match the schema in not', path: ${path} })`);
+      lines.push(`    ${pushError(ctx.sink, `'must NOT match the schema in not'`, path, "not")}`);
       lines.push(`  }`);
     }
   }
@@ -680,7 +694,8 @@ const generateInlineObjectChecks = (key, propSchema, raw, suffix, ctx) => {
     depth: ctx.depth + 1,
     hoisted: ctx.hoisted,
     rootSchema: ctx.rootSchema,
-    sink: ctx.sink
+    sink: ctx.sink,
+    formats: ctx.formats
   };
   const required = new Set(hasRequired(propSchema) ? propSchema.required : []);
   const properties = hasProperties(propSchema) ? propSchema.properties : {};
@@ -715,7 +730,8 @@ const generatePropertyNameChecks = (nameSchema, suffix, ctx) => {
     depth: ctx.depth + 1,
     hoisted: ctx.hoisted,
     rootSchema: ctx.rootSchema,
-    sink: ctx.sink
+    sink: ctx.sink,
+    formats: ctx.formats
   };
   const checks = generateValueChecks("", "_name", at, nameSchema, suffix, nameCtx, true);
   if (checks.length === 0)
@@ -734,7 +750,7 @@ const generateDependentRequiredChecks = (schema, ctx) => {
     for (const dep of deps) {
       const msg = JSON.stringify(`must have property '${dep}' when '${trigger}' is present`);
       lines.push(`  if (${hasOwnCheck(obj, trigger)} && ${missingCheck(obj, dep)}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${at} })`);
+      lines.push(`    ${pushError(ctx.sink, msg, at, "dependentRequired", JSON.stringify({ missingProperty: dep, property: trigger, depsCount: 1 }))}`);
       lines.push(`  }`);
     }
   }
@@ -760,7 +776,7 @@ const generateDependentSchemasChecks = (schema, suffix, ctx) => {
     if (sub === false) {
       const msg = JSON.stringify(`must NOT have property '${trigger}'`);
       lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${at} })`);
+      lines.push(`    ${pushError(ctx.sink, msg, at, "dependentSchemas", JSON.stringify({ property: trigger }))}`);
       lines.push(`  }`);
       continue;
     }
@@ -794,7 +810,7 @@ const generateDependenciesChecks = (schema, suffix, ctx) => {
           continue;
         const msg = JSON.stringify(`must have property '${key}' when '${trigger}' is present`);
         lines.push(`  if (${hasOwnCheck(obj, trigger)} && ${missingCheck(obj, key)}) {`);
-        lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${at} })`);
+        lines.push(`    ${pushError(ctx.sink, msg, at, "dependencies", JSON.stringify({ missingProperty: key, property: trigger, depsCount: 1 }))}`);
         lines.push(`  }`);
       }
       continue;
@@ -804,7 +820,7 @@ const generateDependenciesChecks = (schema, suffix, ctx) => {
     if (value === false) {
       const msg = JSON.stringify(`must NOT have property '${trigger}'`);
       lines.push(`  if (${hasOwnCheck(obj, trigger)}) {`);
-      lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${at} })`);
+      lines.push(`    ${pushError(ctx.sink, msg, at, "dependencies", JSON.stringify({ property: trigger }))}`);
       lines.push(`  }`);
       continue;
     }
@@ -835,13 +851,13 @@ const generateMinMaxPropertiesChecks = (schema, ctx) => {
   if (hasMin) {
     const msg = JSON.stringify(`must have at least ${schema.minProperties} properties`);
     lines.push(`  if (${count} < ${schema.minProperties}) {`);
-    lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${at} })`);
+    lines.push(`    ${pushError(ctx.sink, msg, at, "minProperties", JSON.stringify({ limit: schema.minProperties }))}`);
     lines.push(`  }`);
   }
   if (hasMax) {
     const msg = JSON.stringify(`must have at most ${schema.maxProperties} properties`);
     lines.push(`  if (${count} > ${schema.maxProperties}) {`);
-    lines.push(`    ${ctx.sink}.push({ message: ${msg}, path: ${at} })`);
+    lines.push(`    ${pushError(ctx.sink, msg, at, "maxProperties", JSON.stringify({ limit: schema.maxProperties }))}`);
     lines.push(`  }`);
   }
   return lines;
@@ -857,7 +873,13 @@ const carriesUnevaluated = (schema) => {
   const s = schema;
   return declaresKey(s, "unevaluatedProperties") && s["unevaluatedProperties"] !== true || declaresKey(s, "unevaluatedItems") && s["unevaluatedItems"] !== true;
 };
-const createGuardContext = (unknownKeys) => ({ unknownKeys, locals: 0, loops: 0 });
+const createGuardContext = (unknownKeys, formats = NO_FORMATS) => ({ unknownKeys, formats, locals: 0, loops: 0 });
+const guardFormatPass = (schema, acc, ctx) => {
+  if (!enforcesFormat(schema, ctx.formats))
+    return null;
+  const format = schema.format;
+  return formatFamily(format) === void 0 ? null : `${formatCheckName(format)}(${acc})`;
+};
 const emptyGuardBlock = () => ({ conditions: [], nested: [], keyChecks: [] });
 const isFlatGuardBlock = (block) => block.nested.length === 0 && block.keyChecks.length === 0;
 const keySetCheckLines = (check, bail, indent, unknownKeys) => {
@@ -996,11 +1018,11 @@ const guardObjectConditions = (schema, raw, objAcc, ctx) => {
   }
   return block;
 };
-const generateObjectValidator = (schema, typeName, suffix, rootSchema, unknownKeys) => {
+const generateObjectValidator = (schema, typeName, suffix, rootSchema, unknownKeys, formats) => {
   const vName = validatorName(typeName);
   const required = new Set(hasRequired(schema) ? schema.required : []);
   const properties = hasProperties(schema) ? schema.properties : {};
-  const ctx = createRootContext(rootSchema);
+  const ctx = createRootContext(rootSchema, formats);
   const propertyLines = [];
   for (const [key, propSchema] of Object.entries(properties)) {
     const checks = generatePropertyChecks(key, propSchema, required.has(key), suffix, ctx);
@@ -1025,13 +1047,13 @@ const generateObjectValidator = (schema, typeName, suffix, rootSchema, unknownKe
     propertyLines.push(...objectCombinators);
   }
   const body = propertyLines.length > 0 ? "\n" + propertyLines.join("\n") + "\n" : "";
-  const guard = guardObjectConditions(schema, "input", "obj", createGuardContext(unknownKeys));
+  const guard = guardObjectConditions(schema, "input", "obj", createGuardContext(unknownKeys, formats));
   const objBinding = readsObjBinding(body) ? [`  const obj = input as Record<string, unknown>`] : [];
   const collectBody = (name, exported) => [
     `${exported ? "export " : ""}const ${name} = (input: unknown, _path = ''): ValidationResult => {`,
     ...objBinding,
     `  if (typeof input !== 'object' || input === null || Array.isArray(input)) {`,
-    `    return { valid: false, errors: [{ message: 'must be object', path: _path }] }`,
+    `    ${returnError(`'must be object'`, "_path", "type", JSON.stringify({ type: "object" }))}`,
     `  }`,
     ``,
     `  let errors: ValidationError[] | undefined`,
@@ -1095,7 +1117,7 @@ const booleanLeafExpr = (schema, acc, ctx) => {
   if (!hasType(schema)) {
     if (!hasEnum(schema))
       return null;
-    if (declaresKeywordOutside(schema, ["enum"]))
+    if (declaresKeywordOutside(schema, ["enum"], ctx.formats))
       return null;
     return enumMembershipExpr(schema.enum, acc);
   }
@@ -1116,6 +1138,9 @@ const booleanLeafExpr = (schema, acc, ctx) => {
     // spellings of `(obj.a as Record<string, unknown>).b`.
     case "string": {
       const parts = [`typeof ${acc} === 'string'`];
+      const formatPass = guardFormatPass(schema, acc, ctx);
+      if (formatPass !== null)
+        parts.push(formatPass);
       if (hasPattern(schema))
         parts.push(`${regexLiteral(schema.pattern)}.test(${acc})`);
       if (hasMinLength(schema))
@@ -1129,6 +1154,9 @@ const booleanLeafExpr = (schema, acc, ctx) => {
       const parts = [`typeof ${acc} === 'number'`];
       if (t === "integer")
         parts.push(`Number.isInteger(${acc})`);
+      const formatPass = guardFormatPass(schema, acc, ctx);
+      if (formatPass !== null)
+        parts.push(formatPass);
       if (hasMinimum(schema))
         parts.push(boundPassExpr(acc, "minimum", schema.minimum, hasStrictExclusiveMinimum(schema)));
       if (hasMaximum(schema))
@@ -1266,12 +1294,12 @@ const typeDescribesEveryAcceptedValue = (schema) => {
   }
   return !IMPLICIT_OBJECT_KEYWORDS.some((keyword) => declaresKey(s, keyword));
 };
-const generateBooleanGuard = (schema, typeName, _suffix = "", unknownKeys = DEFAULT_UNKNOWN_KEYS) => {
+const generateBooleanGuard = (schema, typeName, _suffix = "", unknownKeys = DEFAULT_UNKNOWN_KEYS, formats = NO_FORMATS) => {
   const name = guardName(typeName);
   const returns = typeDescribesEveryAcceptedValue(rewriteNullable(schema)) ? `input is ${typeName}` : "boolean";
   const fallback = `export const ${name} = (input: unknown): ${returns} => ${validatorName(typeName)}(input) === true`;
   const rewritten = rewriteNullable(schema);
-  const ctx = createGuardContext(unknownKeys);
+  const ctx = createGuardContext(unknownKeys, formats);
   if (declaresObjectType(rewritten)) {
     if (!objectRootIsSelfContained(rewritten))
       return fallback;
@@ -1293,19 +1321,19 @@ const generateBooleanGuard = (schema, typeName, _suffix = "", unknownKeys = DEFA
     return fallback;
   return `export const ${name} = (input: unknown): ${returns} => ${expr}`;
 };
-const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
+const generateScalarValidator = (schema, typeName, suffix, rootSchema, formats) => {
   const vName = validatorName(typeName);
   if (!isSchemaObject(schema)) {
     if (schema === false) {
       return [
         `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
-        `  return { valid: false, errors: [{ message: ${JSON.stringify(FALSE_SCHEMA_MESSAGE)}, path: _path }] }`,
+        `  ${returnError(JSON.stringify(FALSE_SCHEMA_MESSAGE), "_path", "false schema")}`,
         `}`
       ].join("\n");
     }
     return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join("\n");
   }
-  const generalRoot = () => generateGeneralRootValidator(schema, typeName, suffix, rootSchema);
+  const generalRoot = () => generateGeneralRootValidator(schema, typeName, suffix, rootSchema, formats);
   if (hasRef(schema)) {
     if (declaresKeywordOutside(schema, ["$ref"]))
       return generalRoot();
@@ -1323,7 +1351,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  if (!(input instanceof ${instanceOf})) {`,
-      `    return { valid: false, errors: [{ message: 'must be ${instanceOf}', path: _path }] }`,
+      `    ${returnError(`'must be ${instanceOf}'`, "_path", "type", JSON.stringify({ type: instanceOf }))}`,
       `  }`,
       `  return true`,
       `}`
@@ -1336,7 +1364,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  if (typeof input !== "${primitive}") {`,
-      `    return { valid: false, errors: [{ message: 'must be ${primitive}', path: _path }] }`,
+      `    ${returnError(`'must be ${primitive}'`, "_path", "type", JSON.stringify({ type: primitive }))}`,
       `  }`,
       `  return true`,
       `}`
@@ -1350,7 +1378,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  if (${mismatch}) {`,
-      `    return { valid: false, errors: [{ message: ${msg}, path: _path }] }`,
+      `    ${returnError(msg, "_path", "const", JSON.stringify({ allowedValue: schema.const }))}`,
       `  }`,
       `  return true`,
       `}`
@@ -1363,14 +1391,14 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  if (!${enumMembershipExpr(schema.enum, "input")}) {`,
-      `    return { valid: false, errors: [{ message: ${JSON.stringify(`must be one of: ${label}`)}, path: _path }] }`,
+      `    ${returnError(JSON.stringify(`must be one of: ${label}`), "_path", "enum", JSON.stringify({ allowedValues: schema.enum }))}`,
       `  }`,
       `  return true`,
       `}`
     ].join("\n");
   }
   if (hasAllOf(schema) || hasAnyOf(schema) || hasOneOf(schema) || declaresKey(schema, "not") || declaresKey(schema, "if")) {
-    const ctx = createRootContext(rootSchema);
+    const ctx = createRootContext(rootSchema, formats);
     const checks = [];
     const rootPath = "`${_path}`";
     const rootTypeArray2 = getTypeArray(schema);
@@ -1379,7 +1407,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
       if (allWrong) {
         const label = rootTypeArray2.map((t) => typeofString(t)).join(" or ");
         checks.push(`  if (${allWrong}) {`);
-        checks.push(`    ${ctx.sink}.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${rootPath} })`);
+        checks.push(`    ${pushError(ctx.sink, JSON.stringify(`must be ${label}`), rootPath, "type", JSON.stringify({ type: schema.type }))}`);
         checks.push(`  }`);
       }
     } else if (hasType(schema)) {
@@ -1387,7 +1415,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
       const wrongType = wrongTypeCondition("input", t);
       if (wrongType) {
         checks.push(`  if (${wrongType}) {`);
-        checks.push(`    ${ctx.sink}.push({ message: 'must be ${typeofString(t)}', path: ${rootPath} })`);
+        checks.push(`    ${pushError(ctx.sink, `'must be ${typeofString(t)}'`, rootPath, "type", JSON.stringify({ type: t }))}`);
         checks.push(`  }`);
       }
     }
@@ -1404,14 +1432,14 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
   }
   const rootTypeArray = getTypeArray(schema);
   if (rootTypeArray) {
-    const ctx = createRootContext(rootSchema);
+    const ctx = createRootContext(rootSchema, formats);
     const rootPath = "`${_path}`";
     const checks = [];
     const allWrong = rootTypeArray.map((t) => wrongTypeCondition("input", t)).filter((c) => c !== "").map((c) => `(${c})`).join(" && ");
     if (allWrong) {
       const label = rootTypeArray.map((t) => typeofString(t)).join(" or ");
       checks.push(`  if (${allWrong}) {`);
-      checks.push(`    ${ctx.sink}.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${rootPath} })`);
+      checks.push(`    ${pushError(ctx.sink, JSON.stringify(`must be ${label}`), rootPath, "type", JSON.stringify({ type: schema.type }))}`);
       checks.push(`  }`);
     }
     checks.push(...generateConstraintChecks("", "input", rootPath, schema, suffix, ctx));
@@ -1435,7 +1463,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
     const t = schema.type;
     const wrongType = wrongTypeCondition("input", t);
     const typLabel = typeofString(t);
-    const rootCtx = createRootContext(rootSchema);
+    const rootCtx = createRootContext(rootSchema, formats);
     const constraintLines = generateConstraintChecks("", "_root", "`${_path}`", schema, suffix, rootCtx);
     if (!wrongType) {
       return [
@@ -1448,7 +1476,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
       return [
         `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
         `  if (${wrongType}) {`,
-        `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
+        `    ${returnError(`'must be ${typLabel}'`, "_path", "type", JSON.stringify({ type: schema.type }))}`,
         `  }`,
         `  return true`,
         `}`
@@ -1457,7 +1485,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
     return withHoisted(rootCtx.hoisted, [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  if (${wrongType}) {`,
-      `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
+      `    ${returnError(`'must be ${typLabel}'`, "_path", "type", JSON.stringify({ type: schema.type }))}`,
       `  }`,
       ...readsBinding("_root", constraintLines.join("\n")) ? [`  const _root: unknown = input`] : [],
       `  let errors: ValidationError[] | undefined`,
@@ -1466,7 +1494,7 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
       `}`
     ].join("\n"));
   }
-  const typelessCtx = createRootContext(rootSchema);
+  const typelessCtx = createRootContext(rootSchema, formats);
   const typelessChecks = generateConstraintChecks("", "input", "`${_path}`", schema, suffix, typelessCtx);
   if (typelessChecks.length === 0) {
     return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join("\n");
@@ -1479,8 +1507,8 @@ const generateScalarValidator = (schema, typeName, suffix, rootSchema) => {
     `}`
   ].join("\n"));
 };
-const generateGeneralRootValidator = (schema, typeName, suffix, rootSchema) => {
-  const ctx = createRootContext(rootSchema);
+const generateGeneralRootValidator = (schema, typeName, suffix, rootSchema, formats) => {
+  const ctx = createRootContext(rootSchema, formats);
   const checks = generateValueChecks("", "input", "`${_path}`", schema, suffix, ctx, true);
   const body = checks.join("\n");
   return withHoisted(ctx.hoisted, [
@@ -1546,18 +1574,18 @@ const rewriteNullable = (node) => {
     return { anyOf: [{ type: "null" }, out] };
   return out;
 };
-const generateValidatorFunction = (schema, typeName, suffix = "", rootSchema, unknownKeys = DEFAULT_UNKNOWN_KEYS) => {
+const generateValidatorFunction = (schema, typeName, suffix = "", rootSchema, unknownKeys = DEFAULT_UNKNOWN_KEYS, formats = NO_FORMATS) => {
   assertGeneratableRefs(schema, typeName);
   const rewritten = rewriteNullable(schema);
   const document = rootSchema ?? schema;
-  assertUnevaluatedGeneratable(rewritten, typeName, document, unevaluatedMatcher(suffix, createRootContext(document)));
+  assertUnevaluatedGeneratable(rewritten, typeName, document, unevaluatedMatcher(suffix, createRootContext(document, formats)));
   if (carriesUnevaluated(rewritten)) {
-    return generateGeneralRootValidator(rewritten, typeName, suffix, document);
+    return generateGeneralRootValidator(rewritten, typeName, suffix, document, formats);
   }
   if (declaresObjectType(rewritten) && objectRootIsSelfContained(rewritten)) {
-    return generateObjectValidator(rewritten, typeName, suffix, document, unknownKeys);
+    return generateObjectValidator(rewritten, typeName, suffix, document, unknownKeys, formats);
   }
-  return generateScalarValidator(rewritten, typeName, suffix, document);
+  return generateScalarValidator(rewritten, typeName, suffix, document, formats);
 };
 export {
   generateBooleanGuard,