@nxgt/graphql-validation 0.2.1 → 0.3.1

package/dist/chunks/{index-rbxe5m3y.js → index-xcaf9kes.js}

@@ -17,8 +17,8 @@ var __export = (target, all) => {
 import { DirectiveLocation } from "graphql";
 
 // src/rules/all.ts
-var exports_all2 = {};
-__export(exports_all2, {
+var exports_all = {};
+__export(exports_all, {
   containsRule: () => containsRule,
   endsWithRule: () => endsWithRule,
   exclusiveMaxRule: () => exclusiveMaxRule,
@@ -37,6 +37,7 @@ __export(exports_all2, {
 });
 
 // src/rules/rule.ts
+var RULE_PARAM = "nxgtConstraint";
 function defineRule(rule) {
   return rule;
 }
@@ -78,90 +79,6 @@ var exclusiveMinRule = defineRule({
   toCode: (schema, value) => `${schema}.gt(${value})`,
   owns: (issue) => issue.code === "too_small" && issue.origin === "number" && issue.inclusive === false
 });
-// src/formats/all.ts
-var exports_all = {};
-__export(exports_all, {
-  byteFormat: () => byteFormat,
-  dateFormat: () => dateFormat,
-  dateTimeFormat: () => dateTimeFormat,
-  emailFormat: () => emailFormat,
-  ipv4Format: () => ipv4Format,
-  ipv6Format: () => ipv6Format,
-  uriFormat: () => uriFormat,
-  uuidFormat: () => uuidFormat
-});
-
-// src/formats/byte.ts
-import { z } from "zod";
-
-// src/formats/format.ts
-function defineFormat(format) {
-  return format;
-}
-
-// src/formats/byte.ts
-var byteFormat = defineFormat({
-  name: "byte",
-  toZod: () => z.base64(),
-  toCode: () => "z.base64()"
-});
-// src/formats/date.ts
-import { z as z2 } from "zod";
-var dateFormat = defineFormat({
-  name: "date",
-  toZod: () => z2.iso.date(),
-  toCode: () => "z.iso.date()"
-});
-// src/formats/date-time.ts
-import { z as z3 } from "zod";
-var dateTimeFormat = defineFormat({
-  name: "date-time",
-  toZod: () => z3.iso.datetime({ offset: true }),
-  toCode: () => "z.iso.datetime({ offset: true })"
-});
-// src/formats/email.ts
-import { z as z4 } from "zod";
-var emailFormat = defineFormat({
-  name: "email",
-  toZod: () => z4.email(),
-  toCode: () => "z.email()"
-});
-// src/formats/ipv4.ts
-import { z as z5 } from "zod";
-var ipv4Format = defineFormat({
-  name: "ipv4",
-  toZod: () => z5.ipv4(),
-  toCode: () => "z.ipv4()"
-});
-// src/formats/ipv6.ts
-import { z as z6 } from "zod";
-var ipv6Format = defineFormat({
-  name: "ipv6",
-  toZod: () => z6.ipv6(),
-  toCode: () => "z.ipv6()"
-});
-// src/formats/uri.ts
-import { z as z7 } from "zod";
-var uriFormat = defineFormat({
-  name: "uri",
-  toZod: () => z7.url({ protocol: /^(https?|ftp)$/ }),
-  toCode: () => "z.url({ protocol: /^(https?|ftp)$/ })"
-});
-// src/formats/uuid.ts
-import { z as z8 } from "zod";
-var uuidFormat = defineFormat({
-  name: "uuid",
-  toZod: () => z8.uuid(),
-  toCode: () => "z.uuid()"
-});
-// src/formats/index.ts
-var formats = Object.fromEntries(Object.values(exports_all).map((format) => [format.name, format]));
-function formatNamed(name) {
-  if (Object.hasOwn(formats, name))
-    return formats[name];
-  throw new Error(`Unknown @constraint format "${name}". Known formats: ${Object.keys(formats).join(", ")}.`);
-}
-
 // src/rules/format.ts
 var NARROWING = new Set(["starts_with", "ends_with", "includes", "regex"]);
 var formatRule = defineRule({
@@ -169,9 +86,16 @@ var formatRule = defineRule({
   type: "String",
   target: "string",
   base: true,
-  toZod: (_schema, value) => formatNamed(value).toZod(),
-  toCode: (_schema, value) => formatNamed(value).toCode(),
-  owns: (issue) => issue.code === "invalid_format" && !NARROWING.has(issue.format ?? "")
+  toZod: (_schema, value, { formats }) => formats.named(value).toZod(),
+  toCode: (_schema, value, { formats, formatCode }) => {
+    const format = formats.named(value);
+    if (format.toCode)
+      return format.toCode();
+    if (formatCode)
+      return formatCode(value);
+    throw new Error(`@constraint(format: "${value}") is one of the application's formats: its source is the code generator's to write, through inputCode's format option.`);
+  },
+  owns: (issue) => issue.params?.[RULE_PARAM] === "format" || issue.code === "invalid_format" && !NARROWING.has(issue.format ?? "")
 });
 // src/rules/max.ts
 var maxRule = defineRule({
@@ -272,17 +196,20 @@ var startsWithRule = defineRule({
   owns: (issue) => issue.format === "starts_with"
 });
 // src/rules/index.ts
-var rules = Object.fromEntries(Object.values(exports_all2).map((rule) => [rule.argument, rule]));
-function applyRule(rule, schema, value) {
+var rules = Object.fromEntries(Object.values(exports_all).map((rule) => [rule.argument, rule]));
+function applyRule(rule, schema, value, context) {
   const toZod = rule.toZod;
-  return toZod(schema, value);
+  return toZod(schema, value, context);
 }
-function applyRuleCode(rule, source, value) {
+function applyRuleCode(rule, source, value, context) {
   const toCode = rule.toCode;
-  return toCode(source, value);
+  return toCode(source, value, context);
 }
 function constraintOf(issue) {
   const fields = issue;
+  const marked = fields.params?.[RULE_PARAM];
+  if (typeof marked === "string" && Object.hasOwn(rules, marked))
+    return marked;
   return Object.values(rules).find((rule) => rule.owns(fields))?.argument;
 }
 
@@ -313,7 +240,7 @@ function assertOwnConstraint(directive) {
   }
 }
 
-export { rules, applyRule, applyRuleCode, constraintOf, constraintTypeDefs2, assertOwnConstraint };
+export { __export, RULE_PARAM, rules, applyRule, applyRuleCode, constraintOf, constraintTypeDefs2, assertOwnConstraint };
 
-//# debugId=0FAF783CE1246B6764756E2164756E21
-//# sourceMappingURL=index-rbxe5m3y.js.map
+//# debugId=AD9C9BDBBBE92EA564756E2164756E21
+//# sourceMappingURL=index-xcaf9kes.js.map

package/dist/chunks/index-xcaf9kes.js.map

@@ -0,0 +1,27 @@
+{
+  "version": 3,
+  "sources": ["../src/constraint-directive.ts", "../src/rules/rule.ts", "../src/rules/contains.ts", "../src/rules/ends-with.ts", "../src/rules/exclusive-max.ts", "../src/rules/exclusive-min.ts", "../src/rules/format.ts", "../src/rules/max.ts", "../src/rules/max-items.ts", "../src/rules/max-length.ts", "../src/rules/min.ts", "../src/rules/min-items.ts", "../src/rules/min-length.ts", "../src/rules/multiple-of.ts", "../src/rules/not-contains.ts", "../src/rules/pattern.ts", "../src/rules/starts-with.ts", "../src/rules/index.ts"],
+  "sourcesContent": [
+    "import { DirectiveLocation, type GraphQLDirective } from 'graphql';\nimport { rules } from './rules';\n\n/**\n * The SDL of `@constraint`, to add to a schema-first server's `typeDefs`,\n * written from the rules: an argument is declared once its rule exists.\n *\n * Its arguments are graphql-constraint-directive's, minus `uniqueTypeName`\n * (a detail of that package's scalar wrapping). It is allowed on arguments\n * and input fields only, where that package also allows output fields: a\n * resolver's result is the output scalars' job, and a directive that checked\n * nothing there would be a promise broken in silence.\n */\nexport const constraintTypeDefs: string = `directive @constraint(\n${Object.values(rules)\n\t.map((rule) => `\\t${rule.argument}: ${rule.type}`)\n\t.join('\\n')}\n) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION\n`;\n\nconst allowed = new Set<string>([\n\tDirectiveLocation.ARGUMENT_DEFINITION,\n\tDirectiveLocation.INPUT_FIELD_DEFINITION,\n]);\n\n/**\n * Fails when the schema's `@constraint` is not the one\n * {@link constraintTypeDefs} declares — graphql-constraint-directive's, say,\n * kept from a migration. Its extra locations would be accepted and checked\n * by nothing, its extra arguments mean nothing here, and an argument of\n * another type would reach a rule as the wrong kind of value.\n */\nexport function assertOwnConstraint(directive: GraphQLDirective): void {\n\tconst problems = [\n\t\t...(directive.isRepeatable\n\t\t\t? ['repeatable, and only its first use is read']\n\t\t\t: []),\n\t\t...directive.locations\n\t\t\t.filter((location) => !allowed.has(location))\n\t\t\t.map((location) => `allowed on ${location}`),\n\t\t...directive.args.flatMap((arg) => {\n\t\t\tconst rule = (rules as Record<string, { type: string } | undefined>)[\n\t\t\t\targ.name\n\t\t\t];\n\t\t\tif (!rule) return [`declares ${arg.name}, which no rule reads`];\n\t\t\tconst type = String(arg.type);\n\t\t\treturn type === rule.type\n\t\t\t\t? []\n\t\t\t\t: [`declares ${arg.name}: ${type}, not ${rule.type}`];\n\t\t}),\n\t];\n\tif (problems.length > 0) {\n\t\tthrow new Error(\n\t\t\t`This schema's @constraint is not constraintTypeDefs': it is ${problems.join('; ')}. Declare it with constraintTypeDefs.`,\n\t\t);\n\t}\n}\n",
+    "import type { z } from 'zod';\nimport type { StringSchema } from '../formats/format';\nimport type { FormatRegistry } from '../formats/registry';\n\n/** The schema each kind of rule narrows. */\nexport interface Targets {\n\tstring: StringSchema;\n\tnumber: z.ZodNumber;\n\tlist: z.ZodArray<z.ZodType>;\n}\n\nexport type Target = keyof Targets;\n\n/**\n * What a rule may read besides its value: the formats `format` resolves\n * against, the built-in ones and the application's own, and, when writing\n * source, how to write one of the application's (`InputCodeOptions.format`).\n */\nexport interface RuleContext {\n\treadonly formats: FormatRegistry;\n\treadonly formatCode?: ((name: string) => string) | undefined;\n}\n\n/** What a `@constraint` argument's value can be. */\ninterface ValueOf {\n\tInt: number;\n\tFloat: number;\n\tString: string;\n}\n\n/**\n * One `@constraint` argument: its GraphQL type in the directive's SDL, the\n * kind of value it narrows, and the same narrowing twice — `toZod` applied to\n * a schema at startup, `toCode` written as source by a code generator. The\n * spec beside each rule proves the two accept and refuse the same values.\n *\n * A `base` rule (only `format`) replaces the schema instead of narrowing it,\n * so a builder applies it before every other rule of its target.\n */\nexport interface Rule<\n\tA extends string = string,\n\tT extends keyof ValueOf = keyof ValueOf,\n\tK extends Target = Target,\n> {\n\treadonly argument: A;\n\treadonly type: T;\n\treadonly target: K;\n\treadonly base?: true;\n\treadonly toZod: (\n\t\tschema: Targets[K],\n\t\tvalue: ValueOf[T],\n\t\tcontext: RuleContext,\n\t) => Targets[K];\n\t/**\n\t * `schema` is the source of the schema this rule narrows. The source names\n\t * zod as a free `z`: the generated file imports it.\n\t */\n\treadonly toCode: (\n\t\tschema: string,\n\t\tvalue: ValueOf[T],\n\t\tcontext: RuleContext,\n\t) => string;\n\t/**\n\t * Whether a Zod issue is this rule's refusal, so the error a client gets\n\t * names the rule (`constraint: 'minLength'`), which does not change with\n\t * Zod's own issue codes.\n\t */\n\treadonly owns: (issue: IssueFields) => boolean;\n}\n\n/** The fields of a Zod issue a rule recognises its refusal by. */\nexport interface IssueFields {\n\treadonly code: string;\n\treadonly origin?: string;\n\treadonly format?: string;\n\treadonly inclusive?: boolean;\n\treadonly params?: Readonly<Record<string, unknown>>;\n}\n\n/**\n * The `params` key that marks an issue as one argument's whatever its code:\n * an application format's issues carry `format` there, so a `.regex()` or a\n * `.refine()` inside one is not read as `pattern` or `notContains`.\n */\nexport const RULE_PARAM = 'nxgtConstraint';\n\n/** Declares a rule, with its argument name kept literal. */\nexport function defineRule<\n\tconst A extends string,\n\tT extends keyof ValueOf,\n\tK extends Target,\n>(rule: Rule<A, T, K>): Rule<A, T, K> {\n\treturn rule;\n}\n\n/** A string literal as source: quotes and escapes included. */\nexport const literal = (value: string): string => JSON.stringify(value);\n",
+    "import { defineRule, literal } from './rule';\n\nexport const containsRule = defineRule({\n\targument: 'contains',\n\ttype: 'String',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.includes(value),\n\ttoCode: (schema, value) => `${schema}.includes(${literal(value)})`,\n\towns: (issue) => issue.format === 'includes',\n});\n",
+    "import { defineRule, literal } from './rule';\n\nexport const endsWithRule = defineRule({\n\targument: 'endsWith',\n\ttype: 'String',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.endsWith(value),\n\ttoCode: (schema, value) => `${schema}.endsWith(${literal(value)})`,\n\towns: (issue) => issue.format === 'ends_with',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const exclusiveMaxRule = defineRule({\n\targument: 'exclusiveMax',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.lt(value),\n\ttoCode: (schema, value) => `${schema}.lt(${value})`,\n\towns: (issue) =>\n\t\tissue.code === 'too_big' &&\n\t\tissue.origin === 'number' &&\n\t\tissue.inclusive === false,\n});\n",
+    "import { defineRule } from './rule';\n\nexport const exclusiveMinRule = defineRule({\n\targument: 'exclusiveMin',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.gt(value),\n\ttoCode: (schema, value) => `${schema}.gt(${value})`,\n\towns: (issue) =>\n\t\tissue.code === 'too_small' &&\n\t\tissue.origin === 'number' &&\n\t\tissue.inclusive === false,\n});\n",
+    "import { defineRule, RULE_PARAM } from './rule';\n\n// The string rules' own formats; every other invalid_format is a format's.\nconst NARROWING = new Set(['starts_with', 'ends_with', 'includes', 'regex']);\n\nexport const formatRule = defineRule({\n\targument: 'format',\n\ttype: 'String',\n\ttarget: 'string',\n\tbase: true,\n\ttoZod: (_schema, value, { formats }) => formats.named(value).toZod(),\n\ttoCode: (_schema, value, { formats, formatCode }) => {\n\t\tconst format = formats.named(value);\n\t\tif (format.toCode) return format.toCode();\n\t\tif (formatCode) return formatCode(value);\n\t\tthrow new Error(\n\t\t\t`@constraint(format: \"${value}\") is one of the application's formats: its source is the code generator's to write, through inputCode's format option.`,\n\t\t);\n\t},\n\t// An application format's issues are marked, whatever their code\n\t// (`custom` for a `.refine()`): see FormatRegistry.\n\towns: (issue) =>\n\t\tissue.params?.[RULE_PARAM] === 'format' ||\n\t\t(issue.code === 'invalid_format' && !NARROWING.has(issue.format ?? '')),\n});\n",
+    "import { defineRule } from './rule';\n\nexport const maxRule = defineRule({\n\targument: 'max',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.lte(value),\n\ttoCode: (schema, value) => `${schema}.lte(${value})`,\n\towns: (issue) =>\n\t\tissue.code === 'too_big' &&\n\t\tissue.origin === 'number' &&\n\t\tissue.inclusive === true,\n});\n",
+    "import { defineRule } from './rule';\n\nexport const maxItemsRule = defineRule({\n\targument: 'maxItems',\n\ttype: 'Int',\n\ttarget: 'list',\n\ttoZod: (schema, value) => schema.max(value),\n\ttoCode: (schema, value) => `${schema}.max(${value})`,\n\towns: (issue) => issue.code === 'too_big' && issue.origin === 'array',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const maxLengthRule = defineRule({\n\targument: 'maxLength',\n\ttype: 'Int',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.max(value),\n\ttoCode: (schema, value) => `${schema}.max(${value})`,\n\towns: (issue) => issue.code === 'too_big' && issue.origin === 'string',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const minRule = defineRule({\n\targument: 'min',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.gte(value),\n\ttoCode: (schema, value) => `${schema}.gte(${value})`,\n\towns: (issue) =>\n\t\tissue.code === 'too_small' &&\n\t\tissue.origin === 'number' &&\n\t\tissue.inclusive === true,\n});\n",
+    "import { defineRule } from './rule';\n\nexport const minItemsRule = defineRule({\n\targument: 'minItems',\n\ttype: 'Int',\n\ttarget: 'list',\n\ttoZod: (schema, value) => schema.min(value),\n\ttoCode: (schema, value) => `${schema}.min(${value})`,\n\towns: (issue) => issue.code === 'too_small' && issue.origin === 'array',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const minLengthRule = defineRule({\n\targument: 'minLength',\n\ttype: 'Int',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.min(value),\n\ttoCode: (schema, value) => `${schema}.min(${value})`,\n\towns: (issue) => issue.code === 'too_small' && issue.origin === 'string',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const multipleOfRule = defineRule({\n\targument: 'multipleOf',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.multipleOf(value),\n\ttoCode: (schema, value) => `${schema}.multipleOf(${value})`,\n\towns: (issue) => issue.code === 'not_multiple_of',\n});\n",
+    "import { defineRule, literal } from './rule';\n\nconst message = (value: string) => `Must not contain ${literal(value)}`;\n\nexport const notContainsRule = defineRule({\n\targument: 'notContains',\n\ttype: 'String',\n\ttarget: 'string',\n\t// `refine` keeps the schema's own type, so later rules still chain.\n\ttoZod: (schema, value) =>\n\t\tschema.refine((input) => !input.includes(value), message(value)),\n\ttoCode: (schema, value) =>\n\t\t`${schema}.refine((input) => !input.includes(${literal(value)}), ${literal(message(value))})`,\n\towns: (issue) => issue.code === 'custom',\n});\n",
+    "import { defineRule, literal } from './rule';\n\n/** The pattern as a RegExp, or an error that names the argument. */\nfunction compile(value: string): RegExp {\n\ttry {\n\t\treturn new RegExp(value);\n\t} catch (error) {\n\t\tthrow new Error(\n\t\t\t`Invalid @constraint pattern ${literal(value)}: ${(error as Error).message}`,\n\t\t);\n\t}\n}\n\nexport const patternRule = defineRule({\n\targument: 'pattern',\n\ttype: 'String',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.regex(compile(value)),\n\ttoCode: (schema, value) =>\n\t\t`${schema}.regex(new RegExp(${literal(compile(value).source)}))`,\n\towns: (issue) => issue.format === 'regex',\n});\n",
+    "import { defineRule, literal } from './rule';\n\nexport const startsWithRule = defineRule({\n\targument: 'startsWith',\n\ttype: 'String',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.startsWith(value),\n\ttoCode: (schema, value) => `${schema}.startsWith(${literal(value)})`,\n\towns: (issue) => issue.format === 'starts_with',\n});\n",
+    "import type { z } from 'zod';\nimport * as all from './all';\nimport { type IssueFields, RULE_PARAM, type RuleContext } from './rule';\n\n/**\n * One of the rules, as its own type: a builder narrows it on `target`, so a\n * number schema never reaches a string rule.\n */\nexport type RegisteredRule = (typeof all)[keyof typeof all];\n\n/** An argument `@constraint` takes. */\nexport type ConstraintArgument = RegisteredRule['argument'];\n\n/**\n * Every rule, keyed by its `@constraint` argument. Derived from what\n * `./all` exports, so a new rule is one file and one line there, and the\n * directive's SDL follows.\n */\nexport const rules = Object.fromEntries(\n\tObject.values(all).map((rule) => [rule.argument, rule]),\n) as {\n\treadonly [A in ConstraintArgument]: Extract<RegisteredRule, { argument: A }>;\n};\n\n/**\n * Applies a rule to a schema its caller has already matched to the rule's\n * target: the one place the rule's typed `toZod` meets a schema built from\n * GraphQL types, which the compiler cannot relate.\n */\nexport function applyRule(\n\trule: RegisteredRule,\n\tschema: z.ZodType,\n\tvalue: string | number,\n\tcontext: RuleContext,\n): z.ZodType {\n\tconst toZod = rule.toZod as unknown as (\n\t\tschema: z.ZodType,\n\t\tvalue: string | number,\n\t\tcontext: RuleContext,\n\t) => z.ZodType;\n\treturn toZod(schema, value, context);\n}\n\n/** `applyRule` for source: the rule's typed `toCode` on a schema's source. */\nexport function applyRuleCode(\n\trule: RegisteredRule,\n\tsource: string,\n\tvalue: string | number,\n\tcontext: RuleContext,\n): string {\n\tconst toCode = rule.toCode as (\n\t\tschema: string,\n\t\tvalue: string | number,\n\t\tcontext: RuleContext,\n\t) => string;\n\treturn toCode(source, value, context);\n}\n\n/**\n * The `@constraint` argument whose rule refused with this issue, if any: the\n * one the issue is marked with (an application format's), else the one rule\n * that owns its shape.\n */\nexport function constraintOf(\n\tissue: z.core.$ZodIssue,\n): ConstraintArgument | undefined {\n\tconst fields = issue as unknown as IssueFields;\n\tconst marked = fields.params?.[RULE_PARAM];\n\tif (typeof marked === 'string' && Object.hasOwn(rules, marked))\n\t\treturn marked as ConstraintArgument;\n\treturn Object.values(rules).find((rule) => rule.owns(fields))?.argument;\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "AD9C9BDBBBE92EA564756E2164756E21",
+  "names": []
+}

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   constraintTypeDefs2
-} from "./chunks/index-rbxe5m3y.js";
+} from "./chunks/index-xcaf9kes.js";
 
 // src/typedefs-command.ts
 import { mkdir, writeFile } from "node:fs/promises";

package/dist/codegen.d.ts

@@ -1,4 +1,5 @@
 export { checkConstraints } from './builder/check-constraints.js';
 export { type Constraint, constraintsOn } from './builder/constraints.js';
 export { type InputCodeOptions, inputCode } from './builder/input-code.js';
+export type { FormatSchemas } from './formats/registry.js';
 //# sourceMappingURL=codegen.d.ts.map

package/dist/codegen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../src/codegen.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,KAAK,UAAU,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../src/codegen.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,KAAK,UAAU,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACxE,YAAY,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/codegen.js

@@ -1,13 +1,14 @@
 import {
   applyRuleCode
-} from "./chunks/index-rbxe5m3y.js";
+} from "./chunks/index-xcaf9kes.js";
 import {
+  registryOf,
   constraintsOn2,
   assertLeafTargets,
   assertObjectTargets,
   baseCode,
   checkConstraints2
-} from "./chunks/index-s1kkmg35.js";
+} from "./chunks/index-twevz7yc.js";
 // src/builder/input-code.ts
 import {
   getNamedType,
@@ -15,8 +16,13 @@ import {
   isListType,
   isNonNullType
 } from "graphql";
-function inputCode(type, constraints, where, named, options = {}) {
-  const write = { where, named, options };
+function inputCode(type, constraints, where, named, options = {}, formats) {
+  const write = {
+    where,
+    named,
+    options,
+    formats: registryOf(formats)
+  };
   return typedCode(write, type, constraints);
 }
 function typedCode(write, type, constraints) {
@@ -30,7 +36,7 @@ function requiredCode(write, type, constraints) {
   if (isListType(type)) {
     const own = constraints.filter(({ rule }) => rule.target === "list");
     const items = constraints.filter(({ rule }) => rule.target !== "list");
-    const code = applyCode(`z.array(${typedCode(write, type.ofType, items)})`, own);
+    const code = applyCode(write, `z.array(${typedCode(write, type.ofType, items)})`, own);
     if (!write.options.list)
       return code;
     const single = requiredCode(write, getNamedType(type), []);
@@ -41,10 +47,14 @@ function requiredCode(write, type, constraints) {
     return write.named(type);
   }
   assertLeafTargets(type, constraints, write.where);
-  return applyCode(baseCode(type) ?? write.named(type), constraints);
+  return applyCode(write, baseCode(type) ?? write.named(type), constraints);
 }
-function applyCode(source, constraints) {
-  return constraints.reduce((code, { rule, value }) => applyRuleCode(rule, code, value), source);
+function applyCode(write, source, constraints) {
+  const context = {
+    formats: write.formats,
+    formatCode: write.options.format
+  };
+  return constraints.reduce((code, { rule, value }) => applyRuleCode(rule, code, value, context), source);
 }
 export {
   checkConstraints2 as checkConstraints,
@@ -52,5 +62,5 @@ export {
   inputCode
 };
 
-//# debugId=CF7DECB6FA09613D64756E2164756E21
+//# debugId=95B0758BEEE7072864756E2164756E21
 //# sourceMappingURL=codegen.js.map

package/dist/codegen.js.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../src/builder/input-code.ts"],
   "sourcesContent": [
-    "import {\n\ttype GraphQLInputType,\n\ttype GraphQLList,\n\ttype GraphQLNamedInputType,\n\tgetNamedType,\n\tisInputObjectType,\n\tisListType,\n\tisNonNullType,\n} from 'graphql';\nimport { applyRuleCode } from '../rules';\nimport type { Constraint } from './constraints';\nimport { assertLeafTargets, assertObjectTargets, baseCode } from './leaf';\n\n/**\n * The source of the schema of one argument or input field: what\n * `InputSchemas` builds at startup, written for a code generator. The\n * source names zod as a free `z`.\n *\n * The runtime leaves what graphql already checked to graphql; generated\n * code checks every value, so each named type comes from `named`: an input\n * object's or an enum's schema by name, a custom scalar's from a mapping.\n * The built-in scalars are written here, with their constraints. A\n * constraint that cannot apply fails as it does at startup.\n */\nexport function inputCode(\n\ttype: GraphQLInputType,\n\tconstraints: readonly Constraint[],\n\twhere: string,\n\tnamed: (type: GraphQLNamedInputType) => string,\n\toptions: InputCodeOptions = {},\n): string {\n\tconst write: Write = { where, named, options };\n\treturn typedCode(write, type, constraints);\n}\n\n/** How `inputCode` writes what a generator may want written otherwise. */\nexport interface InputCodeOptions {\n\t/**\n\t * A list's schema, given its `type`, `code` (the array with every rule)\n\t * and `single` (the list's named type, non-null, without rules): to\n\t * take a single value for a list, as graphql does, `single` wrapped then\n\t * piped into `code`. Default: `code`.\n\t */\n\treadonly list?: (list: {\n\t\treadonly type: GraphQLList<GraphQLInputType>;\n\t\treadonly code: string;\n\t\treadonly single: string;\n\t}) => string;\n}\n\ninterface Write {\n\treadonly where: string;\n\treadonly named: (type: GraphQLNamedInputType) => string;\n\treadonly options: InputCodeOptions;\n}\n\nfunction typedCode(\n\twrite: Write,\n\ttype: GraphQLInputType,\n\tconstraints: readonly Constraint[],\n): string {\n\tif (isNonNullType(type)) return requiredCode(write, type.ofType, constraints);\n\treturn `${requiredCode(write, type, constraints)}.nullish()`;\n}\n\nfunction requiredCode(\n\twrite: Write,\n\ttype: GraphQLInputType,\n\tconstraints: readonly Constraint[],\n): string {\n\tif (isNonNullType(type)) return requiredCode(write, type.ofType, constraints);\n\tif (isListType(type)) {\n\t\t// minItems and maxItems are the list's; every other rule is its items'.\n\t\tconst own = constraints.filter(({ rule }) => rule.target === 'list');\n\t\tconst items = constraints.filter(({ rule }) => rule.target !== 'list');\n\t\tconst code = applyCode(\n\t\t\t`z.array(${typedCode(write, type.ofType, items)})`,\n\t\t\town,\n\t\t);\n\t\tif (!write.options.list) return code;\n\t\tconst single = requiredCode(write, getNamedType(type), []);\n\t\treturn write.options.list({ type, code, single });\n\t}\n\tif (isInputObjectType(type)) {\n\t\tassertObjectTargets(type.name, constraints, write.where);\n\t\treturn write.named(type);\n\t}\n\tassertLeafTargets(type, constraints, write.where);\n\treturn applyCode(baseCode(type) ?? write.named(type), constraints);\n}\n\nfunction applyCode(source: string, constraints: readonly Constraint[]): string {\n\treturn constraints.reduce(\n\t\t(code, { rule, value }) => applyRuleCode(rule, code, value),\n\t\tsource,\n\t);\n}\n"
+    "import {\n\ttype GraphQLInputType,\n\ttype GraphQLList,\n\ttype GraphQLNamedInputType,\n\tgetNamedType,\n\tisInputObjectType,\n\tisListType,\n\tisNonNullType,\n} from 'graphql';\nimport {\n\ttype FormatRegistry,\n\ttype FormatSchemas,\n\tregistryOf,\n} from '../formats/registry';\nimport { applyRuleCode } from '../rules';\nimport type { Constraint } from './constraints';\nimport { assertLeafTargets, assertObjectTargets, baseCode } from './leaf';\n\n/**\n * The source of the schema of one argument or input field: what\n * `InputSchemas` builds at startup, written for a code generator. The\n * source names zod as a free `z`.\n *\n * The runtime leaves what graphql already checked to graphql; generated\n * code checks every value, so each named type comes from `named`: an input\n * object's or an enum's schema by name, a custom scalar's from a mapping.\n * The built-in scalars are written here, with their constraints. A\n * constraint that cannot apply fails as it does at startup.\n *\n * `formats` are the application's own, as `withValidation` takes them: a\n * name among them is a known format, which a built-in one is not. Their\n * source is `options.format`'s to write.\n */\nexport function inputCode(\n\ttype: GraphQLInputType,\n\tconstraints: readonly Constraint[],\n\twhere: string,\n\tnamed: (type: GraphQLNamedInputType) => string,\n\toptions: InputCodeOptions = {},\n\tformats?: FormatSchemas,\n): string {\n\tconst write: Write = {\n\t\twhere,\n\t\tnamed,\n\t\toptions,\n\t\tformats: registryOf(formats),\n\t};\n\treturn typedCode(write, type, constraints);\n}\n\n/** How `inputCode` writes what a generator may want written otherwise. */\nexport interface InputCodeOptions {\n\t/**\n\t * A list's schema, given its `type`, `code` (the array with every rule)\n\t * and `single` (the list's named type, non-null, without rules): to\n\t * take a single value for a list, as graphql does, `single` wrapped then\n\t * piped into `code`. Default: `code`.\n\t */\n\treadonly list?: (list: {\n\t\treadonly type: GraphQLList<GraphQLInputType>;\n\t\treadonly code: string;\n\t\treadonly single: string;\n\t}) => string;\n\t/**\n\t * The source of one of the application's formats, given its name (a key\n\t * of the `formats` record): a reference to the application's own schema,\n\t * which the rules after `format` narrow (`formatSchemas.slug.max(40)`).\n\t * A built-in format is written inline and never reaches it. Without it,\n\t * a field using one of the application's formats throws.\n\t */\n\treadonly format?: (name: string) => string;\n}\n\ninterface Write {\n\treadonly where: string;\n\treadonly named: (type: GraphQLNamedInputType) => string;\n\treadonly options: InputCodeOptions;\n\treadonly formats: FormatRegistry;\n}\n\nfunction typedCode(\n\twrite: Write,\n\ttype: GraphQLInputType,\n\tconstraints: readonly Constraint[],\n): string {\n\tif (isNonNullType(type)) return requiredCode(write, type.ofType, constraints);\n\treturn `${requiredCode(write, type, constraints)}.nullish()`;\n}\n\nfunction requiredCode(\n\twrite: Write,\n\ttype: GraphQLInputType,\n\tconstraints: readonly Constraint[],\n): string {\n\tif (isNonNullType(type)) return requiredCode(write, type.ofType, constraints);\n\tif (isListType(type)) {\n\t\t// minItems and maxItems are the list's; every other rule is its items'.\n\t\tconst own = constraints.filter(({ rule }) => rule.target === 'list');\n\t\tconst items = constraints.filter(({ rule }) => rule.target !== 'list');\n\t\tconst code = applyCode(\n\t\t\twrite,\n\t\t\t`z.array(${typedCode(write, type.ofType, items)})`,\n\t\t\town,\n\t\t);\n\t\tif (!write.options.list) return code;\n\t\tconst single = requiredCode(write, getNamedType(type), []);\n\t\treturn write.options.list({ type, code, single });\n\t}\n\tif (isInputObjectType(type)) {\n\t\tassertObjectTargets(type.name, constraints, write.where);\n\t\treturn write.named(type);\n\t}\n\tassertLeafTargets(type, constraints, write.where);\n\treturn applyCode(write, baseCode(type) ?? write.named(type), constraints);\n}\n\nfunction applyCode(\n\twrite: Write,\n\tsource: string,\n\tconstraints: readonly Constraint[],\n): string {\n\tconst context = {\n\t\tformats: write.formats,\n\t\tformatCode: write.options.format,\n\t};\n\treturn constraints.reduce(\n\t\t(code, { rule, value }) => applyRuleCode(rule, code, value, context),\n\t\tsource,\n\t);\n}\n"
   ],
-  "mappings": ";;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBO,SAAS,SAAS,CACxB,MACA,aACA,OACA,OACA,UAA4B,CAAC,GACpB;AAAA,EACT,MAAM,QAAe,EAAE,OAAO,OAAO,QAAQ;AAAA,EAC7C,OAAO,UAAU,OAAO,MAAM,WAAW;AAAA;AAwB1C,SAAS,SAAS,CACjB,OACA,MACA,aACS;AAAA,EACT,IAAI,cAAc,IAAI;AAAA,IAAG,OAAO,aAAa,OAAO,KAAK,QAAQ,WAAW;AAAA,EAC5E,OAAO,GAAG,aAAa,OAAO,MAAM,WAAW;AAAA;AAGhD,SAAS,YAAY,CACpB,OACA,MACA,aACS;AAAA,EACT,IAAI,cAAc,IAAI;AAAA,IAAG,OAAO,aAAa,OAAO,KAAK,QAAQ,WAAW;AAAA,EAC5E,IAAI,WAAW,IAAI,GAAG;AAAA,IAErB,MAAM,MAAM,YAAY,OAAO,GAAG,WAAW,KAAK,WAAW,MAAM;AAAA,IACnE,MAAM,QAAQ,YAAY,OAAO,GAAG,WAAW,KAAK,WAAW,MAAM;AAAA,IACrE,MAAM,OAAO,UACZ,WAAW,UAAU,OAAO,KAAK,QAAQ,KAAK,MAC9C,GACD;AAAA,IACA,IAAI,CAAC,MAAM,QAAQ;AAAA,MAAM,OAAO;AAAA,IAChC,MAAM,SAAS,aAAa,OAAO,aAAa,IAAI,GAAG,CAAC,CAAC;AAAA,IACzD,OAAO,MAAM,QAAQ,KAAK,EAAE,MAAM,MAAM,OAAO,CAAC;AAAA,EACjD;AAAA,EACA,IAAI,kBAAkB,IAAI,GAAG;AAAA,IAC5B,oBAAoB,KAAK,MAAM,aAAa,MAAM,KAAK;AAAA,IACvD,OAAO,MAAM,MAAM,IAAI;AAAA,EACxB;AAAA,EACA,kBAAkB,MAAM,aAAa,MAAM,KAAK;AAAA,EAChD,OAAO,UAAU,SAAS,IAAI,KAAK,MAAM,MAAM,IAAI,GAAG,WAAW;AAAA;AAGlE,SAAS,SAAS,CAAC,QAAgB,aAA4C;AAAA,EAC9E,OAAO,YAAY,OAClB,CAAC,QAAQ,MAAM,YAAY,cAAc,MAAM,MAAM,KAAK,GAC1D,MACD;AAAA;",
-  "debugId": "CF7DECB6FA09613D64756E2164756E21",
+  "mappings": ";;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCO,SAAS,SAAS,CACxB,MACA,aACA,OACA,OACA,UAA4B,CAAC,GAC7B,SACS;AAAA,EACT,MAAM,QAAe;AAAA,IACpB;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS,WAAW,OAAO;AAAA,EAC5B;AAAA,EACA,OAAO,UAAU,OAAO,MAAM,WAAW;AAAA;AAiC1C,SAAS,SAAS,CACjB,OACA,MACA,aACS;AAAA,EACT,IAAI,cAAc,IAAI;AAAA,IAAG,OAAO,aAAa,OAAO,KAAK,QAAQ,WAAW;AAAA,EAC5E,OAAO,GAAG,aAAa,OAAO,MAAM,WAAW;AAAA;AAGhD,SAAS,YAAY,CACpB,OACA,MACA,aACS;AAAA,EACT,IAAI,cAAc,IAAI;AAAA,IAAG,OAAO,aAAa,OAAO,KAAK,QAAQ,WAAW;AAAA,EAC5E,IAAI,WAAW,IAAI,GAAG;AAAA,IAErB,MAAM,MAAM,YAAY,OAAO,GAAG,WAAW,KAAK,WAAW,MAAM;AAAA,IACnE,MAAM,QAAQ,YAAY,OAAO,GAAG,WAAW,KAAK,WAAW,MAAM;AAAA,IACrE,MAAM,OAAO,UACZ,OACA,WAAW,UAAU,OAAO,KAAK,QAAQ,KAAK,MAC9C,GACD;AAAA,IACA,IAAI,CAAC,MAAM,QAAQ;AAAA,MAAM,OAAO;AAAA,IAChC,MAAM,SAAS,aAAa,OAAO,aAAa,IAAI,GAAG,CAAC,CAAC;AAAA,IACzD,OAAO,MAAM,QAAQ,KAAK,EAAE,MAAM,MAAM,OAAO,CAAC;AAAA,EACjD;AAAA,EACA,IAAI,kBAAkB,IAAI,GAAG;AAAA,IAC5B,oBAAoB,KAAK,MAAM,aAAa,MAAM,KAAK;AAAA,IACvD,OAAO,MAAM,MAAM,IAAI;AAAA,EACxB;AAAA,EACA,kBAAkB,MAAM,aAAa,MAAM,KAAK;AAAA,EAChD,OAAO,UAAU,OAAO,SAAS,IAAI,KAAK,MAAM,MAAM,IAAI,GAAG,WAAW;AAAA;AAGzE,SAAS,SAAS,CACjB,OACA,QACA,aACS;AAAA,EACT,MAAM,UAAU;AAAA,IACf,SAAS,MAAM;AAAA,IACf,YAAY,MAAM,QAAQ;AAAA,EAC3B;AAAA,EACA,OAAO,YAAY,OAClB,CAAC,QAAQ,MAAM,YAAY,cAAc,MAAM,MAAM,OAAO,OAAO,GACnE,MACD;AAAA;",
+  "debugId": "95B0758BEEE7072864756E2164756E21",
   "names": []
 }

package/dist/formats/byte.d.ts

@@ -1,2 +1,2 @@
-export declare const byteFormat: import("./format.js").Format<"byte">;
+export declare const byteFormat: import("./format.js").BuiltInFormat<"byte">;
 //# sourceMappingURL=byte.d.ts.map

package/dist/formats/byte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"byte.d.ts","sourceRoot":"","sources":["../../src/formats/byte.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,mCAIrB,CAAC"}
+{"version":3,"file":"byte.d.ts","sourceRoot":"","sources":["../../src/formats/byte.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,0CAIrB,CAAC"}

package/dist/formats/date-time.d.ts

@@ -1,2 +1,2 @@
-export declare const dateTimeFormat: import("./format.js").Format<"date-time">;
+export declare const dateTimeFormat: import("./format.js").BuiltInFormat<"date-time">;
 //# sourceMappingURL=date-time.d.ts.map

package/dist/formats/date-time.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"date-time.d.ts","sourceRoot":"","sources":["../../src/formats/date-time.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,wCAIzB,CAAC"}
+{"version":3,"file":"date-time.d.ts","sourceRoot":"","sources":["../../src/formats/date-time.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,+CAIzB,CAAC"}

package/dist/formats/date.d.ts

@@ -1,2 +1,2 @@
-export declare const dateFormat: import("./format.js").Format<"date">;
+export declare const dateFormat: import("./format.js").BuiltInFormat<"date">;
 //# sourceMappingURL=date.d.ts.map

package/dist/formats/date.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../src/formats/date.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,mCAIrB,CAAC"}
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../src/formats/date.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,0CAIrB,CAAC"}

package/dist/formats/email.d.ts

@@ -1,2 +1,2 @@
-export declare const emailFormat: import("./format.js").Format<"email">;
+export declare const emailFormat: import("./format.js").BuiltInFormat<"email">;
 //# sourceMappingURL=email.d.ts.map

package/dist/formats/email.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"email.d.ts","sourceRoot":"","sources":["../../src/formats/email.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,oCAItB,CAAC"}
+{"version":3,"file":"email.d.ts","sourceRoot":"","sources":["../../src/formats/email.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW,2CAItB,CAAC"}

package/dist/formats/format.d.ts

@@ -1,15 +1,29 @@
 import type { z } from 'zod';
+import type { Narrow } from './marked.js';
 /** A string schema, plain or a format (`z.email()` is not a `z.ZodString`). */
 export type StringSchema = z.ZodString | z.ZodStringFormat;
 /**
  * One value of `@constraint(format: "...")`: the schema it stands for, as a
- * schema at startup and as source for a code generator.
+ * schema at startup and, for a built-in one, as source for a code generator.
+ * A format of the application's own has no `toCode`: the generator writes a
+ * reference to the application's schema instead.
  */
 export interface Format<N extends string = string> {
     readonly name: N;
     readonly toZod: () => StringSchema;
+    readonly toCode?: () => string;
+    /**
+     * An application's format, narrowed by the rules written after it
+     * (`leafSchema` hands them): they run inside it, after its checks, so
+     * they see its abort even once it went async. A built-in format has none:
+     * the rules are chained on `toZod()`.
+     */
+    readonly narrowed?: (narrow: Narrow) => StringSchema;
+}
+/** A format this package ships: written twice, as a schema and as source. */
+export interface BuiltInFormat<N extends string = string> extends Format<N> {
     readonly toCode: () => string;
 }
-/** Declares a format, with its name kept literal. */
-export declare function defineFormat<const N extends string>(format: Format<N>): Format<N>;
+/** Declares a built-in format, with its name kept literal. */
+export declare function defineFormat<const N extends string>(format: BuiltInFormat<N>): BuiltInFormat<N>;
 //# sourceMappingURL=format.d.ts.map

package/dist/formats/format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/formats/format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,+EAA+E;AAC/E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,eAAe,CAAC;AAE3D;;;GAGG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAChD,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,KAAK,EAAE,MAAM,YAAY,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC;CAC9B;AAED,qDAAqD;AACrD,wBAAgB,YAAY,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAClD,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GACf,MAAM,CAAC,CAAC,CAAC,CAEX"}
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/formats/format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,+EAA+E;AAC/E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,eAAe,CAAC;AAE3D;;;;;GAKG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAChD,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,KAAK,EAAE,MAAM,YAAY,CAAC;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,YAAY,CAAC;CACrD;AAED,6EAA6E;AAC7E,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,MAAM,CAAC;CAC9B;AAED,8DAA8D;AAC9D,wBAAgB,YAAY,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAClD,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,GACtB,aAAa,CAAC,CAAC,CAAC,CAElB"}

package/dist/formats/index.d.ts

@@ -1,13 +1,11 @@
 import * as all from './all.js';
-import type { Format } from './format.js';
+import type { BuiltInFormat } from './format.js';
 /**
- * Every format, keyed by the value `@constraint(format: "...")` takes.
- * Derived from what `./all` exports, so a new format is one file and one
- * line there.
+ * Every built-in format, keyed by the value `@constraint(format: "...")`
+ * takes. Derived from what `./all` exports, so a new format is one file and
+ * one line there.
  */
-export declare const formats: { readonly [N in FormatName]: Format<N>; };
-/** A value `@constraint(format: "...")` takes. */
+export declare const formats: { readonly [N in FormatName]: BuiltInFormat<N>; };
+/** A value `@constraint(format: "...")` takes without the application's formats. */
 export type FormatName = (typeof all)[keyof typeof all]['name'];
-/** The format named `name`, or an error that lists the known ones. */
-export declare function formatNamed(name: string): Format;
 //# sourceMappingURL=index.d.ts.map

package/dist/formats/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/formats/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAC7B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;;GAIG;AACH,eAAO,MAAM,OAAO,EAEf,EAAE,QAAQ,EAAE,CAAC,IAAI,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,GAAE,CAAC;AAE/C,kDAAkD;AAClD,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhE,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKhD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/formats/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAC7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;GAIG;AACH,eAAO,MAAM,OAAO,EAEf,EAAE,QAAQ,EAAE,CAAC,IAAI,UAAU,GAAG,aAAa,CAAC,CAAC,CAAC,GAAE,CAAC;AAEtD,oFAAoF;AACpF,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/formats/ipv4.d.ts

@@ -1,2 +1,2 @@
-export declare const ipv4Format: import("./format.js").Format<"ipv4">;
+export declare const ipv4Format: import("./format.js").BuiltInFormat<"ipv4">;
 //# sourceMappingURL=ipv4.d.ts.map

package/dist/formats/ipv4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ipv4.d.ts","sourceRoot":"","sources":["../../src/formats/ipv4.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,mCAIrB,CAAC"}
+{"version":3,"file":"ipv4.d.ts","sourceRoot":"","sources":["../../src/formats/ipv4.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,0CAIrB,CAAC"}

package/dist/formats/ipv6.d.ts

@@ -1,2 +1,2 @@
-export declare const ipv6Format: import("./format.js").Format<"ipv6">;
+export declare const ipv6Format: import("./format.js").BuiltInFormat<"ipv6">;
 //# sourceMappingURL=ipv6.d.ts.map

package/dist/formats/ipv6.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ipv6.d.ts","sourceRoot":"","sources":["../../src/formats/ipv6.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,mCAIrB,CAAC"}
+{"version":3,"file":"ipv6.d.ts","sourceRoot":"","sources":["../../src/formats/ipv6.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,0CAIrB,CAAC"}

package/dist/formats/marked.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { StringSchema } from './format.js';
+/** The rules written after a format, applied to the schema they narrow. */
+export type Narrow = (schema: StringSchema) => z.ZodType;
+/**
+ * The application's schema as a plain string schema, narrowed by the rules
+ * written after it (`narrow`), each of its issues re-raised as it was (code,
+ * message, and an abort that stops those rules) and marked as the format's:
+ * a `.regex()` inside it is the format's refusal, not `pattern`'s. The value
+ * is checked, never changed: a schema that still returns another value (a
+ * custom `.check()` setting `payload.value`, which `rewrites` cannot see)
+ * throws, naming the format, as a resolver's bug would.
+ *
+ * Only zod's public API runs the schema, whatever zod 4 copy it comes from:
+ * `safeParseAsync`, `check` pushing to `ctx.issues`, `refine` (with
+ * `when`), `catch`, and the issues they return. A zod release that changes
+ * its internals changes nothing here.
+ *
+ * - **Once per value, never a dropped promise.** The schema runs through
+ *   `safeParseAsync` only, never a synchronous `safeParse` that would start
+ *   an async check and drop its promise. A `.catch()` and a `.refine()`
+ *   chained last tell, as soon as the call returns, whether the run
+ *   finished synchronously (zod runs a schema's checks within the call
+ *   until one returns a promise): then its result is used at once, so a
+ *   synchronous parse (a default value's check at startup) still works.
+ *   Otherwise the promise is returned to the enclosing parse, with a
+ *   handler, and `onAsync` is told: a synchronous parse throws zod's async
+ *   error and `checkDefaults` names the format.
+ * - **An abort** is read from two refinements chained after the schema's
+ *   checks: a plain one, which zod skips after any issue that does not
+ *   continue (`abort: true`, an issue a `.check()` pushed with no
+ *   `continue`), and one with a `when`, skipped only after `continue:
+ *   false`. Each marks a refused run's issues when it ran. The issues are
+ *   then replayed, with that same `continue`, through a `z.string()`
+ *   narrowed by the rules, so zod itself decides which rules run, as it does
+ *   on the client where they are chained on the schema.
+ * - **Once async**, zod on the client runs the rules before the async
+ *   check's issues arrive, whatever its abort: the rules run here too, and
+ *   the format's issues come first.
+ */
+export declare function marked(name: string, schema: StringSchema, onAsync: () => void): (narrow: Narrow) => StringSchema;
+//# sourceMappingURL=marked.d.ts.map

package/dist/formats/marked.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marked.d.ts","sourceRoot":"","sources":["../../src/formats/marked.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,2EAA2E;AAC3E,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,YAAY,KAAK,CAAC,CAAC,OAAO,CAAC;AAUzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,MAAM,CACrB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,MAAM,IAAI,GACjB,CAAC,MAAM,EAAE,MAAM,KAAK,YAAY,CA4ElC"}

package/dist/formats/registry.d.ts

@@ -0,0 +1,50 @@
+import type { Format, StringSchema } from './format.js';
+import { type FormatName } from './index.js';
+/**
+ * The application's own formats, keyed by the name `@constraint(format:
+ * "...")` gives them: each a Zod string schema, `z.string()` or a string
+ * format (`z.email()`), narrowed (`.regex()`, `.refine()`) but never
+ * transformed nor rewritten (`.trim()`, `.toLowerCase()`, `z.url()`,
+ * `z.coerce.string()`), so the resolver receives what was sent.
+ */
+export type FormatSchemas = {
+    readonly [name: string]: StringSchema;
+};
+/**
+ * `F` with every key that names a built-in format typed `never`, so
+ * replacing one is a type error before it is a startup error. The keys are
+ * optional: a record typed wider than its literal (`FormatSchemas`,
+ * `Record<string, z.ZodString>`) may hold none of them, and passes.
+ */
+export type OwnFormats<F extends FormatSchemas> = F & {
+    readonly [K in keyof F & FormatName]?: never;
+};
+/**
+ * Every format `@constraint(format: "...")` can name: the built-in ones,
+ * then the application's own. A lookup is one `Map` read, however many
+ * formats there are.
+ */
+export declare class FormatRegistry {
+    #private;
+    /**
+     * Fails, naming the format, on a bad name, a built-in's name, a schema
+     * that is not a string's, one zod cannot run, or one that rewrites the
+     * value.
+     */
+    constructor(own?: FormatSchemas);
+    /** The format named `name`, or an error that lists the known ones. */
+    named(name: string): Format;
+    /**
+     * The format of the application that last went async, then forgotten: read
+     * right after a synchronous parse threw zod's `$ZodAsyncError`, it names the
+     * format that made it throw (zod stops at the first check that returns a
+     * promise, and only an application's format can).
+     */
+    takeAsync(): string | undefined;
+}
+/**
+ * The registry of a set of formats, built (and checked) once per record: a
+ * code generator hands the same record for every field.
+ */
+export declare function registryOf(own?: FormatSchemas): FormatRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/formats/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/formats/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,EAAuB,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAG/D;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG;IAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,aAAa,IAAI,CAAC,GAAG;IACrD,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,KAAK;CAC5C,CAAC;AAIF;;;;GAIG;AACH,qBAAa,cAAc;;IAI1B;;;;OAIG;gBACS,GAAG,GAAE,aAAkB;IAqCnC,sEAAsE;IACtE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAQ3B;;;;;OAKG;IACH,SAAS,IAAI,MAAM,GAAG,SAAS;CAK/B;AA6DD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,CAAC,EAAE,aAAa,GAAG,cAAc,CAQ9D"}

package/dist/formats/uri.d.ts

@@ -1,2 +1,2 @@
-export declare const uriFormat: import("./format.js").Format<"uri">;
+export declare const uriFormat: import("./format.js").BuiltInFormat<"uri">;
 //# sourceMappingURL=uri.d.ts.map

package/dist/formats/uri.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uri.d.ts","sourceRoot":"","sources":["../../src/formats/uri.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,SAAS,kCAIpB,CAAC"}
+{"version":3,"file":"uri.d.ts","sourceRoot":"","sources":["../../src/formats/uri.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,SAAS,yCAIpB,CAAC"}

package/dist/formats/uuid.d.ts

@@ -1,2 +1,2 @@
-export declare const uuidFormat: import("./format.js").Format<"uuid">;
+export declare const uuidFormat: import("./format.js").BuiltInFormat<"uuid">;
 //# sourceMappingURL=uuid.d.ts.map

package/dist/formats/uuid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../../src/formats/uuid.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,mCAIrB,CAAC"}
+{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../../src/formats/uuid.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,0CAIrB,CAAC"}