@maroonedog/luq 0.1.2-alpha → 2.1.0

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, allowedPatterns?: 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>;

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringKeywordMap = exports.contentMediaTypeBinding = exports.contentEncodingBinding = exports.patternBinding = exports.maxLengthBinding = exports.minLengthBinding = void 0;
+// ===========================================================================
+// L8  src/json-schema/keyword-map-string.ts — the six string keywords.
+//
+// `format` is the only structural one, and it is structural for a reason worth
+// stating: its VALUE selects the binding. One keyword, twenty possible chain
+// methods. The selection lives in format-map.ts, which is the single format
+// table in this repository — 1.x shipped three of them and they disagreed
+// (docs/legacy-spec/json-schema-mapping.md records the disagreements).
+// ===========================================================================
+const bind_keyword_1 = require("./bind-keyword");
+const string_min_1 = require("../plugins/string-min");
+const string_max_1 = require("../plugins/string-max");
+const string_pattern_1 = require("../plugins/string-pattern");
+const string_content_encoding_1 = require("../plugins/string-content-encoding");
+const string_content_media_type_1 = require("../plugins/string-content-media-type");
+exports.minLengthBinding = (0, bind_keyword_1.bindKeyword)("string", "min", string_min_1.stringMinPlugin, (v) => [v]);
+exports.maxLengthBinding = (0, bind_keyword_1.bindKeyword)("string", "max", string_max_1.stringMaxPlugin, (v) => [v]);
+/**
+ * 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.
+ */
+exports.patternBinding = (0, bind_keyword_1.bindKeyword)("string", "pattern", string_pattern_1.stringPatternPlugin, (v) => [new RegExp(v)]);
+/**
+ * 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.
+ */
+exports.contentEncodingBinding = (0, bind_keyword_1.bindKeyword)("string", "contentEncoding", string_content_encoding_1.stringContentEncodingPlugin, (v) => [v]);
+exports.contentMediaTypeBinding = (0, bind_keyword_1.bindKeyword)("string", "contentMediaType", string_content_media_type_1.stringContentMediaTypePlugin, (v) => [v]);
+exports.stringKeywordMap = {
+    maxLength: exports.maxLengthBinding,
+    minLength: exports.minLengthBinding,
+    pattern: exports.patternBinding,
+    format: (0, bind_keyword_1.structural)("the keyword's VALUE selects which of the sixteen format plugins runs; " +
+        "see format-map.ts, the only format table in src. An unknown format " +
+        "name is an annotation and passes, which is what Draft-07 §7.2 requires"),
+    contentEncoding: exports.contentEncodingBinding,
+    contentMediaType: exports.contentMediaTypeBinding,
+};

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

@@ -0,0 +1,41 @@
+// ===========================================================================
+// L8  src/json-schema/keyword-map-string.ts — the six string keywords.
+//
+// `format` is the only structural one, and it is structural for a reason worth
+// stating: its VALUE selects the binding. One keyword, twenty possible chain
+// methods. The selection lives in format-map.ts, which is the single format
+// table in this repository — 1.x shipped three of them and they disagreed
+// (docs/legacy-spec/json-schema-mapping.md records the disagreements).
+// ===========================================================================
+import { bindKeyword, structural } from "./bind-keyword.mjs";
+import { stringMinPlugin } from "../plugins/string-min/index.mjs";
+import { stringMaxPlugin } from "../plugins/string-max/index.mjs";
+import { stringPatternPlugin } from "../plugins/string-pattern/index.mjs";
+import { stringContentEncodingPlugin, } from "../plugins/string-content-encoding/index.mjs";
+import { stringContentMediaTypePlugin } from "../plugins/string-content-media-type/index.mjs";
+export const minLengthBinding = bindKeyword("string", "min", stringMinPlugin, (v) => [v]);
+export const maxLengthBinding = bindKeyword("string", "max", stringMaxPlugin, (v) => [v]);
+/**
+ * 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 const patternBinding = bindKeyword("string", "pattern", stringPatternPlugin, (v) => [new RegExp(v)]);
+/**
+ * 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 const contentEncodingBinding = bindKeyword("string", "contentEncoding", stringContentEncodingPlugin, (v) => [v]);
+export const contentMediaTypeBinding = bindKeyword("string", "contentMediaType", stringContentMediaTypePlugin, (v) => [v]);
+export const stringKeywordMap = {
+    maxLength: maxLengthBinding,
+    minLength: minLengthBinding,
+    pattern: patternBinding,
+    format: structural("the keyword's VALUE selects which of the sixteen format plugins runs; " +
+        "see format-map.ts, the only format table in src. An unknown format " +
+        "name is an annotation and passes, which is what Draft-07 §7.2 requires"),
+    contentEncoding: contentEncodingBinding,
+    contentMediaType: contentMediaTypeBinding,
+};

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

@@ -0,0 +1,32 @@
+import type { AnyKeywordHandling, KeywordTable } from "./keyword-binding.types";
+import type { Draft07Keyword } from "./draft07-keyword-value.types";
+export declare const draft07KeywordMap: KeywordTable<Draft07Keyword>;
+/**
+ * Keywords Luq recognises the NAME of but which are not Draft-07. They are
+ * listed so that "we did not implement it" and "it is not in this dialect"
+ * stay different answers. `$defs` is the one exception that still does
+ * something: resolve-ref follows it, because a 2019-09 document's pointers
+ * would otherwise dangle.
+ */
+export declare const NON_DRAFT07_KEYWORDS: Readonly<Record<string, string>>;
+export declare function isDraft07Keyword(keyword: string): keyword is Draft07Keyword;
+/** Every keyword the table decides on. No assertion; the guard narrows. */
+export declare function listDraft07Keywords(): readonly Draft07Keyword[];
+/** `undefined` = not a Draft-07 keyword at all. See NON_DRAFT07_KEYWORDS. */
+export declare function findKeywordHandling(keyword: string): AnyKeywordHandling | undefined;
+/** Throws for a keyword the table declares out of scope. Never silent. */
+export declare function assertKeywordSupported(keyword: string): void;
+/**
+ * Every plugin the two tables bind, de-duplicated and sorted. Step 26 GENERATES
+ * the full-feature bundle's use() list from this, so the bundle cannot name a
+ * plugin that is not bound, and cannot omit one that is.
+ */
+export declare function listBoundPluginNames(): readonly string[];
+export interface KeywordHandlingCounts {
+    readonly bind: number;
+    readonly structural: number;
+    readonly unsupported: number;
+    readonly total: number;
+}
+/** Counted, never asserted: the published numbers come from this function. */
+export declare function countKeywordHandlings(table: Readonly<Record<string, AnyKeywordHandling>>): KeywordHandlingCounts;