@maroonedog/luq 2.5.0 → 2.6.0

package/README.md

@@ -42,6 +42,7 @@ compile error, not a rule that quietly never fires.
 | Descending into a built-in (`"when.getTime"` on a `Date`) | compile error |
 | A method that does not exist inside an element sub-chain | compile error |
 | A JSON Schema keyword bound to a chain method that does not exist | compile error |
+| A JSON Schema document declaring 2019-09 or 2020-12 | throws when the validator is built, rather than being read as Draft-07 |
 | A documented example drifting from the API | fails CI |
 
 That matters most when the code calling this library is generated rather than
@@ -136,13 +137,24 @@ const result = orderValidator.validate({ reference: "ab", quantity: 0 });
 if (!result.valid) {
   for (const issue of result.issues) {
     // issue.path  "reference"   — where, with array indices filled in
-    // issue.code  "stringMin"   — which rule, stable across messages
+    // issue.code  "stringMin"   — which rule; the vocabulary is pinned
     // issue.message             — the text, overridable per call
     // issue.severity "error"    — only "error" makes the value invalid
   }
 }
 ```
 
+`issue.code` is the machine-readable half: a plugin's own name by default,
+overridden per rule with `{ code }`. The set is not a convention. The codes the
+library reports are enumerated in `config/issue-code.lock.json`, derived from
+the source by `npm run generate:issue-codes` and checked by
+`npm run check:issue-code-lock`, so renaming one is a diff in a committed file
+and a deliberate act rather than a silent break. The lock records who reports
+each code, because some codes are shared on purpose — a missing root and a
+missing field both report `required`. Codes a gate carries (`skip`,
+`validateIf`) sit in a separate list: they are accepted from a caller but no
+issue can ever carry one.
+
 `.v(path, chain)` declares rules for one field. A path you do not declare is
 not validated, not required and not read, so covering a type partly is a normal
 state rather than a half-finished one.
@@ -295,7 +307,7 @@ const forStringMin = PLUGIN_MANIFEST.filter((entry) =>
 | [Getting started](https://luq.dev/docs/getting-started) | the builder, defaults, `normalize`, reading a result |
 | [Core concepts](https://luq.dev/docs/core-concepts) | field paths, slots, presence, transforms |
 | [Plugins](https://luq.dev/plugins) | every subpath, symbol, chain method and slot |
-| [JSON Schema](https://luq.dev/json-schema) | reading a document in, writing one back out, measured Draft-07 conformance |
+| [JSON Schema](https://luq.dev/json-schema) | reading a Draft-07 document in, writing one back out, measured conformance, and why a newer-dialect document is refused |
 | [Standard Schema](https://luq.dev/standard-schema) | tRPC, TanStack Form, Hono, react-hook-form — and what does not cross that boundary |
 | [Benchmarks](https://luq.dev/benchmarks) | bundle size and throughput, with the method |
 | [Luq or zod?](https://luq.dev/luq-or-zod) | when schema-first is the better answer |
@@ -311,6 +323,8 @@ Breaking changes happen in a major and nowhere else, an API being removed is
 deprecated one major ahead, and each major ships with the codemod needed to
 cross it.
 
+- **[CHANGELOG.md](https://github.com/maroonedog/luq/blob/master/CHANGELOG.md)** — every released version, what a caller
+  sees change in each, and which ones need reading before you take them
 - **[CONTRIBUTING.md](https://github.com/maroonedog/luq/blob/master/CONTRIBUTING.md)** — `npm run verify` is the whole
   contract; the gates and what each one refuses
 - **[SECURITY.md](https://github.com/maroonedog/luq/blob/master/SECURITY.md)** — reporting, zero runtime dependencies, the
@@ -320,11 +334,13 @@ cross it.
 
 ## About the "universal platform" goal
 
-1.x described a `.luq` DSL that would generate validators for other languages,
-against dated milestones. Those dates have passed and none of it shipped, so the
-plan has been withdrawn rather than moved: no part of it is in this package, and
-this release makes no claim about when any of it will exist. What is in the box
-is the TypeScript validation library described above.
+The first published line — `0.1.0-alpha` through `0.1.2-alpha`, which the
+migration guide and the docs site both call "1.x" although no `1.x` was ever
+published — described a `.luq` DSL that would generate validators for other
+languages, against dated milestones. Those dates have passed and none of it
+shipped, so the plan has been withdrawn rather than moved: no part of it is in
+this package, and this release makes no claim about when any of it will exist.
+What is in the box is the TypeScript validation library described above.
 
 ## License
 

package/dist/chain/slot-type-guard.js

@@ -3,16 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.slotTypeGuard = slotTypeGuard;
 const types_1 = require("../types");
 const create_rule_1 = require("../plugin-kit/create-rule");
+/**
+ * Each code is SPELLED here rather than interpolated from the slot name.
+ *
+ * `${slot}Type` produced the same six strings, and produced them nowhere a
+ * reader could find them: config/issue-code.lock.json enumerates every code
+ * the library can report, and a code that only exists once a template has been
+ * evaluated cannot be enumerated, so these six were missing from the published
+ * vocabulary while being among the most commonly reported codes there are.
+ */
 const SLOT_TYPES = Object.freeze({
-    string: { accepts: types_1.isString, noun: "a string" },
-    number: { accepts: types_1.isNumber, noun: "a number" },
+    string: { accepts: types_1.isString, code: "stringType", noun: "a string" },
+    number: { accepts: types_1.isNumber, code: "numberType", noun: "a number" },
     boolean: {
         accepts: (value) => typeof value === "boolean",
+        code: "booleanType",
         noun: "a boolean",
     },
-    date: { accepts: (value) => value instanceof Date, noun: "a Date" },
-    array: { accepts: types_1.isArray, noun: "an array" },
-    object: { accepts: types_1.isPlainObject, noun: "an object" },
+    date: {
+        accepts: (value) => value instanceof Date,
+        code: "dateType",
+        noun: "a Date",
+    },
+    array: { accepts: types_1.isArray, code: "arrayType", noun: "an array" },
+    object: { accepts: types_1.isPlainObject, code: "objectType", noun: "an object" },
 });
 /**
  * The rule `b.<slot>` starts its chain with, or null for a slot that claims
@@ -26,7 +40,7 @@ function slotTypeGuard(slot, severity) {
     if (slotType === undefined)
         return null;
     return (0, create_rule_1.check)({
-        code: `${slot}Type`,
+        code: slotType.code,
         severity,
         run: (value) => value === undefined || value === null || slotType.accepts(value)
             ? types_1.PASS

package/dist/chain/slot-type-guard.mjs

@@ -1,15 +1,29 @@
 import { PASS, fail, isArray, isNumber, isPlainObject, isString, } from "../types/index.mjs";
 import { check } from "../plugin-kit/create-rule.mjs";
+/**
+ * Each code is SPELLED here rather than interpolated from the slot name.
+ *
+ * `${slot}Type` produced the same six strings, and produced them nowhere a
+ * reader could find them: config/issue-code.lock.json enumerates every code
+ * the library can report, and a code that only exists once a template has been
+ * evaluated cannot be enumerated, so these six were missing from the published
+ * vocabulary while being among the most commonly reported codes there are.
+ */
 const SLOT_TYPES = Object.freeze({
-    string: { accepts: isString, noun: "a string" },
-    number: { accepts: isNumber, noun: "a number" },
+    string: { accepts: isString, code: "stringType", noun: "a string" },
+    number: { accepts: isNumber, code: "numberType", noun: "a number" },
     boolean: {
         accepts: (value) => typeof value === "boolean",
+        code: "booleanType",
         noun: "a boolean",
     },
-    date: { accepts: (value) => value instanceof Date, noun: "a Date" },
-    array: { accepts: isArray, noun: "an array" },
-    object: { accepts: isPlainObject, noun: "an object" },
+    date: {
+        accepts: (value) => value instanceof Date,
+        code: "dateType",
+        noun: "a Date",
+    },
+    array: { accepts: isArray, code: "arrayType", noun: "an array" },
+    object: { accepts: isPlainObject, code: "objectType", noun: "an object" },
 });
 /**
  * The rule `b.<slot>` starts its chain with, or null for a slot that claims
@@ -23,7 +37,7 @@ export function slotTypeGuard(slot, severity) {
     if (slotType === undefined)
         return null;
     return check({
-        code: `${slot}Type`,
+        code: slotType.code,
         severity,
         run: (value) => value === undefined || value === null || slotType.accepts(value)
             ? PASS

package/dist/compile/resolve-presence.js

@@ -38,13 +38,43 @@ function countRestrictions(rule) {
         (rule.allowNull ? 0 : 1) +
         (rule.emptyStringIsMissing ? 1 : 0));
 }
+/**
+ * Which of two equally restrictive rules is reported, decided on WHAT each one
+ * forbids: undefined first, then null, then the empty string.
+ *
+ * The order is declared here rather than falling out of something else. It
+ * runs from the broadest absence to the narrowest — a field that is not there
+ * at all, a field that is there holding null, a field holding "" — so the
+ * identity a caller sees names the largest thing that was missing.
+ *
+ * Nothing in this comparison reads a code. A code is a published name, pinned
+ * in config/issue-code.lock.json, and re-spelling one must not move which rule
+ * a failure is reported under; comparing the two codes made exactly that
+ * happen, silently, from a one-word rename.
+ *
+ * Two rules forbidding the identical three things are indistinguishable to
+ * every reader of the policy, so neither outranks the other and the one
+ * declared first stays. That is the only case where the order the methods were
+ * typed in is observable at all.
+ */
+function outranksOnRestriction(rule, incumbent) {
+    if (rule.allowUndefined !== incumbent.allowUndefined) {
+        return !rule.allowUndefined;
+    }
+    if (rule.allowNull !== incumbent.allowNull)
+        return !rule.allowNull;
+    if (rule.emptyStringIsMissing !== incumbent.emptyStringIsMissing) {
+        return rule.emptyStringIsMissing;
+    }
+    return false;
+}
 /**
  * The identity a failure is reported under: the rule that forbids the most,
- * ties broken by the lexicographically smaller code.
+ * ties broken by which absence it forbids.
  *
- * Tie-breaking on the CODE rather than on declaration order is what keeps the
- * whole policy — not merely its three flags — independent of the order the
- * rules arrived in. `.optional().nullable()` and `.nullable().optional()` are
+ * Both halves of the decision read only the three presence flags, so the whole
+ * policy — not merely its flags — is independent of the order the rules
+ * arrived in. `.optional().nullable()` and `.nullable().optional()` are
  * deep-equal, which is the property the tests assert.
  */
 function selectStrictestPresence(rules) {
@@ -55,7 +85,8 @@ function selectStrictestPresence(rules) {
             continue;
         }
         const difference = countRestrictions(rule) - countRestrictions(strictest);
-        if (difference > 0 || (difference === 0 && rule.code < strictest.code)) {
+        if (difference > 0 ||
+            (difference === 0 && outranksOnRestriction(rule, strictest))) {
             strictest = rule;
         }
     }

package/dist/compile/resolve-presence.mjs

@@ -34,13 +34,43 @@ function countRestrictions(rule) {
         (rule.allowNull ? 0 : 1) +
         (rule.emptyStringIsMissing ? 1 : 0));
 }
+/**
+ * Which of two equally restrictive rules is reported, decided on WHAT each one
+ * forbids: undefined first, then null, then the empty string.
+ *
+ * The order is declared here rather than falling out of something else. It
+ * runs from the broadest absence to the narrowest — a field that is not there
+ * at all, a field that is there holding null, a field holding "" — so the
+ * identity a caller sees names the largest thing that was missing.
+ *
+ * Nothing in this comparison reads a code. A code is a published name, pinned
+ * in config/issue-code.lock.json, and re-spelling one must not move which rule
+ * a failure is reported under; comparing the two codes made exactly that
+ * happen, silently, from a one-word rename.
+ *
+ * Two rules forbidding the identical three things are indistinguishable to
+ * every reader of the policy, so neither outranks the other and the one
+ * declared first stays. That is the only case where the order the methods were
+ * typed in is observable at all.
+ */
+function outranksOnRestriction(rule, incumbent) {
+    if (rule.allowUndefined !== incumbent.allowUndefined) {
+        return !rule.allowUndefined;
+    }
+    if (rule.allowNull !== incumbent.allowNull)
+        return !rule.allowNull;
+    if (rule.emptyStringIsMissing !== incumbent.emptyStringIsMissing) {
+        return rule.emptyStringIsMissing;
+    }
+    return false;
+}
 /**
  * The identity a failure is reported under: the rule that forbids the most,
- * ties broken by the lexicographically smaller code.
+ * ties broken by which absence it forbids.
  *
- * Tie-breaking on the CODE rather than on declaration order is what keeps the
- * whole policy — not merely its three flags — independent of the order the
- * rules arrived in. `.optional().nullable()` and `.nullable().optional()` are
+ * Both halves of the decision read only the three presence flags, so the whole
+ * policy — not merely its flags — is independent of the order the rules
+ * arrived in. `.optional().nullable()` and `.nullable().optional()` are
  * deep-equal, which is the property the tests assert.
  */
 function selectStrictestPresence(rules) {
@@ -51,7 +81,8 @@ function selectStrictestPresence(rules) {
             continue;
         }
         const difference = countRestrictions(rule) - countRestrictions(strictest);
-        if (difference > 0 || (difference === 0 && rule.code < strictest.code)) {
+        if (difference > 0 ||
+            (difference === 0 && outranksOnRestriction(rule, strictest))) {
             strictest = rule;
         }
     }

package/dist/json-schema/assert-supported-dialect.d.ts

@@ -0,0 +1,37 @@
+/**
+ * What the caller may say about the dialect. `JsonSchemaOptions` extends this,
+ * so the chain method and the conversion function offer the same word.
+ */
+export interface DialectOptions {
+    /**
+     * Read the document under Draft-07 rules whatever its `$schema` declares.
+     *
+     * The reading it buys is Draft-07's, exactly: `$ref` replaces the node it
+     * sits in, `format` asserts, and an array under `items` is the tuple form.
+     * A 2019-09 or 2020-12 document that relies on any of those meaning what the
+     * NEWER draft says will be enforced as less, or as something else, than it
+     * states.
+     */
+    readonly assumeDraft07?: boolean | undefined;
+}
+/**
+ * The released dialects Luq recognises the NAME of and does not implement,
+ * each with what it does that Draft-07 does not. They are written out so that
+ * "this is a dialect we know and did not build" and "we have never heard of
+ * this URI" stay different answers — the same distinction NON_DRAFT07_KEYWORDS
+ * draws between an out-of-dialect keyword and an invented one.
+ */
+export declare const NON_DRAFT07_DIALECTS: Readonly<Record<string, string>>;
+/**
+ * Reads the root `$schema` and refuses a dialect Luq does not implement.
+ *
+ * Called at both front doors, immediately after "is this a schema at all" and
+ * before any keyword is read, so no validator that enforces less than its
+ * document states can be reached by either route.
+ *
+ * A non-string `$schema` is a malformed VALUE rather than an unimplemented
+ * dialect — the meta-schema types it as a string — so it goes to the class that
+ * answers that question, and it is refused under the opt-out too: the opt-out
+ * says "read this dialect as Draft-07", and a number names no dialect.
+ */
+export declare function assertSupportedDialect(document: unknown, options: DialectOptions): void;

package/dist/json-schema/assert-supported-dialect.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NON_DRAFT07_DIALECTS = void 0;
+exports.assertSupportedDialect = assertSupportedDialect;
+// ===========================================================================
+// L8  src/json-schema/assert-supported-dialect.ts — the DIALECT gate, read
+// once at the document root before any keyword is.
+//
+// WHY A DEFAULT REFUSAL AND NOT A DIVERGENCE DETECTOR. Refusing only documents
+// that actually USE something 2019-09 changed sounds more precise and is the
+// worse trade. The divergences are not all spellable as keyword names: `$ref`
+// gains siblings, `format` and the two `content*` keywords stop asserting by
+// default, and 2020-12 moves the tuple form of `items` to `prefixItems`. A
+// detector would therefore have to carry a second semantic model of two
+// dialects this library does not implement, and every case it fails to think
+// of is a SILENT wrong answer — which is the exact failure this file exists to
+// stop. The `$ref`-sibling case was itself invisible until it was hunted for.
+// `$schema` is the document's own statement of what it means, so that is what
+// is read.
+//
+// WHAT THE DEFAULT COSTS, and why the opt-out exists. A newer `$schema` over a
+// body that happens to be Draft-07-compatible builds correctly today, and
+// people copy the newest `$schema` line into documents that use nothing new.
+// Refusing outright would break those. `assumeDraft07` gives them a one-word
+// fix that is written at the CALL SITE, in the caller's own source, where a
+// reviewer reads it — so the reading is a stated decision rather than a silent
+// default. There is no way to get the wrong answer without having written the
+// word down.
+//
+// A document with NO `$schema` is untouched. That is most real documents and
+// all 929 cases of the conformance corpus, and it is not a guess about the
+// dialect: nothing was declared, so nothing contradicts Draft-07.
+//
+// THE ROOT ONLY. `externalDocuments` is a map the caller loads, and the suite's
+// own map holds 37 documents across four dialects of which a given case follows
+// two or three; refusing at registration would refuse documents nothing reads.
+// A `$schema` deeper in a document is likewise not the document's dialect.
+// ===========================================================================
+const types_1 = require("../types");
+const malformed_schema_error_1 = require("./malformed-schema-error");
+const unsupported_dialect_error_1 = require("./unsupported-dialect-error");
+/**
+ * Comparable form of a meta-schema URI: case folded, scheme dropped, and a
+ * trailing "#" or "/" removed.
+ *
+ * The scheme is dropped because the two families disagree about it — Draft-07
+ * publishes `http://json-schema.org/draft-07/schema#` and 2020-12 publishes
+ * `https://json-schema.org/draft/2020-12/schema` — and a document that writes
+ * `https` for the first or `http` for the second is naming the same dialect,
+ * not a different one. Matching the published string exactly would make the
+ * gate depend on which of two equally common spellings a document picked.
+ */
+function normaliseDialectUri(uri) {
+    return uri
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, "")
+        .replace(/[#/]+$/, "");
+}
+const DRAFT07_NORMALISED = normaliseDialectUri("http://json-schema.org/draft-07/schema#");
+/**
+ * The released dialects Luq recognises the NAME of and does not implement,
+ * each with what it does that Draft-07 does not. They are written out so that
+ * "this is a dialect we know and did not build" and "we have never heard of
+ * this URI" stay different answers — the same distinction NON_DRAFT07_KEYWORDS
+ * draws between an out-of-dialect keyword and an invented one.
+ */
+exports.NON_DRAFT07_DIALECTS = Object.freeze({
+    "json-schema.org/schema": "the unversioned alias, which names whichever draft the site publishes " +
+        "as current rather than a fixed one",
+    "json-schema.org/draft-03/schema": "Draft-03, which spells `required` as a boolean on each property",
+    "json-schema.org/draft-04/schema": "Draft-04, whose `exclusiveMaximum` is a boolean modifier, not a bound",
+    "json-schema.org/draft-06/schema": "Draft-06, which has no `$comment` and reads `$ref` the Draft-07 way",
+    "json-schema.org/draft/2019-09/schema": "2019-09, where `$ref` is an ordinary applicator and its siblings are " +
+        "applied, and `format` asserts nothing unless the vocabulary asks",
+    "json-schema.org/draft/2020-12/schema": "2020-12, where `$ref` siblings are applied, the tuple form of `items` " +
+        "is spelled `prefixItems`, and `format` asserts nothing by default",
+});
+const UNRECOGNISED_DIALECT = "a meta-schema Luq has no reading for, so what its keywords mean is unknown";
+const DIALECT_VALUE_REASON = "the value must be a URI string";
+/**
+ * Reads the root `$schema` and refuses a dialect Luq does not implement.
+ *
+ * Called at both front doors, immediately after "is this a schema at all" and
+ * before any keyword is read, so no validator that enforces less than its
+ * document states can be reached by either route.
+ *
+ * A non-string `$schema` is a malformed VALUE rather than an unimplemented
+ * dialect — the meta-schema types it as a string — so it goes to the class that
+ * answers that question, and it is refused under the opt-out too: the opt-out
+ * says "read this dialect as Draft-07", and a number names no dialect.
+ */
+function assertSupportedDialect(document, options) {
+    // Read off an untyped object rather than through `Draft07SchemaObject`,
+    // which types `$schema` as a string: the document is whatever JSON.parse
+    // produced, and a `$schema` that is not a string is exactly what this has to
+    // be able to see. The §4.4 boolean form and every non-object fall out here,
+    // declaring no dialect.
+    if (!(0, types_1.isPlainObject)(document))
+        return;
+    const declared = document["$schema"];
+    if (declared === undefined)
+        return;
+    if (typeof declared !== "string") {
+        throw new malformed_schema_error_1.MalformedSchemaError("$schema", DIALECT_VALUE_REASON, declared);
+    }
+    const normalised = normaliseDialectUri(declared);
+    if (normalised === DRAFT07_NORMALISED)
+        return;
+    if (options.assumeDraft07 === true)
+        return;
+    throw new unsupported_dialect_error_1.UnsupportedDialectError(declared, exports.NON_DRAFT07_DIALECTS[normalised] ?? UNRECOGNISED_DIALECT);
+}

package/dist/json-schema/assert-supported-dialect.mjs

@@ -0,0 +1,109 @@
+// ===========================================================================
+// L8  src/json-schema/assert-supported-dialect.ts — the DIALECT gate, read
+// once at the document root before any keyword is.
+//
+// WHY A DEFAULT REFUSAL AND NOT A DIVERGENCE DETECTOR. Refusing only documents
+// that actually USE something 2019-09 changed sounds more precise and is the
+// worse trade. The divergences are not all spellable as keyword names: `$ref`
+// gains siblings, `format` and the two `content*` keywords stop asserting by
+// default, and 2020-12 moves the tuple form of `items` to `prefixItems`. A
+// detector would therefore have to carry a second semantic model of two
+// dialects this library does not implement, and every case it fails to think
+// of is a SILENT wrong answer — which is the exact failure this file exists to
+// stop. The `$ref`-sibling case was itself invisible until it was hunted for.
+// `$schema` is the document's own statement of what it means, so that is what
+// is read.
+//
+// WHAT THE DEFAULT COSTS, and why the opt-out exists. A newer `$schema` over a
+// body that happens to be Draft-07-compatible builds correctly today, and
+// people copy the newest `$schema` line into documents that use nothing new.
+// Refusing outright would break those. `assumeDraft07` gives them a one-word
+// fix that is written at the CALL SITE, in the caller's own source, where a
+// reviewer reads it — so the reading is a stated decision rather than a silent
+// default. There is no way to get the wrong answer without having written the
+// word down.
+//
+// A document with NO `$schema` is untouched. That is most real documents and
+// all 929 cases of the conformance corpus, and it is not a guess about the
+// dialect: nothing was declared, so nothing contradicts Draft-07.
+//
+// THE ROOT ONLY. `externalDocuments` is a map the caller loads, and the suite's
+// own map holds 37 documents across four dialects of which a given case follows
+// two or three; refusing at registration would refuse documents nothing reads.
+// A `$schema` deeper in a document is likewise not the document's dialect.
+// ===========================================================================
+import { isPlainObject } from "../types/index.mjs";
+import { MalformedSchemaError } from "./malformed-schema-error.mjs";
+import { UnsupportedDialectError } from "./unsupported-dialect-error.mjs";
+/**
+ * Comparable form of a meta-schema URI: case folded, scheme dropped, and a
+ * trailing "#" or "/" removed.
+ *
+ * The scheme is dropped because the two families disagree about it — Draft-07
+ * publishes `http://json-schema.org/draft-07/schema#` and 2020-12 publishes
+ * `https://json-schema.org/draft/2020-12/schema` — and a document that writes
+ * `https` for the first or `http` for the second is naming the same dialect,
+ * not a different one. Matching the published string exactly would make the
+ * gate depend on which of two equally common spellings a document picked.
+ */
+function normaliseDialectUri(uri) {
+    return uri
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, "")
+        .replace(/[#/]+$/, "");
+}
+const DRAFT07_NORMALISED = normaliseDialectUri("http://json-schema.org/draft-07/schema#");
+/**
+ * The released dialects Luq recognises the NAME of and does not implement,
+ * each with what it does that Draft-07 does not. They are written out so that
+ * "this is a dialect we know and did not build" and "we have never heard of
+ * this URI" stay different answers — the same distinction NON_DRAFT07_KEYWORDS
+ * draws between an out-of-dialect keyword and an invented one.
+ */
+export const NON_DRAFT07_DIALECTS = Object.freeze({
+    "json-schema.org/schema": "the unversioned alias, which names whichever draft the site publishes " +
+        "as current rather than a fixed one",
+    "json-schema.org/draft-03/schema": "Draft-03, which spells `required` as a boolean on each property",
+    "json-schema.org/draft-04/schema": "Draft-04, whose `exclusiveMaximum` is a boolean modifier, not a bound",
+    "json-schema.org/draft-06/schema": "Draft-06, which has no `$comment` and reads `$ref` the Draft-07 way",
+    "json-schema.org/draft/2019-09/schema": "2019-09, where `$ref` is an ordinary applicator and its siblings are " +
+        "applied, and `format` asserts nothing unless the vocabulary asks",
+    "json-schema.org/draft/2020-12/schema": "2020-12, where `$ref` siblings are applied, the tuple form of `items` " +
+        "is spelled `prefixItems`, and `format` asserts nothing by default",
+});
+const UNRECOGNISED_DIALECT = "a meta-schema Luq has no reading for, so what its keywords mean is unknown";
+const DIALECT_VALUE_REASON = "the value must be a URI string";
+/**
+ * Reads the root `$schema` and refuses a dialect Luq does not implement.
+ *
+ * Called at both front doors, immediately after "is this a schema at all" and
+ * before any keyword is read, so no validator that enforces less than its
+ * document states can be reached by either route.
+ *
+ * A non-string `$schema` is a malformed VALUE rather than an unimplemented
+ * dialect — the meta-schema types it as a string — so it goes to the class that
+ * answers that question, and it is refused under the opt-out too: the opt-out
+ * says "read this dialect as Draft-07", and a number names no dialect.
+ */
+export function assertSupportedDialect(document, options) {
+    // Read off an untyped object rather than through `Draft07SchemaObject`,
+    // which types `$schema` as a string: the document is whatever JSON.parse
+    // produced, and a `$schema` that is not a string is exactly what this has to
+    // be able to see. The §4.4 boolean form and every non-object fall out here,
+    // declaring no dialect.
+    if (!isPlainObject(document))
+        return;
+    const declared = document["$schema"];
+    if (declared === undefined)
+        return;
+    if (typeof declared !== "string") {
+        throw new MalformedSchemaError("$schema", DIALECT_VALUE_REASON, declared);
+    }
+    const normalised = normaliseDialectUri(declared);
+    if (normalised === DRAFT07_NORMALISED)
+        return;
+    if (options.assumeDraft07 === true)
+        return;
+    throw new UnsupportedDialectError(declared, NON_DRAFT07_DIALECTS[normalised] ?? UNRECOGNISED_DIALECT);
+}

package/dist/json-schema/build-from-schema.d.ts

@@ -2,6 +2,7 @@ import type { FieldBuilderSurface } from "../builder/builder-surface.types";
 import type { FieldEntry } from "../builder/field-entry.types";
 import type { Validator } from "../builder/validator.types";
 import type { GlobalConfig } from "../types/global-config";
+import type { DialectOptions } from "./assert-supported-dialect";
 import type { JsonSchemaBag } from "./json-schema-bag.types";
 /** A value that is not a schema at all. Named, and refused at the boundary. */
 export declare class NotASchemaError extends Error {
@@ -9,10 +10,28 @@ export declare class NotASchemaError extends Error {
     constructor(received: unknown);
 }
 /** One pending `.v()` per declared path, with its callback still unrun. */
-export declare function buildFieldEntries(bag: JsonSchemaBag, schema: unknown): readonly FieldEntry[];
+export declare function buildFieldEntries(bag: JsonSchemaBag, schema: unknown, options?: DialectOptions): readonly FieldEntry[];
 /** The erased front door: the declarations, with nothing compiled yet. */
-export declare function buildFromSchema(bag: JsonSchemaBag, schema: unknown, config?: GlobalConfig): FieldBuilderSurface;
+export declare function buildFromSchema(bag: JsonSchemaBag, schema: unknown, config?: GlobalConfig, options?: DialectOptions): FieldBuilderSurface;
 /**
+ * Converts a JSON Schema document into a validator.
+ *
+ * THE INPUT LIMIT IS DRAFT-07, and it is a limit on what may be handed in, not
+ * only a statement of how much of Draft-07 is covered. A document declaring
+ * 2019-09 or 2020-12 in its root `$schema` is REFUSED with an
+ * `UnsupportedDialectError` rather than read as Draft-07, because the two
+ * dialects disagree about what an unchanged keyword means: from 2019-09 on
+ * `$ref` is an ordinary applicator whose siblings are applied, while Draft-07
+ * §8.3 replaces the node, so `{"$ref": "#/$defs/name", "minLength": 5}` read as
+ * Draft-07 loses the `minLength` and accepts a value the document forbids. A
+ * document with NO `$schema` is read as Draft-07 and always has been. Pass
+ * `{ assumeDraft07: true }` as the fourth argument to read a newer-dialect
+ * document under Draft-07 rules deliberately, with that reading's consequences.
+ *
+ * `T` defaults to `Record<string, unknown>`, never `any`; under the default NO
+ * declared path is checked. See the header of this file, which owns that
+ * escape hatch.
+ *
  * The declared type is put back on by `eraseSchemaValidator`, the fourth
  * function in src/core/type-erasure.ts — the one file the code standard allows
  * to assert. Step 25 expressed this as an OVERLOAD PAIR instead, because
@@ -20,4 +39,4 @@ export declare function buildFromSchema(bag: JsonSchemaBag, schema: unknown, con
  * TypeScript on lenient compatibility rules and so was never audited anywhere.
  * The call below is, in the file where every escape hatch is reviewed together.
  */
-export declare function fromJsonSchema<T extends object = Record<string, unknown>>(bag: JsonSchemaBag, schema: unknown, config?: GlobalConfig): Validator<T>;
+export declare function fromJsonSchema<T extends object = Record<string, unknown>>(bag: JsonSchemaBag, schema: unknown, config?: GlobalConfig, options?: DialectOptions): Validator<T>;

package/dist/json-schema/build-from-schema.js

@@ -6,6 +6,7 @@ exports.buildFromSchema = buildFromSchema;
 exports.fromJsonSchema = fromJsonSchema;
 const create_field_builder_1 = require("../builder/create-field-builder");
 const type_erasure_1 = require("../core/type-erasure");
+const assert_supported_dialect_1 = require("./assert-supported-dialect");
 const create_structural_context_1 = require("./create-structural-context");
 const declare_presence_1 = require("./declare-presence");
 const ref_scope_1 = require("./ref-scope");
@@ -35,9 +36,12 @@ function collectDeclaredRules(declaration, bag, root, chain) {
     ]);
 }
 /** One pending `.v()` per declared path, with its callback still unrun. */
-function buildFieldEntries(bag, schema) {
+function buildFieldEntries(bag, schema, options = {}) {
     if (!(0, draft07_types_1.isDraft07Schema)(schema))
         throw new NotASchemaError(schema);
+    // Before any keyword is read: what the document's keywords MEAN depends on
+    // the dialect it declares, and Luq reads every one of them as Draft-07.
+    (0, assert_supported_dialect_1.assertSupportedDialect)(schema, options);
     return (0, flatten_schema_1.flattenSchema)(schema, schema_to_declarations_1.readChildSchemas).map((declaration) => ({
         path: declaration.path,
         defaultOf: null,
@@ -53,10 +57,28 @@ function buildFieldEntries(bag, schema) {
     }));
 }
 /** The erased front door: the declarations, with nothing compiled yet. */
-function buildFromSchema(bag, schema, config) {
-    return (0, create_field_builder_1.createFieldBuilderSurface)(bag, config, buildFieldEntries(bag, schema));
+function buildFromSchema(bag, schema, config, options) {
+    return (0, create_field_builder_1.createFieldBuilderSurface)(bag, config, buildFieldEntries(bag, schema, options));
 }
 /**
+ * Converts a JSON Schema document into a validator.
+ *
+ * THE INPUT LIMIT IS DRAFT-07, and it is a limit on what may be handed in, not
+ * only a statement of how much of Draft-07 is covered. A document declaring
+ * 2019-09 or 2020-12 in its root `$schema` is REFUSED with an
+ * `UnsupportedDialectError` rather than read as Draft-07, because the two
+ * dialects disagree about what an unchanged keyword means: from 2019-09 on
+ * `$ref` is an ordinary applicator whose siblings are applied, while Draft-07
+ * §8.3 replaces the node, so `{"$ref": "#/$defs/name", "minLength": 5}` read as
+ * Draft-07 loses the `minLength` and accepts a value the document forbids. A
+ * document with NO `$schema` is read as Draft-07 and always has been. Pass
+ * `{ assumeDraft07: true }` as the fourth argument to read a newer-dialect
+ * document under Draft-07 rules deliberately, with that reading's consequences.
+ *
+ * `T` defaults to `Record<string, unknown>`, never `any`; under the default NO
+ * declared path is checked. See the header of this file, which owns that
+ * escape hatch.
+ *
  * The declared type is put back on by `eraseSchemaValidator`, the fourth
  * function in src/core/type-erasure.ts — the one file the code standard allows
  * to assert. Step 25 expressed this as an OVERLOAD PAIR instead, because
@@ -64,7 +86,7 @@ function buildFromSchema(bag, schema, config) {
  * TypeScript on lenient compatibility rules and so was never audited anywhere.
  * The call below is, in the file where every escape hatch is reviewed together.
  */
-function fromJsonSchema(bag, schema, config) {
-    const planBacked = buildFromSchema(bag, schema, config).build();
+function fromJsonSchema(bag, schema, config, options) {
+    const planBacked = buildFromSchema(bag, schema, config, options).build();
     return (0, type_erasure_1.eraseSchemaValidator)(planBacked);
 }

package/dist/json-schema/build-from-schema.mjs

@@ -1,5 +1,6 @@
 import { createFieldBuilderSurface } from "../builder/create-field-builder.mjs";
 import { eraseSchemaValidator } from "../core/type-erasure.mjs";
+import { assertSupportedDialect } from "./assert-supported-dialect.mjs";
 import { createStructuralContext } from "./create-structural-context.mjs";
 import { declarePresenceRules } from "./declare-presence.mjs";
 import { createLocalScope } from "./ref-scope.mjs";
@@ -28,9 +29,12 @@ function collectDeclaredRules(declaration, bag, root, chain) {
     ]);
 }
 /** One pending `.v()` per declared path, with its callback still unrun. */
-export function buildFieldEntries(bag, schema) {
+export function buildFieldEntries(bag, schema, options = {}) {
     if (!isDraft07Schema(schema))
         throw new NotASchemaError(schema);
+    // Before any keyword is read: what the document's keywords MEAN depends on
+    // the dialect it declares, and Luq reads every one of them as Draft-07.
+    assertSupportedDialect(schema, options);
     return flattenSchema(schema, readChildSchemas).map((declaration) => ({
         path: declaration.path,
         defaultOf: null,
@@ -46,10 +50,28 @@ export function buildFieldEntries(bag, schema) {
     }));
 }
 /** The erased front door: the declarations, with nothing compiled yet. */
-export function buildFromSchema(bag, schema, config) {
-    return createFieldBuilderSurface(bag, config, buildFieldEntries(bag, schema));
+export function buildFromSchema(bag, schema, config, options) {
+    return createFieldBuilderSurface(bag, config, buildFieldEntries(bag, schema, options));
 }
 /**
+ * Converts a JSON Schema document into a validator.
+ *
+ * THE INPUT LIMIT IS DRAFT-07, and it is a limit on what may be handed in, not
+ * only a statement of how much of Draft-07 is covered. A document declaring
+ * 2019-09 or 2020-12 in its root `$schema` is REFUSED with an
+ * `UnsupportedDialectError` rather than read as Draft-07, because the two
+ * dialects disagree about what an unchanged keyword means: from 2019-09 on
+ * `$ref` is an ordinary applicator whose siblings are applied, while Draft-07
+ * §8.3 replaces the node, so `{"$ref": "#/$defs/name", "minLength": 5}` read as
+ * Draft-07 loses the `minLength` and accepts a value the document forbids. A
+ * document with NO `$schema` is read as Draft-07 and always has been. Pass
+ * `{ assumeDraft07: true }` as the fourth argument to read a newer-dialect
+ * document under Draft-07 rules deliberately, with that reading's consequences.
+ *
+ * `T` defaults to `Record<string, unknown>`, never `any`; under the default NO
+ * declared path is checked. See the header of this file, which owns that
+ * escape hatch.
+ *
  * The declared type is put back on by `eraseSchemaValidator`, the fourth
  * function in src/core/type-erasure.ts — the one file the code standard allows
  * to assert. Step 25 expressed this as an OVERLOAD PAIR instead, because
@@ -57,7 +79,7 @@ export function buildFromSchema(bag, schema, config) {
  * TypeScript on lenient compatibility rules and so was never audited anywhere.
  * The call below is, in the file where every escape hatch is reviewed together.
  */
-export function fromJsonSchema(bag, schema, config) {
-    const planBacked = buildFromSchema(bag, schema, config).build();
+export function fromJsonSchema(bag, schema, config, options) {
+    const planBacked = buildFromSchema(bag, schema, config, options).build();
     return eraseSchemaValidator(planBacked);
 }

package/dist/json-schema/extensions/json-schema/index.d.ts

@@ -1,4 +1,4 @@
 export { SCHEMA_BRANCH_LABEL, collectDocumentRules, jsonSchemaPlugin, } from "./json-schema";
 export type { JsonSchemaOptions } from "./json-schema";
-export { MalformedSchemaError, NotASchemaError, UnsupportedKeywordError, RefResolutionError, buildFieldEntries, buildFromSchema, fromJsonSchema, isDraft07Schema, listBoundPluginNames, listDraft07Keywords, listFormatNames, } from "../../index";
-export type { Draft07Schema, Draft07SchemaObject, JsonSchemaBag, } from "../../index";
+export { DRAFT07_DIALECT_URI, MalformedSchemaError, NotASchemaError, UnsupportedDialectError, UnsupportedKeywordError, RefResolutionError, buildFieldEntries, buildFromSchema, fromJsonSchema, isDraft07Schema, listBoundPluginNames, listDraft07Keywords, listFormatNames, } from "../../index";
+export type { DialectOptions, Draft07Schema, Draft07SchemaObject, JsonSchemaBag, } from "../../index";

package/dist/json-schema/extensions/json-schema/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listFormatNames = exports.listDraft07Keywords = exports.listBoundPluginNames = exports.isDraft07Schema = exports.fromJsonSchema = exports.buildFromSchema = exports.buildFieldEntries = exports.RefResolutionError = exports.UnsupportedKeywordError = exports.NotASchemaError = exports.MalformedSchemaError = exports.jsonSchemaPlugin = exports.collectDocumentRules = exports.SCHEMA_BRANCH_LABEL = void 0;
+exports.listFormatNames = exports.listDraft07Keywords = exports.listBoundPluginNames = exports.isDraft07Schema = exports.fromJsonSchema = exports.buildFromSchema = exports.buildFieldEntries = exports.RefResolutionError = exports.UnsupportedKeywordError = exports.UnsupportedDialectError = exports.NotASchemaError = exports.MalformedSchemaError = exports.DRAFT07_DIALECT_URI = exports.jsonSchemaPlugin = exports.collectDocumentRules = exports.SCHEMA_BRANCH_LABEL = void 0;
 // ===========================================================================
 // The public subpath `@maroonedog/luq/plugins/jsonSchema`. Re-exports only.
 //
@@ -15,8 +15,10 @@ Object.defineProperty(exports, "SCHEMA_BRANCH_LABEL", { enumerable: true, get: f
 Object.defineProperty(exports, "collectDocumentRules", { enumerable: true, get: function () { return json_schema_1.collectDocumentRules; } });
 Object.defineProperty(exports, "jsonSchemaPlugin", { enumerable: true, get: function () { return json_schema_1.jsonSchemaPlugin; } });
 var index_1 = require("../../index");
+Object.defineProperty(exports, "DRAFT07_DIALECT_URI", { enumerable: true, get: function () { return index_1.DRAFT07_DIALECT_URI; } });
 Object.defineProperty(exports, "MalformedSchemaError", { enumerable: true, get: function () { return index_1.MalformedSchemaError; } });
 Object.defineProperty(exports, "NotASchemaError", { enumerable: true, get: function () { return index_1.NotASchemaError; } });
+Object.defineProperty(exports, "UnsupportedDialectError", { enumerable: true, get: function () { return index_1.UnsupportedDialectError; } });
 Object.defineProperty(exports, "UnsupportedKeywordError", { enumerable: true, get: function () { return index_1.UnsupportedKeywordError; } });
 Object.defineProperty(exports, "RefResolutionError", { enumerable: true, get: function () { return index_1.RefResolutionError; } });
 Object.defineProperty(exports, "buildFieldEntries", { enumerable: true, get: function () { return index_1.buildFieldEntries; } });

package/dist/json-schema/extensions/json-schema/index.mjs

@@ -8,4 +8,4 @@
 // a consumer of this subpath pays only for the plugins they import themselves.
 // ===========================================================================
 export { SCHEMA_BRANCH_LABEL, collectDocumentRules, jsonSchemaPlugin, } from "./json-schema.mjs";
-export { MalformedSchemaError, NotASchemaError, UnsupportedKeywordError, RefResolutionError, buildFieldEntries, buildFromSchema, fromJsonSchema, isDraft07Schema, listBoundPluginNames, listDraft07Keywords, listFormatNames, } from "../../index.mjs";
+export { DRAFT07_DIALECT_URI, MalformedSchemaError, NotASchemaError, UnsupportedDialectError, UnsupportedKeywordError, RefResolutionError, buildFieldEntries, buildFromSchema, fromJsonSchema, isDraft07Schema, listBoundPluginNames, listDraft07Keywords, listFormatNames, } from "../../index.mjs";

package/dist/json-schema/extensions/json-schema/json-schema.d.ts

@@ -2,7 +2,7 @@ import type { Rule } from "../../../plugin-kit/compiled-rule";
 import { type MessageContextExtra, type TypeName } from "../../../types";
 import type { RuleBuildContext } from "../../../plugin-kit/rule-build-context";
 import type { Unchanged } from "../../../plugin-kit/marker.types";
-import { type JsonSchemaBag } from "../../index";
+import { type DialectOptions, type JsonSchemaBag } from "../../index";
 /** The label the whole document carries inside the composite it becomes. */
 export declare const SCHEMA_BRANCH_LABEL = "schema";
 /**
@@ -17,7 +17,7 @@ export declare const SCHEMA_BRANCH_LABEL = "schema";
  * The caller fetches, reads from disk, or bundles — whichever is right for
  * their deployment — and hands over what they already have.
  */
-export interface JsonSchemaOptions {
+export interface JsonSchemaOptions extends DialectOptions {
     readonly externalDocuments?: Readonly<Record<string, unknown>> | undefined;
 }
 /**

package/dist/json-schema/extensions/json-schema/json-schema.js

@@ -66,6 +66,9 @@ const NO_EXTERNAL_DOCUMENTS = Object.freeze({});
 function collectDocumentRules(ctx, document, bag, options = {}) {
     if (!(0, index_1.isDraft07Schema)(document))
         throw new index_1.NotASchemaError(document);
+    // Before any keyword is read, and in the same place the function front door
+    // reads it: the dialect decides what the keywords below MEAN.
+    (0, index_1.assertSupportedDialect)(document, options);
     const root = document;
     const scope = (0, index_1.createDocumentScope)(root, options.externalDocuments ?? NO_EXTERNAL_DOCUMENTS);
     // The seed's `chain` is a ChainBuildContext, whose three members a

package/dist/json-schema/extensions/json-schema/json-schema.mjs

@@ -38,7 +38,7 @@
 import { branch, composite } from "../../../plugin-kit/create-rule.mjs";
 import { definePlugin } from "../../../plugin-kit/plugin-definition.mjs";
 import { PASS } from "../../../types/index.mjs";
-import { NotASchemaError, collectSubSchemaRules, createStructuralContext, createDocumentScope, isDraft07Schema, resolveSchemaNodeInScope, } from "../../index.mjs";
+import { NotASchemaError, assertSupportedDialect, collectSubSchemaRules, createStructuralContext, createDocumentScope, isDraft07Schema, resolveSchemaNodeInScope, } from "../../index.mjs";
 /** Every slot: a JSON Schema document constrains a value of any shape. */
 const SCHEMA_SLOTS = [
     "string",
@@ -62,6 +62,9 @@ const NO_EXTERNAL_DOCUMENTS = Object.freeze({});
 export function collectDocumentRules(ctx, document, bag, options = {}) {
     if (!isDraft07Schema(document))
         throw new NotASchemaError(document);
+    // Before any keyword is read, and in the same place the function front door
+    // reads it: the dialect decides what the keywords below MEAN.
+    assertSupportedDialect(document, options);
     const root = document;
     const scope = createDocumentScope(root, options.externalDocuments ?? NO_EXTERNAL_DOCUMENTS);
     // The seed's `chain` is a ChainBuildContext, whose three members a

package/dist/json-schema/extensions/json-schema-full-feature/index.d.ts

@@ -2,4 +2,6 @@ export { fromJsonSchema, jsonSchemaFullFeaturePlugin, } from "./json-schema-full
 export { jsonSchemaBag } from "./bundled-plugins";
 export { UNBOUND_BUNDLED_PLUGIN_NAMES, findStaleUnboundDeclarations, findUnbundledBoundPlugins, findUnexplainedBundledPlugins, listBundledPluginNames, } from "./bundle-coverage";
 export type { JsonSchemaOptions } from "../json-schema";
-export type { JsonSchemaBag } from "../../index";
+export { DRAFT07_DIALECT_URI, UnsupportedDialectError, } from "../../unsupported-dialect-error";
+export { MalformedSchemaError, NotASchemaError, RefResolutionError, UnsupportedKeywordError, } from "../../index";
+export type { DialectOptions, JsonSchemaBag } from "../../index";

package/dist/json-schema/extensions/json-schema-full-feature/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listBundledPluginNames = exports.findUnexplainedBundledPlugins = exports.findUnbundledBoundPlugins = exports.findStaleUnboundDeclarations = exports.UNBOUND_BUNDLED_PLUGIN_NAMES = exports.jsonSchemaBag = exports.jsonSchemaFullFeaturePlugin = exports.fromJsonSchema = void 0;
+exports.UnsupportedKeywordError = exports.RefResolutionError = exports.NotASchemaError = exports.MalformedSchemaError = exports.UnsupportedDialectError = exports.DRAFT07_DIALECT_URI = exports.listBundledPluginNames = exports.findUnexplainedBundledPlugins = exports.findUnbundledBoundPlugins = exports.findStaleUnboundDeclarations = exports.UNBOUND_BUNDLED_PLUGIN_NAMES = exports.jsonSchemaBag = exports.jsonSchemaFullFeaturePlugin = exports.fromJsonSchema = void 0;
 // ===========================================================================
 // The public subpath `@maroonedog/luq/plugins/jsonSchemaFullFeature`.
 // Re-exports only.
@@ -23,3 +23,20 @@ Object.defineProperty(exports, "findStaleUnboundDeclarations", { enumerable: tru
 Object.defineProperty(exports, "findUnbundledBoundPlugins", { enumerable: true, get: function () { return bundle_coverage_1.findUnbundledBoundPlugins; } });
 Object.defineProperty(exports, "findUnexplainedBundledPlugins", { enumerable: true, get: function () { return bundle_coverage_1.findUnexplainedBundledPlugins; } });
 Object.defineProperty(exports, "listBundledPluginNames", { enumerable: true, get: function () { return bundle_coverage_1.listBundledPluginNames; } });
+// Every error `fromJsonSchema` can throw, so a caller can tell them apart by
+// class rather than by reading the message.
+//
+// This subpath is the one-import route and the one the documentation points at,
+// which made it the worst place to be missing them: a document that is not
+// Draft-07 at all, one the meta-schema forbids, one carrying a keyword Luq
+// cannot honour and one that is not a schema are four different things to do
+// about it, and a caller who can only match on message text has to re-derive
+// that distinction from prose that is free to change.
+var unsupported_dialect_error_1 = require("../../unsupported-dialect-error");
+Object.defineProperty(exports, "DRAFT07_DIALECT_URI", { enumerable: true, get: function () { return unsupported_dialect_error_1.DRAFT07_DIALECT_URI; } });
+Object.defineProperty(exports, "UnsupportedDialectError", { enumerable: true, get: function () { return unsupported_dialect_error_1.UnsupportedDialectError; } });
+var index_1 = require("../../index");
+Object.defineProperty(exports, "MalformedSchemaError", { enumerable: true, get: function () { return index_1.MalformedSchemaError; } });
+Object.defineProperty(exports, "NotASchemaError", { enumerable: true, get: function () { return index_1.NotASchemaError; } });
+Object.defineProperty(exports, "RefResolutionError", { enumerable: true, get: function () { return index_1.RefResolutionError; } });
+Object.defineProperty(exports, "UnsupportedKeywordError", { enumerable: true, get: function () { return index_1.UnsupportedKeywordError; } });

package/dist/json-schema/extensions/json-schema-full-feature/index.mjs

@@ -12,3 +12,14 @@
 export { fromJsonSchema, jsonSchemaFullFeaturePlugin, } from "./json-schema-full-feature.mjs";
 export { jsonSchemaBag } from "./bundled-plugins.mjs";
 export { UNBOUND_BUNDLED_PLUGIN_NAMES, findStaleUnboundDeclarations, findUnbundledBoundPlugins, findUnexplainedBundledPlugins, listBundledPluginNames, } from "./bundle-coverage.mjs";
+// Every error `fromJsonSchema` can throw, so a caller can tell them apart by
+// class rather than by reading the message.
+//
+// This subpath is the one-import route and the one the documentation points at,
+// which made it the worst place to be missing them: a document that is not
+// Draft-07 at all, one the meta-schema forbids, one carrying a keyword Luq
+// cannot honour and one that is not a schema are four different things to do
+// about it, and a caller who can only match on message text has to re-derive
+// that distinction from prose that is free to change.
+export { DRAFT07_DIALECT_URI, UnsupportedDialectError, } from "../../unsupported-dialect-error.mjs";
+export { MalformedSchemaError, NotASchemaError, RefResolutionError, UnsupportedKeywordError, } from "../../index.mjs";

package/dist/json-schema/extensions/json-schema-full-feature/json-schema-full-feature.d.ts

@@ -1,6 +1,7 @@
 import type { MessageContextExtra, TypeName } from "../../../types";
 import type { Unchanged } from "../../../plugin-kit/marker.types";
 import type { JsonSchemaOptions } from "../json-schema";
+import type { DialectOptions } from "../../index";
 import type { GlobalConfig } from "../../../types/global-config";
 export declare const jsonSchemaFullFeaturePlugin: import("../../../plugin-kit/plugin-definition").PluginDefinition<"jsonSchemaFullFeature", "jsonSchemaFullFeature", readonly TypeName[], {
     args: readonly [document: unknown, options?: JsonSchemaOptions];
@@ -17,8 +18,15 @@ export declare const jsonSchemaFullFeaturePlugin: import("../../../plugin-kit/pl
  * NO declared path is checked — see build-from-schema.ts, which owns that
  * escape hatch and its single overload.
  *
+ * THE INPUT LIMIT IS DRAFT-07. A document whose root `$schema` names 2019-09 or
+ * 2020-12 is refused with an `UnsupportedDialectError` rather than read as
+ * Draft-07, because the dialects disagree about what unchanged keywords mean;
+ * a document with no `$schema` is read as Draft-07 as before. Pass
+ * `{ assumeDraft07: true }` as the third argument to take the Draft-07 reading
+ * deliberately. build-from-schema.ts states the divergence in full.
+ *
  * The return type is INFERRED rather than written: naming `Validator<T>` would
  * mean importing src/builder, which tier `extension` forbids. The inferred type
  * is that same `Validator<T>` and the type test asserts it.
  */
-export declare function fromJsonSchema<T extends object = Record<string, unknown>>(schema: unknown, config?: GlobalConfig): import("../../..").Validator<T, T>;
+export declare function fromJsonSchema<T extends object = Record<string, unknown>>(schema: unknown, config?: GlobalConfig, options?: DialectOptions): import("../../..").Validator<T, T>;

package/dist/json-schema/extensions/json-schema-full-feature/json-schema-full-feature.js

@@ -57,10 +57,17 @@ exports.jsonSchemaFullFeaturePlugin = (0, plugin_definition_1.definePlugin)()({
  * NO declared path is checked — see build-from-schema.ts, which owns that
  * escape hatch and its single overload.
  *
+ * THE INPUT LIMIT IS DRAFT-07. A document whose root `$schema` names 2019-09 or
+ * 2020-12 is refused with an `UnsupportedDialectError` rather than read as
+ * Draft-07, because the dialects disagree about what unchanged keywords mean;
+ * a document with no `$schema` is read as Draft-07 as before. Pass
+ * `{ assumeDraft07: true }` as the third argument to take the Draft-07 reading
+ * deliberately. build-from-schema.ts states the divergence in full.
+ *
  * The return type is INFERRED rather than written: naming `Validator<T>` would
  * mean importing src/builder, which tier `extension` forbids. The inferred type
  * is that same `Validator<T>` and the type test asserts it.
  */
-function fromJsonSchema(schema, config) {
-    return (0, index_1.fromJsonSchema)(bundled_plugins_1.jsonSchemaBag, schema, config);
+function fromJsonSchema(schema, config, options) {
+    return (0, index_1.fromJsonSchema)(bundled_plugins_1.jsonSchemaBag, schema, config, options);
 }

package/dist/json-schema/extensions/json-schema-full-feature/json-schema-full-feature.mjs

@@ -53,10 +53,17 @@ export const jsonSchemaFullFeaturePlugin = /*#__PURE__*/ definePlugin()({
  * NO declared path is checked — see build-from-schema.ts, which owns that
  * escape hatch and its single overload.
  *
+ * THE INPUT LIMIT IS DRAFT-07. A document whose root `$schema` names 2019-09 or
+ * 2020-12 is refused with an `UnsupportedDialectError` rather than read as
+ * Draft-07, because the dialects disagree about what unchanged keywords mean;
+ * a document with no `$schema` is read as Draft-07 as before. Pass
+ * `{ assumeDraft07: true }` as the third argument to take the Draft-07 reading
+ * deliberately. build-from-schema.ts states the divergence in full.
+ *
  * The return type is INFERRED rather than written: naming `Validator<T>` would
  * mean importing src/builder, which tier `extension` forbids. The inferred type
  * is that same `Validator<T>` and the type test asserts it.
  */
-export function fromJsonSchema(schema, config) {
-    return convertWithBag(jsonSchemaBag, schema, config);
+export function fromJsonSchema(schema, config, options) {
+    return convertWithBag(jsonSchemaBag, schema, config, options);
 }

package/dist/json-schema/index.d.ts

@@ -18,6 +18,9 @@ export type { SchemaRegistry } from "./schema-registry";
 export { createSchemaRegistry } from "./schema-registry";
 export { UnsupportedKeywordError } from "./unsupported-keyword-error";
 export { MalformedSchemaError } from "./malformed-schema-error";
+export { DRAFT07_DIALECT_URI, UnsupportedDialectError, } from "./unsupported-dialect-error";
+export { NON_DRAFT07_DIALECTS, assertSupportedDialect, } from "./assert-supported-dialect";
+export type { DialectOptions } from "./assert-supported-dialect";
 export { isDraft07Schema, isSchemaObject } from "./draft07.types";
 export type { Draft07Schema, Draft07SchemaObject, Draft07TypeKeyword, } from "./draft07.types";
 export { assertKeywordSupported, countKeywordHandlings, findKeywordHandling, isDraft07Keyword, listBoundPluginNames, listDraft07Keywords, } from "./keyword-map";

package/dist/json-schema/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listFormatNames = exports.findFormatHandling = exports.listDraft07Keywords = exports.listBoundPluginNames = exports.isDraft07Keyword = exports.findKeywordHandling = exports.countKeywordHandlings = exports.assertKeywordSupported = exports.isSchemaObject = exports.isDraft07Schema = exports.MalformedSchemaError = exports.UnsupportedKeywordError = exports.createSchemaRegistry = exports.createLocalScope = exports.createDocumentScope = exports.resolveRefInScope = exports.resolveRef = exports.isResolvableRef = exports.RefResolutionError = exports.declarePresenceRules = exports.declareRequiredProperties = exports.createStructuralContext = exports.toSchemaBranch = exports.collectSubSchemaRules = exports.readChildSchemas = exports.isStructuralKeyword = exports.expandSchemaRules = exports.STRUCTURAL_EXPANSIONS = exports.joinDeclaredPath = exports.flattenSchema = exports.toSchemaObject = exports.resolveSchemaNodeInScope = exports.resolveSchemaNode = exports.readRefPointer = exports.isDefinitionContainer = exports.collectDefinitionNames = exports.DEFINITION_CONTAINERS = exports.fromJsonSchema = exports.buildFromSchema = exports.buildFieldEntries = exports.NotASchemaError = void 0;
+exports.listFormatNames = exports.findFormatHandling = exports.listDraft07Keywords = exports.listBoundPluginNames = exports.isDraft07Keyword = exports.findKeywordHandling = exports.countKeywordHandlings = exports.assertKeywordSupported = exports.isSchemaObject = exports.isDraft07Schema = exports.assertSupportedDialect = exports.NON_DRAFT07_DIALECTS = exports.UnsupportedDialectError = exports.DRAFT07_DIALECT_URI = exports.MalformedSchemaError = exports.UnsupportedKeywordError = exports.createSchemaRegistry = exports.createLocalScope = exports.createDocumentScope = exports.resolveRefInScope = exports.resolveRef = exports.isResolvableRef = exports.RefResolutionError = exports.declarePresenceRules = exports.declareRequiredProperties = exports.createStructuralContext = exports.toSchemaBranch = exports.collectSubSchemaRules = exports.readChildSchemas = exports.isStructuralKeyword = exports.expandSchemaRules = exports.STRUCTURAL_EXPANSIONS = exports.joinDeclaredPath = exports.flattenSchema = exports.toSchemaObject = exports.resolveSchemaNodeInScope = exports.resolveSchemaNode = exports.readRefPointer = exports.isDefinitionContainer = exports.collectDefinitionNames = exports.DEFINITION_CONTAINERS = exports.fromJsonSchema = exports.buildFromSchema = exports.buildFieldEntries = exports.NotASchemaError = void 0;
 // ===========================================================================
 // L8  src/json-schema/index.ts — re-exports only. Nothing is defined here.
 //
@@ -52,6 +52,12 @@ var unsupported_keyword_error_1 = require("./unsupported-keyword-error");
 Object.defineProperty(exports, "UnsupportedKeywordError", { enumerable: true, get: function () { return unsupported_keyword_error_1.UnsupportedKeywordError; } });
 var malformed_schema_error_1 = require("./malformed-schema-error");
 Object.defineProperty(exports, "MalformedSchemaError", { enumerable: true, get: function () { return malformed_schema_error_1.MalformedSchemaError; } });
+var unsupported_dialect_error_1 = require("./unsupported-dialect-error");
+Object.defineProperty(exports, "DRAFT07_DIALECT_URI", { enumerable: true, get: function () { return unsupported_dialect_error_1.DRAFT07_DIALECT_URI; } });
+Object.defineProperty(exports, "UnsupportedDialectError", { enumerable: true, get: function () { return unsupported_dialect_error_1.UnsupportedDialectError; } });
+var assert_supported_dialect_1 = require("./assert-supported-dialect");
+Object.defineProperty(exports, "NON_DRAFT07_DIALECTS", { enumerable: true, get: function () { return assert_supported_dialect_1.NON_DRAFT07_DIALECTS; } });
+Object.defineProperty(exports, "assertSupportedDialect", { enumerable: true, get: function () { return assert_supported_dialect_1.assertSupportedDialect; } });
 var draft07_types_1 = require("./draft07.types");
 Object.defineProperty(exports, "isDraft07Schema", { enumerable: true, get: function () { return draft07_types_1.isDraft07Schema; } });
 Object.defineProperty(exports, "isSchemaObject", { enumerable: true, get: function () { return draft07_types_1.isSchemaObject; } });

package/dist/json-schema/index.mjs

@@ -18,6 +18,8 @@ export { createDocumentScope, createLocalScope } from "./ref-scope.mjs";
 export { createSchemaRegistry } from "./schema-registry.mjs";
 export { UnsupportedKeywordError } from "./unsupported-keyword-error.mjs";
 export { MalformedSchemaError } from "./malformed-schema-error.mjs";
+export { DRAFT07_DIALECT_URI, UnsupportedDialectError, } from "./unsupported-dialect-error.mjs";
+export { NON_DRAFT07_DIALECTS, assertSupportedDialect, } from "./assert-supported-dialect.mjs";
 export { isDraft07Schema, isSchemaObject } from "./draft07.types.mjs";
 export { assertKeywordSupported, countKeywordHandlings, findKeywordHandling, isDraft07Keyword, listBoundPluginNames, listDraft07Keywords, } from "./keyword-map.mjs";
 export { findFormatHandling, listFormatNames } from "./format-map.mjs";

package/dist/json-schema/keyword-map-core.js

@@ -25,7 +25,9 @@ const ANNOTATION_ONLY = "an annotation with no validation effect in Draft-07";
  */
 exports.constBinding = (0, bind_keyword_1.bindKeyword)("any", "literal", literal_1.literalPlugin, (v) => [v]);
 exports.coreKeywordMap = {
-    $schema: (0, bind_keyword_1.unsupported)("read and discarded: Luq targets Draft-07 and does not switch dialect"),
+    $schema: (0, bind_keyword_1.unsupported)("read at the document ROOT by assert-supported-dialect and then " +
+        "discarded: Luq implements Draft-07 and never switches dialect, so a " +
+        "root `$schema` naming another one is refused rather than ignored"),
     $id: (0, bind_keyword_1.unsupported)("no base-URI resolution; resolve-ref accepts local $ref only"),
     $comment: (0, bind_keyword_1.unsupported)(ANNOTATION_ONLY),
     $ref: (0, bind_keyword_1.structural)("resolved by resolve-ref before any keyword is read"),

package/dist/json-schema/keyword-map-core.mjs

@@ -22,7 +22,9 @@ const ANNOTATION_ONLY = "an annotation with no validation effect in Draft-07";
  */
 export const constBinding = bindKeyword("any", "literal", literalPlugin, (v) => [v]);
 export const coreKeywordMap = {
-    $schema: unsupported("read and discarded: Luq targets Draft-07 and does not switch dialect"),
+    $schema: unsupported("read at the document ROOT by assert-supported-dialect and then " +
+        "discarded: Luq implements Draft-07 and never switches dialect, so a " +
+        "root `$schema` naming another one is refused rather than ignored"),
     $id: unsupported("no base-URI resolution; resolve-ref accepts local $ref only"),
     $comment: unsupported(ANNOTATION_ONLY),
     $ref: structural("resolved by resolve-ref before any keyword is read"),

package/dist/json-schema/keyword-map.js

@@ -32,7 +32,10 @@ exports.NON_DRAFT07_KEYWORDS = {
     $defs: "2019-09 spelling of `definitions`; resolve-ref follows it anyway",
     $anchor: "2019-09 anchors; resolve-ref resolves JSON Pointers only",
     $dynamicRef: "2020-12 dynamic references",
+    $dynamicAnchor: "2020-12 dynamic anchors; the target half of $dynamicRef",
     $recursiveRef: "2019-09 recursive references",
+    $recursiveAnchor: "2019-09 recursive anchors; the target half of $recursiveRef",
+    $vocabulary: "2019-09 vocabulary declaration; Luq has one fixed vocabulary",
     dependentRequired: "2019-09 split of `dependencies`; use `dependencies`",
     dependentSchemas: "2019-09 split of `dependencies`; use `dependencies`",
     minContains: "2019-09 bound on `contains`; Draft-07's is fixed at one",

package/dist/json-schema/keyword-map.mjs

@@ -23,7 +23,10 @@ export const NON_DRAFT07_KEYWORDS = {
     $defs: "2019-09 spelling of `definitions`; resolve-ref follows it anyway",
     $anchor: "2019-09 anchors; resolve-ref resolves JSON Pointers only",
     $dynamicRef: "2020-12 dynamic references",
+    $dynamicAnchor: "2020-12 dynamic anchors; the target half of $dynamicRef",
     $recursiveRef: "2019-09 recursive references",
+    $recursiveAnchor: "2019-09 recursive anchors; the target half of $recursiveRef",
+    $vocabulary: "2019-09 vocabulary declaration; Luq has one fixed vocabulary",
     dependentRequired: "2019-09 split of `dependencies`; use `dependencies`",
     dependentSchemas: "2019-09 split of `dependencies`; use `dependencies`",
     minContains: "2019-09 bound on `contains`; Draft-07's is fixed at one",

package/dist/json-schema/unsupported-dialect-error.d.ts

@@ -0,0 +1,21 @@
+/** The dialect this library implements, in the spelling the draft publishes. */
+export declare const DRAFT07_DIALECT_URI = "http://json-schema.org/draft-07/schema#";
+/**
+ * Raised when a document's root `$schema` names a dialect Luq does not
+ * implement. Thrown at build time, before a validator that would read the
+ * document under the wrong dialect's rules can exist.
+ *
+ * `reason` follows the convention the other two refusals use: a sentence
+ * fragment with no terminal punctuation, saying what the dialect does that
+ * Draft-07 does not, so that two refusals from two different dialects read as
+ * one library rather than as two unrelated messages.
+ */
+export declare class UnsupportedDialectError extends Error {
+    /** The `$schema` value the document wrote, verbatim. */
+    readonly declared: string;
+    /** The dialect Luq reads every document under. */
+    readonly implemented: string;
+    /** What that dialect does differently, or that it is unrecognised. */
+    readonly reason: string;
+    constructor(declared: string, reason: string);
+}

package/dist/json-schema/unsupported-dialect-error.js

@@ -0,0 +1,58 @@
+"use strict";
+// ===========================================================================
+// L8  src/json-schema/unsupported-dialect-error.ts
+//
+// The third refusal, and the only one with no keyword to hang on.
+// UnsupportedKeywordError refuses a keyword NAME; MalformedSchemaError refuses
+// a keyword VALUE. Both need the document to write something recognisable, and
+// there is one divergence that writes nothing at all:
+//
+//     {"$schema": "https://json-schema.org/draft/2020-12/schema",
+//      "$defs": {"name": {"type": "string"}},
+//      "properties": {"nick": {"$ref": "#/$defs/name", "minLength": 5}}}
+//
+// Every keyword there is a Draft-07 keyword spelled the Draft-07 way, so the
+// keyword table sees nothing to refuse. The meaning is not Draft-07: §8.3 has
+// `$ref` REPLACE the object it appears in, and from 2019-09 on `$ref` is an
+// ordinary applicator whose siblings are applied. Read as Draft-07 the document
+// above builds a validator that accepts `{"nick":"ab"}` — the `minLength` is
+// gone, silently, and nothing in the result says a constraint went missing.
+// `$schema` is the only signal the document offers, so it is the one read.
+//
+// It stays a separate class from the other two, neither extending the other,
+// for the reason written in malformed-schema-error.ts: each answers a different
+// question. "Luq cannot honour this keyword", "this document is not valid
+// Draft-07", and now "this document is not Draft-07 AT ALL" are three distinct
+// facts, and a caller catching one must not silently catch another.
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedDialectError = exports.DRAFT07_DIALECT_URI = void 0;
+/** The dialect this library implements, in the spelling the draft publishes. */
+exports.DRAFT07_DIALECT_URI = "http://json-schema.org/draft-07/schema#";
+/**
+ * Raised when a document's root `$schema` names a dialect Luq does not
+ * implement. Thrown at build time, before a validator that would read the
+ * document under the wrong dialect's rules can exist.
+ *
+ * `reason` follows the convention the other two refusals use: a sentence
+ * fragment with no terminal punctuation, saying what the dialect does that
+ * Draft-07 does not, so that two refusals from two different dialects read as
+ * one library rather than as two unrelated messages.
+ */
+class UnsupportedDialectError extends Error {
+    constructor(declared, reason) {
+        super(`JSON Schema dialect "${declared}" is not supported: ${reason}. Luq ` +
+            `implements Draft-07 (${exports.DRAFT07_DIALECT_URI}) and would read this ` +
+            "document under Draft-07 rules, which can enforce less than it " +
+            "states. Convert the document to Draft-07, or pass " +
+            "`{ assumeDraft07: true }` to take the Draft-07 reading deliberately.");
+        /** The dialect Luq reads every document under. */
+        this.implemented = exports.DRAFT07_DIALECT_URI;
+        this.name = "UnsupportedDialectError";
+        this.declared = declared;
+        this.reason = reason;
+        // Without this, `instanceof` fails when the package is compiled to ES5.
+        Object.setPrototypeOf(this, UnsupportedDialectError.prototype);
+    }
+}
+exports.UnsupportedDialectError = UnsupportedDialectError;

package/dist/json-schema/unsupported-dialect-error.mjs

@@ -0,0 +1,54 @@
+// ===========================================================================
+// L8  src/json-schema/unsupported-dialect-error.ts
+//
+// The third refusal, and the only one with no keyword to hang on.
+// UnsupportedKeywordError refuses a keyword NAME; MalformedSchemaError refuses
+// a keyword VALUE. Both need the document to write something recognisable, and
+// there is one divergence that writes nothing at all:
+//
+//     {"$schema": "https://json-schema.org/draft/2020-12/schema",
+//      "$defs": {"name": {"type": "string"}},
+//      "properties": {"nick": {"$ref": "#/$defs/name", "minLength": 5}}}
+//
+// Every keyword there is a Draft-07 keyword spelled the Draft-07 way, so the
+// keyword table sees nothing to refuse. The meaning is not Draft-07: §8.3 has
+// `$ref` REPLACE the object it appears in, and from 2019-09 on `$ref` is an
+// ordinary applicator whose siblings are applied. Read as Draft-07 the document
+// above builds a validator that accepts `{"nick":"ab"}` — the `minLength` is
+// gone, silently, and nothing in the result says a constraint went missing.
+// `$schema` is the only signal the document offers, so it is the one read.
+//
+// It stays a separate class from the other two, neither extending the other,
+// for the reason written in malformed-schema-error.ts: each answers a different
+// question. "Luq cannot honour this keyword", "this document is not valid
+// Draft-07", and now "this document is not Draft-07 AT ALL" are three distinct
+// facts, and a caller catching one must not silently catch another.
+// ===========================================================================
+/** The dialect this library implements, in the spelling the draft publishes. */
+export const DRAFT07_DIALECT_URI = "http://json-schema.org/draft-07/schema#";
+/**
+ * Raised when a document's root `$schema` names a dialect Luq does not
+ * implement. Thrown at build time, before a validator that would read the
+ * document under the wrong dialect's rules can exist.
+ *
+ * `reason` follows the convention the other two refusals use: a sentence
+ * fragment with no terminal punctuation, saying what the dialect does that
+ * Draft-07 does not, so that two refusals from two different dialects read as
+ * one library rather than as two unrelated messages.
+ */
+export class UnsupportedDialectError extends Error {
+    constructor(declared, reason) {
+        super(`JSON Schema dialect "${declared}" is not supported: ${reason}. Luq ` +
+            `implements Draft-07 (${DRAFT07_DIALECT_URI}) and would read this ` +
+            "document under Draft-07 rules, which can enforce less than it " +
+            "states. Convert the document to Draft-07, or pass " +
+            "`{ assumeDraft07: true }` to take the Draft-07 reading deliberately.");
+        /** The dialect Luq reads every document under. */
+        this.implemented = DRAFT07_DIALECT_URI;
+        this.name = "UnsupportedDialectError";
+        this.declared = declared;
+        this.reason = reason;
+        // Without this, `instanceof` fails when the package is compiled to ES5.
+        Object.setPrototypeOf(this, UnsupportedDialectError.prototype);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maroonedog/luq",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Universal Model & API Definition Platform - TypeScript validation library evolving into cross-language code generation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -459,18 +459,20 @@
     "typecheck:src": "tsc --noEmit -p tsconfig.json",
     "typecheck:scripts": "tsc --noEmit -p scripts/tsconfig.json",
     "typecheck:bench": "tsc --noEmit -p bench/tsconfig.json",
-    "generate": "npm run generate:sources && npm run generate:exports && npm run generate:lock",
+    "generate": "npm run generate:sources && npm run generate:exports && npm run generate:lock && npm run generate:issue-codes",
     "generate:sources": "npm run generate:manifest && npm run generate:barrel && npm run generate:slot-catalog",
     "generate:slot-catalog": "npx ts-node --project scripts/tsconfig.json scripts/generate-slot-catalog.ts",
     "generate:manifest": "npx ts-node --project scripts/tsconfig.json scripts/generate-plugin-manifest.ts",
     "generate:barrel": "npx ts-node --project scripts/tsconfig.json scripts/generate-plugin-barrel.ts",
     "generate:exports": "npx ts-node --project scripts/tsconfig.json scripts/generate-package-exports.ts",
     "generate:lock": "npx ts-node --project scripts/tsconfig.json scripts/generate-plugin-catalog.ts",
+    "generate:issue-codes": "npx ts-node --project scripts/tsconfig.json scripts/generate-issue-code-catalog.ts",
     "check:exports": "npx ts-node --project scripts/tsconfig.json scripts/check-exports.ts --mode=exact",
     "check:catalog-lock": "npx ts-node --project scripts/tsconfig.json scripts/check-catalog-lock.ts",
+    "check:issue-code-lock": "npx ts-node --project scripts/tsconfig.json scripts/check-issue-code-lock.ts",
     "check:plugin-isolation": "npx ts-node --project scripts/tsconfig.json scripts/check-plugin-isolation.ts",
     "check:plugin-uniqueness": "npx ts-node --project scripts/tsconfig.json scripts/check-plugin-uniqueness.ts",
-    "check:catalog": "npm run check:plugin-uniqueness && npm run check:plugin-isolation && npm run check:exports && npm run check:catalog-lock",
+    "check:catalog": "npm run check:plugin-uniqueness && npm run check:plugin-isolation && npm run check:exports && npm run check:catalog-lock && npm run check:issue-code-lock",
     "check:size": "npx ts-node --project scripts/tsconfig.json scripts/measure-bundle-size.ts",
     "check:barrel-equivalence": "npx ts-node --project scripts/tsconfig.json scripts/check-barrel-equivalence.ts",
     "check:no-dynamic-code": "npx ts-node --project scripts/tsconfig.json scripts/check-no-dynamic-code.ts",
@@ -493,6 +495,7 @@
     "check:conformance-figures": "npx ts-node --project scripts/tsconfig.json scripts/check-conformance-figures.ts",
     "bench:competitors": "npx ts-node --project bench/tsconfig.json bench/competitors/report-competitors.ts",
     "bench:competitors:check": "npx ts-node --project bench/tsconfig.json bench/competitors/check-competitors.ts",
+    "bench:megamorphism": "npx ts-node --project bench/tsconfig.json bench/megamorphism/report-megamorphism.ts",
     "lint:ox": "oxlint -c .oxlintrc.json src bench",
     "lint:naming": "eslint \"src/**/*.ts\" \"bench/**/*.ts\"",
     "generate:perf-figures": "npx ts-node --project scripts/tsconfig.json scripts/check-perf-figures.ts --write",