@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/json-schema/json-schema-bag.types.d.ts

@@ -0,0 +1,124 @@
+import type { TypeName } from "../types";
+import type { IsMarkerFree } from "../plugin-kit/marker.types";
+import type { PluginArgs, PluginDefinition, PluginSignature } from "../plugin-kit/plugin-definition";
+import type { SlotPlugins } from "../chain/plugin-bag.types";
+import { requiredPlugin } from "../plugins/required";
+import { compareFieldPlugin } from "../plugins/compare-field";
+import { numberMinPlugin } from "../plugins/number-min";
+import { stringMinPlugin } from "../plugins/string-min";
+import { arrayEachPlugin } from "../plugins/array-each";
+import { conditionalSchemaPlugin } from "../plugins/conditional-schema";
+import { arrayMaxLengthPlugin } from "../plugins/array-max-length";
+import { arrayMinLengthPlugin } from "../plugins/array-min-length";
+import { arrayUniquePlugin } from "../plugins/array-unique";
+import { numberMaxPlugin } from "../plugins/number-max";
+import { stringMaxPlugin } from "../plugins/string-max";
+import { stringPatternPlugin } from "../plugins/string-pattern";
+import { literalPlugin } from "../plugins/literal";
+import { oneOfPlugin } from "../plugins/one-of";
+import { objectAdditionalPropertiesPlugin } from "../plugins/object-additional-properties";
+import { objectPatternPropertiesPlugin } from "../plugins/object-pattern-properties";
+import { objectPropertyNamesPlugin } from "../plugins/object-property-names";
+import { numberIntegerPlugin } from "../plugins/number-integer";
+import { numberMultipleOfPlugin } from "../plugins/number-multiple-of";
+import { objectMinPropertiesPlugin } from "../plugins/object-min-properties";
+import { objectMaxPropertiesPlugin } from "../plugins/object-max-properties";
+import { objectAdditionalPropertiesSchemaPlugin } from "../plugins/object-additional-properties";
+import { objectDependentRequiredPlugin } from "../plugins/object-dependent-required";
+import { objectDependentSchemasPlugin } from "../plugins/object-dependent-schemas";
+import { arrayContainsPlugin } from "../plugins/array-contains";
+import { tupleBuilderPlugin } from "../plugins/tuple-builder";
+import { optionalPlugin } from "../plugins/optional";
+import { nullablePlugin } from "../plugins/nullable";
+import { stringContentEncodingPlugin } from "../plugins/string-content-encoding";
+import { stringContentMediaTypePlugin } from "../plugins/string-content-media-type";
+import { stringDatePlugin } from "../plugins/string-date";
+import { stringDatetimePlugin } from "../plugins/string-datetime";
+import { stringDurationPlugin } from "../plugins/string-duration";
+import { stringEmailPlugin } from "../plugins/string-email";
+import { stringHostnamePlugin } from "../plugins/string-hostname";
+import { stringIdnEmailPlugin } from "../plugins/string-idn-email";
+import { stringIdnHostnamePlugin } from "../plugins/string-idn-hostname";
+import { stringIpv4Plugin } from "../plugins/string-ipv4";
+import { stringIpv6Plugin } from "../plugins/string-ipv6";
+import { stringIriPlugin } from "../plugins/string-iri";
+import { stringIriReferencePlugin } from "../plugins/string-iri-reference";
+import { stringJsonPointerPlugin } from "../plugins/string-json-pointer";
+import { stringRelativeJsonPointerPlugin } from "../plugins/string-relative-json-pointer";
+import { stringTimePlugin } from "../plugins/string-time";
+import { stringUriTemplatePlugin } from "../plugins/string-uri-template";
+import { stringUrlPlugin } from "../plugins/string-url";
+import { stringRegexPlugin } from "../plugins/string-regex";
+import { stringUriReferencePlugin } from "../plugins/string-uri-reference";
+import { uuidPlugin } from "../plugins/uuid";
+/** The concrete bag `jsonSchemaFullFeature` installs. See the note above. */
+export type JsonSchemaBag = {
+    readonly required: typeof requiredPlugin;
+    readonly optional: typeof optionalPlugin;
+    readonly nullable: typeof nullablePlugin;
+    readonly literal: typeof literalPlugin;
+    readonly stringMin: typeof stringMinPlugin;
+    readonly stringMax: typeof stringMaxPlugin;
+    readonly stringPattern: typeof stringPatternPlugin;
+    readonly stringContentEncoding: typeof stringContentEncodingPlugin;
+    readonly stringContentMediaType: typeof stringContentMediaTypePlugin;
+    readonly numberMin: typeof numberMinPlugin;
+    readonly numberMax: typeof numberMaxPlugin;
+    readonly numberInteger: typeof numberIntegerPlugin;
+    readonly numberMultipleOf: typeof numberMultipleOfPlugin;
+    readonly arrayMinLength: typeof arrayMinLengthPlugin;
+    readonly arrayMaxLength: typeof arrayMaxLengthPlugin;
+    readonly arrayUnique: typeof arrayUniquePlugin;
+    readonly objectMinProperties: typeof objectMinPropertiesPlugin;
+    readonly objectMaxProperties: typeof objectMaxPropertiesPlugin;
+    readonly stringDate: typeof stringDatePlugin;
+    readonly stringDatetime: typeof stringDatetimePlugin;
+    readonly stringTime: typeof stringTimePlugin;
+    readonly stringDuration: typeof stringDurationPlugin;
+    readonly stringEmail: typeof stringEmailPlugin;
+    readonly stringHostname: typeof stringHostnamePlugin;
+    readonly stringIdnEmail: typeof stringIdnEmailPlugin;
+    readonly stringIdnHostname: typeof stringIdnHostnamePlugin;
+    readonly stringRegex: typeof stringRegexPlugin;
+    readonly stringUriReference: typeof stringUriReferencePlugin;
+    readonly stringIpv4: typeof stringIpv4Plugin;
+    readonly stringIpv6: typeof stringIpv6Plugin;
+    readonly stringUrl: typeof stringUrlPlugin;
+    readonly stringIri: typeof stringIriPlugin;
+    readonly stringIriReference: typeof stringIriReferencePlugin;
+    readonly stringUriTemplate: typeof stringUriTemplatePlugin;
+    readonly stringJsonPointer: typeof stringJsonPointerPlugin;
+    readonly stringRelativeJsonPointer: typeof stringRelativeJsonPointerPlugin;
+    readonly uuid: typeof uuidPlugin;
+    readonly oneOf: typeof oneOfPlugin;
+    readonly objectAdditionalProperties: typeof objectAdditionalPropertiesPlugin;
+    readonly objectAdditionalPropertiesSchema: typeof objectAdditionalPropertiesSchemaPlugin;
+    readonly objectPatternProperties: typeof objectPatternPropertiesPlugin;
+    readonly objectPropertyNames: typeof objectPropertyNamesPlugin;
+    readonly objectDependentRequired: typeof objectDependentRequiredPlugin;
+    readonly objectDependentSchemas: typeof objectDependentSchemasPlugin;
+    readonly arrayEach: typeof arrayEachPlugin;
+    readonly arrayContains: typeof arrayContainsPlugin;
+    readonly tupleBuilder: typeof tupleBuilderPlugin;
+    readonly conditionalSchema: typeof conditionalSchemaPlugin;
+    readonly compareField: typeof compareFieldPlugin;
+};
+/** Every method name reachable on the bag's chain for slot S. */
+export type BoundMethod<S extends TypeName> = keyof SlotPlugins<JsonSchemaBag, S> & string;
+/** A total lookup: a direct index would be TS2536 under a generic S. */
+export type BoundPlugin<S extends TypeName, M> = SlotPlugins<JsonSchemaBag, S> extends infer Slot ? M extends keyof Slot ? Slot[M] : never : never;
+export type NameOf<P> = P extends {
+    readonly name: infer N extends string;
+} ? N : never;
+/** PluginArgs re-stated so it satisfies a `readonly unknown[]` constraint. */
+export type ArgsOf<P> = PluginArgs<P> extends infer A extends readonly unknown[] ? A : never;
+/** Marker-freeness is expressed through IsMarkerFree, which lives beside the
+ *  marker registry, so a new marker cannot silently widen it. */
+export type MarkerFreePlugin<P> = P extends PluginDefinition<string, string, readonly TypeName[], infer Sig extends PluginSignature> ? IsMarkerFree<Sig["args"]> extends true ? P : never : never;
+export type JsonSchemaPlugin = MarkerFreePlugin<JsonSchemaBag[keyof JsonSchemaBag]>;
+/** An argument tuple a JSON document can supply: `never` when it carries a marker. */
+export type MarkerFreeArgs<A extends readonly unknown[]> = IsMarkerFree<A> extends true ? A : never;
+/** The methods of slot S a keyword may bind to: reachable AND marker-free. */
+export type BindableMethod<S extends TypeName> = {
+    [M in BoundMethod<S>]: [MarkerFreePlugin<BoundPlugin<S, M>>] extends [never] ? never : M;
+}[BoundMethod<S>];

package/dist/json-schema/json-schema-bag.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/json-schema/json-schema-bag.types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/json-schema/keyword-binding.types.d.ts

@@ -0,0 +1,50 @@
+import type { TypeName } from "../types";
+import type { ArgsOf, BindableMethod, BoundMethod, BoundPlugin, NameOf } from "./json-schema-bag.types";
+import type { Draft07Keyword, Draft07KeywordValues } from "./draft07-keyword-value.types";
+/**
+ * One JSON Schema keyword bound to one chain method.
+ *
+ * Nothing here is looked up in the plugin registry: every identifier arrives as
+ * a type argument, inferred by `bindKeyword` from the plugin object itself.
+ * `M extends BoundMethod<S>` is the ONLY registry contact, and it is a
+ * constraint (a gate), not a derivation (a computation) — which is what lets
+ * the type be written by hand and still be checked.
+ */
+export interface KeywordBinding<S extends TypeName, M extends BoundMethod<S>, TName extends string, TArgs extends readonly unknown[], V> {
+    readonly handling: "bind";
+    readonly slot: S;
+    readonly method: M;
+    readonly pluginName: TName;
+    toArguments(keywordValue: V): TArgs;
+}
+/** Consumer-side alias: S and M are concrete here, so the registry resolves. */
+export type BindingForMethod<S extends TypeName, M extends BoundMethod<S>, V> = KeywordBinding<S, M, NameOf<BoundPlugin<S, M>>, ArgsOf<BoundPlugin<S, M>>, V>;
+/** Any binding a Draft-07 keyword may legally hold: reachable and marker-free. */
+export type AnyKeywordBinding<V = never> = {
+    [S in TypeName]: {
+        [M in BindableMethod<S> & BoundMethod<S>]: BindingForMethod<S, M, V>;
+    }[BindableMethod<S> & BoundMethod<S>];
+}[TypeName];
+/** The keyword shapes the CONVERTER handles itself (recursion, slot choice). */
+export interface StructuralKeyword {
+    readonly handling: "structural";
+    readonly note: string;
+}
+/** Declared out of scope, in writing. The legacy code just ignored these. */
+export interface UnsupportedKeyword {
+    readonly handling: "unsupported";
+    readonly reason: string;
+}
+export type KeywordHandlingFor<V> = AnyKeywordBinding<V> | StructuralKeyword | UnsupportedKeyword;
+/** The one decision a keyword table may record, whatever the keyword. */
+export type AnyKeywordHandling = KeywordHandlingFor<never>;
+/**
+ * A category table: EVERY keyword of the category, each carrying a handling
+ * for that keyword's own normalised value type. Because the mapped type is
+ * total over `K`, a forgotten keyword is TS2739 and a keyword that is not in
+ * the Draft-07 vocabulary is an excess property — both compile errors, which
+ * is the whole point of writing the vocabulary down.
+ */
+export type KeywordTable<K extends Draft07Keyword> = {
+    readonly [Keyword in K]: KeywordHandlingFor<Draft07KeywordValues[Keyword]>;
+};

package/dist/json-schema/keyword-binding.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/json-schema/keyword-binding.types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/json-schema/keyword-map-array.d.ts

@@ -0,0 +1,13 @@
+import type { KeywordTable } from "./keyword-binding.types";
+import type { Draft07ArrayKeyword } from "./draft07-keyword-value.types";
+export declare const minItemsBinding: import("./keyword-binding.types").KeywordBinding<"array", "minLength", "arrayMinLength", readonly [min: number], number>;
+export declare const maxItemsBinding: import("./keyword-binding.types").KeywordBinding<"array", "maxLength", "arrayMaxLength", readonly [max: number], number>;
+/**
+ * The value type is `true`, not `boolean`. Draft-07 §6.4.3 defines
+ * `uniqueItems: false` as imposing no constraint, so applying this binding for
+ * `false` would add a rule the document does not state. The converter cannot
+ * reach the binding without narrowing to `true` first — the compiler, not a
+ * comment, is what enforces the no-op.
+ */
+export declare const uniqueItemsBinding: import("./keyword-binding.types").KeywordBinding<"array", "unique", "arrayUnique", readonly [], true>;
+export declare const arrayKeywordMap: KeywordTable<Draft07ArrayKeyword>;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayKeywordMap = exports.uniqueItemsBinding = exports.maxItemsBinding = exports.minItemsBinding = void 0;
+// ===========================================================================
+// L8  src/json-schema/keyword-map-array.ts — the six array keywords.
+//
+// THE C2 REGRESSION LIVES HERE, and is fixed by one word per entry: the
+// Draft-07 keyword is `minItems`, the chain method is `minLength`. 1.x wrote
+// `if (constraints.minItems !== undefined && chain.minItems) chain.minItems(n)`
+// — `minItems` is not a chain method, the guard was false, and the constraint
+// evaporated with no error at build time or run time. Writing "minItems" as
+// the method below does not compile; the type test flips exactly that word.
+// ===========================================================================
+const bind_keyword_1 = require("./bind-keyword");
+const array_min_length_1 = require("../plugins/array-min-length");
+const array_max_length_1 = require("../plugins/array-max-length");
+const array_unique_1 = require("../plugins/array-unique");
+exports.minItemsBinding = (0, bind_keyword_1.bindKeyword)("array", "minLength", array_min_length_1.arrayMinLengthPlugin, (v) => [v]);
+exports.maxItemsBinding = (0, bind_keyword_1.bindKeyword)("array", "maxLength", array_max_length_1.arrayMaxLengthPlugin, (v) => [v]);
+/**
+ * The value type is `true`, not `boolean`. Draft-07 §6.4.3 defines
+ * `uniqueItems: false` as imposing no constraint, so applying this binding for
+ * `false` would add a rule the document does not state. The converter cannot
+ * reach the binding without narrowing to `true` first — the compiler, not a
+ * comment, is what enforces the no-op.
+ */
+exports.uniqueItemsBinding = (0, bind_keyword_1.bindKeyword)("array", "unique", array_unique_1.arrayUniquePlugin, (_v) => []);
+exports.arrayKeywordMap = {
+    items: (0, bind_keyword_1.structural)("a single sub-schema becomes one sub-chain through .each(); the TUPLE " +
+        "form drives tupleBuilder's .builder(), whose method is `builder` and " +
+        "never `tupleBuilder` — the third name 1.x guessed wrong"),
+    additionalItems: (0, bind_keyword_1.structural)("the rest sub-chain of .builder(); meaningful only beside a tuple `items`"),
+    maxItems: exports.maxItemsBinding,
+    minItems: exports.minItemsBinding,
+    uniqueItems: exports.uniqueItemsBinding,
+    contains: (0, bind_keyword_1.structural)("a sub-chain applied existentially; arrayContains takes an ElementChain"),
+};

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

@@ -0,0 +1,34 @@
+// ===========================================================================
+// L8  src/json-schema/keyword-map-array.ts — the six array keywords.
+//
+// THE C2 REGRESSION LIVES HERE, and is fixed by one word per entry: the
+// Draft-07 keyword is `minItems`, the chain method is `minLength`. 1.x wrote
+// `if (constraints.minItems !== undefined && chain.minItems) chain.minItems(n)`
+// — `minItems` is not a chain method, the guard was false, and the constraint
+// evaporated with no error at build time or run time. Writing "minItems" as
+// the method below does not compile; the type test flips exactly that word.
+// ===========================================================================
+import { bindKeyword, structural } from "./bind-keyword.mjs";
+import { arrayMinLengthPlugin } from "../plugins/array-min-length/index.mjs";
+import { arrayMaxLengthPlugin } from "../plugins/array-max-length/index.mjs";
+import { arrayUniquePlugin } from "../plugins/array-unique/index.mjs";
+export const minItemsBinding = bindKeyword("array", "minLength", arrayMinLengthPlugin, (v) => [v]);
+export const maxItemsBinding = bindKeyword("array", "maxLength", arrayMaxLengthPlugin, (v) => [v]);
+/**
+ * The value type is `true`, not `boolean`. Draft-07 §6.4.3 defines
+ * `uniqueItems: false` as imposing no constraint, so applying this binding for
+ * `false` would add a rule the document does not state. The converter cannot
+ * reach the binding without narrowing to `true` first — the compiler, not a
+ * comment, is what enforces the no-op.
+ */
+export const uniqueItemsBinding = bindKeyword("array", "unique", arrayUniquePlugin, (_v) => []);
+export const arrayKeywordMap = {
+    items: structural("a single sub-schema becomes one sub-chain through .each(); the TUPLE " +
+        "form drives tupleBuilder's .builder(), whose method is `builder` and " +
+        "never `tupleBuilder` — the third name 1.x guessed wrong"),
+    additionalItems: structural("the rest sub-chain of .builder(); meaningful only beside a tuple `items`"),
+    maxItems: maxItemsBinding,
+    minItems: minItemsBinding,
+    uniqueItems: uniqueItemsBinding,
+    contains: structural("a sub-chain applied existentially; arrayContains takes an ElementChain"),
+};

package/dist/json-schema/keyword-map-core.d.ts

@@ -0,0 +1,8 @@
+import type { KeywordTable } from "./keyword-binding.types";
+import type { Draft07CoreKeyword } from "./draft07-keyword-value.types";
+/**
+ * `const` reaches every slot: literalPlugin's `slots` is the whole TypeName
+ * list, so `.literal()` is on the "any" chain as well as on each typed one.
+ */
+export declare const constBinding: import("./keyword-binding.types").KeywordBinding<"any", "literal", "literal", readonly [expected: unknown], unknown>;
+export declare const coreKeywordMap: KeywordTable<Draft07CoreKeyword>;

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coreKeywordMap = exports.constBinding = void 0;
+// ===========================================================================
+// L8  src/json-schema/keyword-map-core.ts — the 21 keywords that belong to no
+// single Luq slot: document plumbing, annotations, the any-instance keywords
+// and the applicators.
+//
+// Every entry is one of three written decisions and there is NO fall-through:
+//   bind        a chain method, with the method name checked by the compiler.
+//   structural  the CONVERTER expands it (it recurses, or it picks the slot).
+//               A sub-schema becomes a sub-CHAIN, which is a marker argument,
+//               so such a keyword can never be a binding — bindKeyword rejects
+//               it and the type test proves the rejection.
+//   unsupported out of scope, in writing, with the reason. 1.x stored eleven
+//               keywords it never read again; that is the failure this table
+//               exists to make impossible.
+// ===========================================================================
+const bind_keyword_1 = require("./bind-keyword");
+const literal_1 = require("../plugins/literal");
+const ANNOTATION_ONLY = "an annotation with no validation effect in Draft-07";
+/**
+ * `const` reaches every slot: literalPlugin's `slots` is the whole TypeName
+ * list, so `.literal()` is on the "any" chain as well as on each typed one.
+ */
+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"),
+    $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"),
+    definitions: (0, bind_keyword_1.structural)("a container of schemas, never a constraint itself"),
+    title: (0, bind_keyword_1.unsupported)(ANNOTATION_ONLY),
+    description: (0, bind_keyword_1.unsupported)(ANNOTATION_ONLY),
+    default: (0, bind_keyword_1.unsupported)("Luq never mutates the input it validates, so a default has nowhere to land"),
+    examples: (0, bind_keyword_1.unsupported)(ANNOTATION_ONLY),
+    readOnly: (0, bind_keyword_1.unsupported)(`${ANNOTATION_ONLY}; the readOnly plugin exists but is chain-only, because ` +
+        "Draft-07 gives readOnly no assertion behaviour"),
+    writeOnly: (0, bind_keyword_1.unsupported)(`${ANNOTATION_ONLY}; the writeOnly plugin exists but is chain-only`),
+    type: (0, bind_keyword_1.structural)("chooses the slot (b.string / b.number / ...), not a method on one; " +
+        "`integer` adds .integer() and a type ARRAY becomes nullable or a union"),
+    enum: (0, bind_keyword_1.structural)("the allowed-value list is typed against the FIELD (.oneOf() takes " +
+        "readonly SelfValue[]), so it carries a marker and cannot be a binding; " +
+        "the converter resolves the list and calls .oneOf() itself"),
+    const: exports.constBinding,
+    allOf: (0, bind_keyword_1.structural)("every sub-schema becomes a sub-chain the composite runs"),
+    anyOf: (0, bind_keyword_1.structural)("sub-chains combined existentially"),
+    oneOf: (0, bind_keyword_1.structural)("sub-chains counted; exactly one must pass. NB: the `enum` KEYWORD drives " +
+        "the .oneOf() METHOD, which is a different thing from this keyword"),
+    not: (0, bind_keyword_1.structural)("one negated sub-chain"),
+    if: (0, bind_keyword_1.structural)("the condition sub-chain of conditionalSchema"),
+    then: (0, bind_keyword_1.structural)("the then sub-chain of conditionalSchema"),
+    else: (0, bind_keyword_1.structural)("the else sub-chain of conditionalSchema"),
+};

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

@@ -0,0 +1,51 @@
+// ===========================================================================
+// L8  src/json-schema/keyword-map-core.ts — the 21 keywords that belong to no
+// single Luq slot: document plumbing, annotations, the any-instance keywords
+// and the applicators.
+//
+// Every entry is one of three written decisions and there is NO fall-through:
+//   bind        a chain method, with the method name checked by the compiler.
+//   structural  the CONVERTER expands it (it recurses, or it picks the slot).
+//               A sub-schema becomes a sub-CHAIN, which is a marker argument,
+//               so such a keyword can never be a binding — bindKeyword rejects
+//               it and the type test proves the rejection.
+//   unsupported out of scope, in writing, with the reason. 1.x stored eleven
+//               keywords it never read again; that is the failure this table
+//               exists to make impossible.
+// ===========================================================================
+import { bindKeyword, structural, unsupported } from "./bind-keyword.mjs";
+import { literalPlugin } from "../plugins/literal/index.mjs";
+const ANNOTATION_ONLY = "an annotation with no validation effect in Draft-07";
+/**
+ * `const` reaches every slot: literalPlugin's `slots` is the whole TypeName
+ * list, so `.literal()` is on the "any" chain as well as on each typed one.
+ */
+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"),
+    $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"),
+    definitions: structural("a container of schemas, never a constraint itself"),
+    title: unsupported(ANNOTATION_ONLY),
+    description: unsupported(ANNOTATION_ONLY),
+    default: unsupported("Luq never mutates the input it validates, so a default has nowhere to land"),
+    examples: unsupported(ANNOTATION_ONLY),
+    readOnly: unsupported(`${ANNOTATION_ONLY}; the readOnly plugin exists but is chain-only, because ` +
+        "Draft-07 gives readOnly no assertion behaviour"),
+    writeOnly: unsupported(`${ANNOTATION_ONLY}; the writeOnly plugin exists but is chain-only`),
+    type: structural("chooses the slot (b.string / b.number / ...), not a method on one; " +
+        "`integer` adds .integer() and a type ARRAY becomes nullable or a union"),
+    enum: structural("the allowed-value list is typed against the FIELD (.oneOf() takes " +
+        "readonly SelfValue[]), so it carries a marker and cannot be a binding; " +
+        "the converter resolves the list and calls .oneOf() itself"),
+    const: constBinding,
+    allOf: structural("every sub-schema becomes a sub-chain the composite runs"),
+    anyOf: structural("sub-chains combined existentially"),
+    oneOf: structural("sub-chains counted; exactly one must pass. NB: the `enum` KEYWORD drives " +
+        "the .oneOf() METHOD, which is a different thing from this keyword"),
+    not: structural("one negated sub-chain"),
+    if: structural("the condition sub-chain of conditionalSchema"),
+    then: structural("the then sub-chain of conditionalSchema"),
+    else: structural("the else sub-chain of conditionalSchema"),
+};

package/dist/json-schema/keyword-map-number.d.ts

@@ -0,0 +1,13 @@
+import type { KeywordTable } from "./keyword-binding.types";
+import type { Draft07NumberKeyword } from "./draft07-keyword-value.types";
+export declare const minimumBinding: import("./keyword-binding.types").KeywordBinding<"number", "min", "numberMin", readonly [min: number, exclusive?: boolean | undefined], number>;
+export declare const maximumBinding: import("./keyword-binding.types").KeywordBinding<"number", "max", "numberMax", readonly [max: number, exclusive?: boolean | undefined], number>;
+/** Draft-07 §6.2.5: the bound itself is excluded. Hence the trailing `true`. */
+export declare const exclusiveMinimumBinding: import("./keyword-binding.types").KeywordBinding<"number", "min", "numberMin", readonly [min: number, exclusive?: boolean | undefined], number>;
+export declare const exclusiveMaximumBinding: import("./keyword-binding.types").KeywordBinding<"number", "max", "numberMax", readonly [max: number, exclusive?: boolean | undefined], number>;
+/**
+ * numberMultipleOf compares scaled integers, so `multipleOf: 0.1` accepts 0.3
+ * — the float-modulo answer 1.x gave here was wrong and is not reproduced.
+ */
+export declare const multipleOfBinding: import("./keyword-binding.types").KeywordBinding<"number", "multipleOf", "numberMultipleOf", readonly [divisor: number], number>;
+export declare const numberKeywordMap: KeywordTable<Draft07NumberKeyword>;

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberKeywordMap = exports.multipleOfBinding = exports.exclusiveMaximumBinding = exports.exclusiveMinimumBinding = exports.maximumBinding = exports.minimumBinding = void 0;
+// ===========================================================================
+// L8  src/json-schema/keyword-map-number.ts — the five numeric keywords.
+//
+// All five bind. Draft-07 spells the strict bounds as SEPARATE numeric
+// keywords (`exclusiveMinimum: 5`), while numberMin/numberMax spell them as
+// the same method with a second argument (`.min(5, true)`). That is the whole
+// difference, and it is written once, here, rather than being re-decided at
+// each call site the way 1.x re-decided it in three places.
+// ===========================================================================
+const bind_keyword_1 = require("./bind-keyword");
+const number_min_1 = require("../plugins/number-min");
+const number_max_1 = require("../plugins/number-max");
+const number_multiple_of_1 = require("../plugins/number-multiple-of");
+exports.minimumBinding = (0, bind_keyword_1.bindKeyword)("number", "min", number_min_1.numberMinPlugin, (v) => [v]);
+exports.maximumBinding = (0, bind_keyword_1.bindKeyword)("number", "max", number_max_1.numberMaxPlugin, (v) => [v]);
+/** Draft-07 §6.2.5: the bound itself is excluded. Hence the trailing `true`. */
+exports.exclusiveMinimumBinding = (0, bind_keyword_1.bindKeyword)("number", "min", number_min_1.numberMinPlugin, (v) => [v, true]);
+exports.exclusiveMaximumBinding = (0, bind_keyword_1.bindKeyword)("number", "max", number_max_1.numberMaxPlugin, (v) => [v, true]);
+/**
+ * numberMultipleOf compares scaled integers, so `multipleOf: 0.1` accepts 0.3
+ * — the float-modulo answer 1.x gave here was wrong and is not reproduced.
+ */
+exports.multipleOfBinding = (0, bind_keyword_1.bindKeyword)("number", "multipleOf", number_multiple_of_1.numberMultipleOfPlugin, (v) => [v]);
+exports.numberKeywordMap = {
+    multipleOf: exports.multipleOfBinding,
+    maximum: exports.maximumBinding,
+    exclusiveMaximum: exports.exclusiveMaximumBinding,
+    minimum: exports.minimumBinding,
+    exclusiveMinimum: exports.exclusiveMinimumBinding,
+};

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

@@ -0,0 +1,30 @@
+// ===========================================================================
+// L8  src/json-schema/keyword-map-number.ts — the five numeric keywords.
+//
+// All five bind. Draft-07 spells the strict bounds as SEPARATE numeric
+// keywords (`exclusiveMinimum: 5`), while numberMin/numberMax spell them as
+// the same method with a second argument (`.min(5, true)`). That is the whole
+// difference, and it is written once, here, rather than being re-decided at
+// each call site the way 1.x re-decided it in three places.
+// ===========================================================================
+import { bindKeyword } from "./bind-keyword.mjs";
+import { numberMinPlugin } from "../plugins/number-min/index.mjs";
+import { numberMaxPlugin } from "../plugins/number-max/index.mjs";
+import { numberMultipleOfPlugin } from "../plugins/number-multiple-of/index.mjs";
+export const minimumBinding = bindKeyword("number", "min", numberMinPlugin, (v) => [v]);
+export const maximumBinding = bindKeyword("number", "max", numberMaxPlugin, (v) => [v]);
+/** Draft-07 §6.2.5: the bound itself is excluded. Hence the trailing `true`. */
+export const exclusiveMinimumBinding = bindKeyword("number", "min", numberMinPlugin, (v) => [v, true]);
+export const exclusiveMaximumBinding = bindKeyword("number", "max", numberMaxPlugin, (v) => [v, true]);
+/**
+ * numberMultipleOf compares scaled integers, so `multipleOf: 0.1` accepts 0.3
+ * — the float-modulo answer 1.x gave here was wrong and is not reproduced.
+ */
+export const multipleOfBinding = bindKeyword("number", "multipleOf", numberMultipleOfPlugin, (v) => [v]);
+export const numberKeywordMap = {
+    multipleOf: multipleOfBinding,
+    maximum: maximumBinding,
+    exclusiveMaximum: exclusiveMaximumBinding,
+    minimum: minimumBinding,
+    exclusiveMinimum: exclusiveMinimumBinding,
+};

package/dist/json-schema/keyword-map-object.d.ts

@@ -0,0 +1,17 @@
+import type { KeywordTable } from "./keyword-binding.types";
+import type { Draft07ObjectKeyword } from "./draft07-keyword-value.types";
+export declare const minPropertiesBinding: import("./keyword-binding.types").KeywordBinding<"object", "minProperties", "objectMinProperties", readonly [min: number], number>;
+export declare const maxPropertiesBinding: import("./keyword-binding.types").KeywordBinding<"object", "maxProperties", "objectMaxProperties", readonly [max: number], number>;
+/**
+ * Slot "any": requiredPlugin's `slots` is the whole TypeName list, so
+ * `.required()` is reachable on every field chain, which is exactly what a
+ * presence flag needs — the parent does not know the child's slot.
+ */
+export declare const requiredBinding: import("./keyword-binding.types").KeywordBinding<"any", "required", "required", readonly [], true>;
+/**
+ * The boolean form only. objectAdditionalProperties defaults its allowed set
+ * to the declared sibling keys, so `additionalProperties: false` no longer
+ * rejects every property the way 1.x's empty `allowedProperties` default did.
+ */
+export declare const additionalPropertiesBinding: import("./keyword-binding.types").KeywordBinding<"object", "additionalProperties", "objectAdditionalProperties", readonly [allowed: boolean, allowedProperties?: readonly string[] | undefined], boolean>;
+export declare const objectKeywordMap: KeywordTable<Draft07ObjectKeyword>;

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectKeywordMap = exports.additionalPropertiesBinding = exports.requiredBinding = exports.maxPropertiesBinding = exports.minPropertiesBinding = void 0;
+// ===========================================================================
+// L8  src/json-schema/keyword-map-object.ts — the eight object keywords.
+//
+// Two entries carry a normalisation the compiler enforces:
+//
+//   required               Draft-07 puts a string ARRAY on the PARENT. A
+//                          binding applies to one field, so the converter
+//                          resolves the array into one `true` per named child
+//                          before it can reach this binding. The value type is
+//                          `true`, so the unresolved array cannot be passed.
+//   additionalProperties   Draft-07 allows a schema OR a boolean. The schema
+//                          form is a sub-CHAIN (.additionalPropertiesSchema())
+//                          and no binding can take one; the boolean form binds
+//                          here. The value type is `boolean`, so the schema
+//                          form cannot reach this entry by accident.
+// ===========================================================================
+const bind_keyword_1 = require("./bind-keyword");
+const required_1 = require("../plugins/required");
+const object_min_properties_1 = require("../plugins/object-min-properties");
+const object_max_properties_1 = require("../plugins/object-max-properties");
+const object_additional_properties_1 = require("../plugins/object-additional-properties");
+exports.minPropertiesBinding = (0, bind_keyword_1.bindKeyword)("object", "minProperties", object_min_properties_1.objectMinPropertiesPlugin, (v) => [v]);
+exports.maxPropertiesBinding = (0, bind_keyword_1.bindKeyword)("object", "maxProperties", object_max_properties_1.objectMaxPropertiesPlugin, (v) => [v]);
+/**
+ * Slot "any": requiredPlugin's `slots` is the whole TypeName list, so
+ * `.required()` is reachable on every field chain, which is exactly what a
+ * presence flag needs — the parent does not know the child's slot.
+ */
+exports.requiredBinding = (0, bind_keyword_1.bindKeyword)("any", "required", required_1.requiredPlugin, (_v) => []);
+/**
+ * The boolean form only. objectAdditionalProperties defaults its allowed set
+ * to the declared sibling keys, so `additionalProperties: false` no longer
+ * rejects every property the way 1.x's empty `allowedProperties` default did.
+ */
+exports.additionalPropertiesBinding = (0, bind_keyword_1.bindKeyword)("object", "additionalProperties", object_additional_properties_1.objectAdditionalPropertiesPlugin, (v) => [v]);
+exports.objectKeywordMap = {
+    maxProperties: exports.maxPropertiesBinding,
+    minProperties: exports.minPropertiesBinding,
+    required: exports.requiredBinding,
+    properties: (0, bind_keyword_1.structural)("expanded into one .v() per declared path"),
+    patternProperties: (0, bind_keyword_1.structural)("one sub-chain per key pattern; EVERY matching pattern applies, which the " +
+        "break-after-first of 1.x did not do"),
+    additionalProperties: exports.additionalPropertiesBinding,
+    dependencies: (0, bind_keyword_1.structural)("both Draft-07 forms: a key list drives .dependentRequired(), a sub-schema " +
+        "drives .dependentSchemas(). One keyword, two chain methods, so the " +
+        "converter must branch and no single binding can express it"),
+    propertyNames: (0, bind_keyword_1.structural)("a sub-chain over property NAMES, not values"),
+};

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

@@ -0,0 +1,48 @@
+// ===========================================================================
+// L8  src/json-schema/keyword-map-object.ts — the eight object keywords.
+//
+// Two entries carry a normalisation the compiler enforces:
+//
+//   required               Draft-07 puts a string ARRAY on the PARENT. A
+//                          binding applies to one field, so the converter
+//                          resolves the array into one `true` per named child
+//                          before it can reach this binding. The value type is
+//                          `true`, so the unresolved array cannot be passed.
+//   additionalProperties   Draft-07 allows a schema OR a boolean. The schema
+//                          form is a sub-CHAIN (.additionalPropertiesSchema())
+//                          and no binding can take one; the boolean form binds
+//                          here. The value type is `boolean`, so the schema
+//                          form cannot reach this entry by accident.
+// ===========================================================================
+import { bindKeyword, structural } from "./bind-keyword.mjs";
+import { requiredPlugin } from "../plugins/required/index.mjs";
+import { objectMinPropertiesPlugin } from "../plugins/object-min-properties/index.mjs";
+import { objectMaxPropertiesPlugin } from "../plugins/object-max-properties/index.mjs";
+import { objectAdditionalPropertiesPlugin } from "../plugins/object-additional-properties/index.mjs";
+export const minPropertiesBinding = bindKeyword("object", "minProperties", objectMinPropertiesPlugin, (v) => [v]);
+export const maxPropertiesBinding = bindKeyword("object", "maxProperties", objectMaxPropertiesPlugin, (v) => [v]);
+/**
+ * Slot "any": requiredPlugin's `slots` is the whole TypeName list, so
+ * `.required()` is reachable on every field chain, which is exactly what a
+ * presence flag needs — the parent does not know the child's slot.
+ */
+export const requiredBinding = bindKeyword("any", "required", requiredPlugin, (_v) => []);
+/**
+ * The boolean form only. objectAdditionalProperties defaults its allowed set
+ * to the declared sibling keys, so `additionalProperties: false` no longer
+ * rejects every property the way 1.x's empty `allowedProperties` default did.
+ */
+export const additionalPropertiesBinding = bindKeyword("object", "additionalProperties", objectAdditionalPropertiesPlugin, (v) => [v]);
+export const objectKeywordMap = {
+    maxProperties: maxPropertiesBinding,
+    minProperties: minPropertiesBinding,
+    required: requiredBinding,
+    properties: structural("expanded into one .v() per declared path"),
+    patternProperties: structural("one sub-chain per key pattern; EVERY matching pattern applies, which the " +
+        "break-after-first of 1.x did not do"),
+    additionalProperties: additionalPropertiesBinding,
+    dependencies: structural("both Draft-07 forms: a key list drives .dependentRequired(), a sub-schema " +
+        "drives .dependentSchemas(). One keyword, two chain methods, so the " +
+        "converter must branch and no single binding can express it"),
+    propertyNames: structural("a sub-chain over property NAMES, not values"),
+};

package/dist/json-schema/keyword-map-string.d.ts

@@ -0,0 +1,20 @@
+import type { KeywordTable } from "./keyword-binding.types";
+import type { Draft07StringKeyword } from "./draft07-keyword-value.types";
+import { type ContentEncodingName } from "../plugins/string-content-encoding";
+export declare const minLengthBinding: import("./keyword-binding.types").KeywordBinding<"string", "min", "stringMin", readonly [min: number], number>;
+export declare const maxLengthBinding: import("./keyword-binding.types").KeywordBinding<"string", "max", "stringMax", readonly [max: number], number>;
+/**
+ * Draft-07 spells `pattern` as an ECMA-262 SOURCE string; the plugin accepts a
+ * RegExp and only a RegExp, because 1.x's `new RegExp(source)` at the call site
+ * dropped flags silently and gave the caller no compile-time check. Compiling
+ * the schema's string therefore happens HERE, once, and nowhere else.
+ */
+export declare const patternBinding: import("./keyword-binding.types").KeywordBinding<"string", "pattern", "stringPattern", readonly [pattern: RegExp], string>;
+/**
+ * The value type is `ContentEncodingName`, not `string`: an encoding the
+ * plugin does not know must be refused by the converter rather than accepted
+ * silently, and the compiler is what forces that narrowing to happen.
+ */
+export declare const contentEncodingBinding: import("./keyword-binding.types").KeywordBinding<"string", "contentEncoding", "stringContentEncoding", readonly [encoding: ContentEncodingName], ContentEncodingName>;
+export declare const contentMediaTypeBinding: import("./keyword-binding.types").KeywordBinding<"string", "contentMediaType", "stringContentMediaType", readonly [mediaType: string], string>;
+export declare const stringKeywordMap: KeywordTable<Draft07StringKeyword>;