@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/json-schema/declare-presence.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declarePresenceRules = declarePresenceRules;
+// ===========================================================================
+// L8  src/json-schema/declare-presence.ts — is this property allowed to be
+// ABSENT, and is it allowed to be NULL?
+//
+// Draft-07 answers with two different keywords in two different places: the
+// PARENT's `required` array decides absence, and the child's own `type` decides
+// null (a `type` that omits "null" forbids it; NO `type` at all forbids
+// nothing). Luq answers with one merged PresencePolicy per field, so the two
+// have to be resolved together — which is also why this is not the `required`
+// KEYWORD BINDING from keyword-map-object.ts.
+//
+// WHY NOT `.required()` (measured, and a deliberate deviation): requiredPlugin
+// declares `emptyStringIsMissing: true`, carried over verbatim from 1.x's
+// form-oriented emptiness, and src/compile/resolve-presence.ts merges that flag
+// with `.some()`, so no companion rule can switch it back off. Under
+// `.required()` the document `{"name": ""}` therefore FAILS `required: ["name"]`,
+// which Draft-07 §6.5.3 permits — the keyword is about the property being
+// PRESENT, not about it being non-empty. The policy below is the same rule kind
+// from the same factory with `emptyStringIsMissing: false`.
+// ===========================================================================
+const create_rule_1 = require("../plugin-kit/create-rule");
+/**
+ * The rule is emitted even when it forbids nothing, because it carries
+ * `nullIsValue` and that is not a permission — it is the statement that null
+ * has to be JUDGED here rather than settled by presence. A subject with no
+ * presence rule carries OPEN_PRESENCE, which ends the field on null before a
+ * single check runs; under Draft-07 that is wrong, because `false`,
+ * `{"not": {}}` and an `enum` without null all forbid null while saying
+ * nothing about `type`. Null therefore goes to the checks, and `type`
+ * (declare-value-keywords.ts) is what rejects it when the document says so —
+ * one answer instead of two that have to agree.
+ */
+function declarePresenceRules(declaration) {
+    return Object.freeze([
+        (0, create_rule_1.presence)({
+            code: declaration.isRequired ? "required" : "type",
+            severity: declaration.severity,
+            allowUndefined: !declaration.isRequired,
+            // Unreachable for null while nullIsValue is true; `type` decides.
+            allowNull: true,
+            emptyStringIsMissing: false,
+            nullIsValue: true,
+            describe: (messageContext) => declaration.isRequired
+                ? `${messageContext.path} is required`
+                : `${messageContext.path} must not be null`,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}

package/dist/json-schema/declare-presence.mjs

@@ -0,0 +1,49 @@
+// ===========================================================================
+// L8  src/json-schema/declare-presence.ts — is this property allowed to be
+// ABSENT, and is it allowed to be NULL?
+//
+// Draft-07 answers with two different keywords in two different places: the
+// PARENT's `required` array decides absence, and the child's own `type` decides
+// null (a `type` that omits "null" forbids it; NO `type` at all forbids
+// nothing). Luq answers with one merged PresencePolicy per field, so the two
+// have to be resolved together — which is also why this is not the `required`
+// KEYWORD BINDING from keyword-map-object.ts.
+//
+// WHY NOT `.required()` (measured, and a deliberate deviation): requiredPlugin
+// declares `emptyStringIsMissing: true`, carried over verbatim from 1.x's
+// form-oriented emptiness, and src/compile/resolve-presence.ts merges that flag
+// with `.some()`, so no companion rule can switch it back off. Under
+// `.required()` the document `{"name": ""}` therefore FAILS `required: ["name"]`,
+// which Draft-07 §6.5.3 permits — the keyword is about the property being
+// PRESENT, not about it being non-empty. The policy below is the same rule kind
+// from the same factory with `emptyStringIsMissing: false`.
+// ===========================================================================
+import { presence } from "../plugin-kit/create-rule.mjs";
+/**
+ * The rule is emitted even when it forbids nothing, because it carries
+ * `nullIsValue` and that is not a permission — it is the statement that null
+ * has to be JUDGED here rather than settled by presence. A subject with no
+ * presence rule carries OPEN_PRESENCE, which ends the field on null before a
+ * single check runs; under Draft-07 that is wrong, because `false`,
+ * `{"not": {}}` and an `enum` without null all forbid null while saying
+ * nothing about `type`. Null therefore goes to the checks, and `type`
+ * (declare-value-keywords.ts) is what rejects it when the document says so —
+ * one answer instead of two that have to agree.
+ */
+export function declarePresenceRules(declaration) {
+    return Object.freeze([
+        presence({
+            code: declaration.isRequired ? "required" : "type",
+            severity: declaration.severity,
+            allowUndefined: !declaration.isRequired,
+            // Unreachable for null while nullIsValue is true; `type` decides.
+            allowNull: true,
+            emptyStringIsMissing: false,
+            nullIsValue: true,
+            describe: (messageContext) => declaration.isRequired
+                ? `${messageContext.path} is required`
+                : `${messageContext.path} must not be null`,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}

package/dist/json-schema/declare-required-properties.d.ts

@@ -0,0 +1,18 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { Draft07SchemaObject } from "./draft07.types";
+import type { StructuralContext } from "./structural-expansion.types";
+/**
+ * `required` as a rule on the OBJECT, not as a presence rule on each child.
+ *
+ * The difference decides a verdict. A child's presence rule fires whenever the
+ * child reads `undefined`, which includes the case where the PARENT is absent —
+ * so `{properties:{a:{properties:{b:{}},required:["b"]}}}` would refuse `{}`,
+ * although Draft-07 applies a sub-schema only to a value that is there. Asking
+ * the object itself asks the question the draft asks, and §6.5.3 also says a
+ * NON-object is none of `required`'s business, which is why a non-object passes.
+ *
+ * The document ROOT is the exception and is handled in flatten-schema.ts: it has
+ * no declarable path to carry this rule, and it is always present anyway
+ * (src/runtime/create-validator.ts refuses a missing root before the plan runs).
+ */
+export declare function declareRequiredProperties(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

package/dist/json-schema/declare-required-properties.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declareRequiredProperties = declareRequiredProperties;
+// ===========================================================================
+// L8  src/json-schema/declare-required-properties.ts — `required`, as a rule on
+// the OBJECT rather than on each named child.
+//
+// The distinction decides verdicts, so it is worth a file of its own. See the
+// doc comment below; the short version is that a child's presence rule cannot
+// tell "the property is missing from an object that IS there" from "the whole
+// object is absent", and Draft-07 applies a sub-schema only to a value that is
+// there.
+//
+// This is also the reason the `required` KEYWORD BINDING in keyword-map-object.ts
+// is not the mechanism here: `.required()` is a presence rule on ONE field, and
+// it additionally treats "" as absent (1.x's form emptiness), which §6.5.3 does
+// not. The binding stays as the type-checked record that `required` maps to
+// `.required()`; the converter needs the object-level question instead.
+// ===========================================================================
+const create_rule_1 = require("../plugin-kit/create-rule");
+const types_1 = require("../types");
+const NO_RULES = Object.freeze([]);
+/**
+ * `required` as a rule on the OBJECT, not as a presence rule on each child.
+ *
+ * The difference decides a verdict. A child's presence rule fires whenever the
+ * child reads `undefined`, which includes the case where the PARENT is absent —
+ * so `{properties:{a:{properties:{b:{}},required:["b"]}}}` would refuse `{}`,
+ * although Draft-07 applies a sub-schema only to a value that is there. Asking
+ * the object itself asks the question the draft asks, and §6.5.3 also says a
+ * NON-object is none of `required`'s business, which is why a non-object passes.
+ *
+ * The document ROOT is the exception and is handled in flatten-schema.ts: it has
+ * no declarable path to carry this rule, and it is always present anyway
+ * (src/runtime/create-validator.ts refuses a missing root before the plan runs).
+ */
+function declareRequiredProperties(schema, context) {
+    const required = schema.required;
+    if (required === undefined || required.length === 0)
+        return NO_RULES;
+    const missingOf = (value) => required.filter((key) => !Object.prototype.hasOwnProperty.call(value, key));
+    return Object.freeze([
+        (0, create_rule_1.check)({
+            code: "required",
+            severity: context.build.config.defaultSeverity,
+            run: (value) => {
+                if (!(0, types_1.isPlainObject)(value))
+                    return types_1.PASS;
+                const missing = missingOf(value);
+                return missing.length === 0
+                    ? types_1.PASS
+                    : (0, types_1.fail)({ expected: required, actual: missing });
+            },
+            describe: (detail) => `Missing required propert${(0, types_1.isArray)(detail.actual) && detail.actual.length === 1 ? "y" : "ies"}: ${String(detail.actual)}`,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}

package/dist/json-schema/declare-required-properties.mjs

@@ -0,0 +1,55 @@
+// ===========================================================================
+// L8  src/json-schema/declare-required-properties.ts — `required`, as a rule on
+// the OBJECT rather than on each named child.
+//
+// The distinction decides verdicts, so it is worth a file of its own. See the
+// doc comment below; the short version is that a child's presence rule cannot
+// tell "the property is missing from an object that IS there" from "the whole
+// object is absent", and Draft-07 applies a sub-schema only to a value that is
+// there.
+//
+// This is also the reason the `required` KEYWORD BINDING in keyword-map-object.ts
+// is not the mechanism here: `.required()` is a presence rule on ONE field, and
+// it additionally treats "" as absent (1.x's form emptiness), which §6.5.3 does
+// not. The binding stays as the type-checked record that `required` maps to
+// `.required()`; the converter needs the object-level question instead.
+// ===========================================================================
+import { check } from "../plugin-kit/create-rule.mjs";
+import { PASS, fail, isArray, isPlainObject } from "../types/index.mjs";
+const NO_RULES = Object.freeze([]);
+/**
+ * `required` as a rule on the OBJECT, not as a presence rule on each child.
+ *
+ * The difference decides a verdict. A child's presence rule fires whenever the
+ * child reads `undefined`, which includes the case where the PARENT is absent —
+ * so `{properties:{a:{properties:{b:{}},required:["b"]}}}` would refuse `{}`,
+ * although Draft-07 applies a sub-schema only to a value that is there. Asking
+ * the object itself asks the question the draft asks, and §6.5.3 also says a
+ * NON-object is none of `required`'s business, which is why a non-object passes.
+ *
+ * The document ROOT is the exception and is handled in flatten-schema.ts: it has
+ * no declarable path to carry this rule, and it is always present anyway
+ * (src/runtime/create-validator.ts refuses a missing root before the plan runs).
+ */
+export function declareRequiredProperties(schema, context) {
+    const required = schema.required;
+    if (required === undefined || required.length === 0)
+        return NO_RULES;
+    const missingOf = (value) => required.filter((key) => !Object.prototype.hasOwnProperty.call(value, key));
+    return Object.freeze([
+        check({
+            code: "required",
+            severity: context.build.config.defaultSeverity,
+            run: (value) => {
+                if (!isPlainObject(value))
+                    return PASS;
+                const missing = missingOf(value);
+                return missing.length === 0
+                    ? PASS
+                    : fail({ expected: required, actual: missing });
+            },
+            describe: (detail) => `Missing required propert${isArray(detail.actual) && detail.actual.length === 1 ? "y" : "ies"}: ${String(detail.actual)}`,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}

package/dist/json-schema/declare-scalar-keywords.d.ts

@@ -0,0 +1,11 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { Draft07SchemaObject } from "./draft07.types";
+import type { StructuralContext } from "./structural-expansion.types";
+export declare function declareStringRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+/**
+ * Draft-07 §7.2: an unknown format is an ANNOTATION and passes. A format the
+ * table declares out of scope is a different answer and throws — 1.x confused
+ * the two and its validator and its error generator disagreed about which.
+ */
+export declare function declareFormatRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+export declare function declareNumberRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

package/dist/json-schema/declare-scalar-keywords.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declareStringRules = declareStringRules;
+exports.declareFormatRules = declareFormatRules;
+exports.declareNumberRules = declareNumberRules;
+// ===========================================================================
+// L8  src/json-schema/declare-scalar-keywords.ts — the keywords that BIND.
+//
+// Every call below goes through applyKeywordBinding, so the chain method a
+// keyword drives is checked by the compiler against the plugin that declares
+// it. That is the whole reason step 24 exists: 1.x wrote
+// `chain.minItems && chain.minItems(n)` and the constraint evaporated.
+//
+// The slot chains are built and driven here, but a slot is NOT a filter: every
+// bound plugin in the bag passes a wrong-typed value on purpose (see
+// string-min.ts: "a wrong-typed value PASSES"), which is exactly Draft-07 §6 —
+// `minLength` says nothing about a number. So the converter applies the string
+// keywords AND the number keywords whenever they appear, without first deciding
+// what the value will be, and `type` (declare-value-keywords.ts) is the only rule
+// that judges the type. That is also what makes `type: ["string","number"]`
+// with a `minLength` correct rather than approximated.
+// ===========================================================================
+const create_chain_node_1 = require("../chain/create-chain-node");
+const create_field_slots_1 = require("../chain/create-field-slots");
+const apply_keyword_binding_1 = require("./apply-keyword-binding");
+const format_map_1 = require("./format-map");
+const keyword_map_number_1 = require("./keyword-map-number");
+const keyword_map_string_1 = require("./keyword-map-string");
+const unsupported_keyword_error_1 = require("./unsupported-keyword-error");
+const NO_RULES = Object.freeze([]);
+/** Total over the plugin's own union, so a new encoding breaks THIS line. */
+const CONTENT_ENCODING_NAMES = {
+    base64: true,
+    base32: true,
+    binary: true,
+    "7bit": true,
+    "8bit": true,
+    "quoted-printable": true,
+};
+function isContentEncodingName(name) {
+    return Object.prototype.hasOwnProperty.call(CONTENT_ENCODING_NAMES, name);
+}
+function readRules(chain) {
+    return (0, create_chain_node_1.readChainRules)(chain) ?? NO_RULES;
+}
+function emptyStringChain(bag, context) {
+    return (0, create_field_slots_1.createFieldSlots)(bag, context.build)
+        .string;
+}
+function declareStringRules(schema, context) {
+    let chain = emptyStringChain(context.bag, context);
+    if (schema.minLength !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_string_1.minLengthBinding, schema.minLength);
+    }
+    if (schema.maxLength !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_string_1.maxLengthBinding, schema.maxLength);
+    }
+    if (schema.pattern !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_string_1.patternBinding, schema.pattern);
+    }
+    if (schema.contentMediaType !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_string_1.contentMediaTypeBinding, schema.contentMediaType);
+    }
+    const encoding = schema.contentEncoding;
+    if (encoding !== undefined) {
+        if (!isContentEncodingName(encoding)) {
+            throw new unsupported_keyword_error_1.UnsupportedKeywordError("contentEncoding", `"${encoding}" is not one of the encodings stringContentEncoding ` +
+                "recognises; 1.x accepted every unknown name and validated nothing");
+        }
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_string_1.contentEncodingBinding, encoding);
+    }
+    return readRules(chain);
+}
+/**
+ * Draft-07 §7.2: an unknown format is an ANNOTATION and passes. A format the
+ * table declares out of scope is a different answer and throws — 1.x confused
+ * the two and its validator and its error generator disagreed about which.
+ */
+function declareFormatRules(schema, context) {
+    const format = schema.format;
+    if (format === undefined)
+        return NO_RULES;
+    const handling = (0, format_map_1.findFormatHandling)(format);
+    if (handling === undefined)
+        return NO_RULES;
+    if (handling.handling === "unsupported") {
+        throw new unsupported_keyword_error_1.UnsupportedKeywordError(`format: ${format}`, handling.reason);
+    }
+    const chain = emptyStringChain(context.bag, context);
+    return readRules((0, apply_keyword_binding_1.applyKeywordBinding)(chain, handling, "format"));
+}
+function declareNumberRules(schema, context) {
+    let chain = (0, create_field_slots_1.createFieldSlots)(context.bag, context.build).number;
+    if (schema.minimum !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_number_1.minimumBinding, schema.minimum);
+    }
+    if (schema.maximum !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_number_1.maximumBinding, schema.maximum);
+    }
+    if (schema.exclusiveMinimum !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_number_1.exclusiveMinimumBinding, schema.exclusiveMinimum);
+    }
+    if (schema.exclusiveMaximum !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_number_1.exclusiveMaximumBinding, schema.exclusiveMaximum);
+    }
+    if (schema.multipleOf !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_number_1.multipleOfBinding, schema.multipleOf);
+    }
+    return readRules(chain);
+}

package/dist/json-schema/declare-scalar-keywords.mjs

@@ -0,0 +1,105 @@
+// ===========================================================================
+// L8  src/json-schema/declare-scalar-keywords.ts — the keywords that BIND.
+//
+// Every call below goes through applyKeywordBinding, so the chain method a
+// keyword drives is checked by the compiler against the plugin that declares
+// it. That is the whole reason step 24 exists: 1.x wrote
+// `chain.minItems && chain.minItems(n)` and the constraint evaporated.
+//
+// The slot chains are built and driven here, but a slot is NOT a filter: every
+// bound plugin in the bag passes a wrong-typed value on purpose (see
+// string-min.ts: "a wrong-typed value PASSES"), which is exactly Draft-07 §6 —
+// `minLength` says nothing about a number. So the converter applies the string
+// keywords AND the number keywords whenever they appear, without first deciding
+// what the value will be, and `type` (declare-value-keywords.ts) is the only rule
+// that judges the type. That is also what makes `type: ["string","number"]`
+// with a `minLength` correct rather than approximated.
+// ===========================================================================
+import { readChainRules } from "../chain/create-chain-node.mjs";
+import { createFieldSlots } from "../chain/create-field-slots.mjs";
+import { applyKeywordBinding } from "./apply-keyword-binding.mjs";
+import { findFormatHandling } from "./format-map.mjs";
+import { exclusiveMaximumBinding, exclusiveMinimumBinding, maximumBinding, minimumBinding, multipleOfBinding, } from "./keyword-map-number.mjs";
+import { contentEncodingBinding, contentMediaTypeBinding, maxLengthBinding, minLengthBinding, patternBinding, } from "./keyword-map-string.mjs";
+import { UnsupportedKeywordError } from "./unsupported-keyword-error.mjs";
+const NO_RULES = Object.freeze([]);
+/** Total over the plugin's own union, so a new encoding breaks THIS line. */
+const CONTENT_ENCODING_NAMES = {
+    base64: true,
+    base32: true,
+    binary: true,
+    "7bit": true,
+    "8bit": true,
+    "quoted-printable": true,
+};
+function isContentEncodingName(name) {
+    return Object.prototype.hasOwnProperty.call(CONTENT_ENCODING_NAMES, name);
+}
+function readRules(chain) {
+    return readChainRules(chain) ?? NO_RULES;
+}
+function emptyStringChain(bag, context) {
+    return createFieldSlots(bag, context.build)
+        .string;
+}
+export function declareStringRules(schema, context) {
+    let chain = emptyStringChain(context.bag, context);
+    if (schema.minLength !== undefined) {
+        chain = applyKeywordBinding(chain, minLengthBinding, schema.minLength);
+    }
+    if (schema.maxLength !== undefined) {
+        chain = applyKeywordBinding(chain, maxLengthBinding, schema.maxLength);
+    }
+    if (schema.pattern !== undefined) {
+        chain = applyKeywordBinding(chain, patternBinding, schema.pattern);
+    }
+    if (schema.contentMediaType !== undefined) {
+        chain = applyKeywordBinding(chain, contentMediaTypeBinding, schema.contentMediaType);
+    }
+    const encoding = schema.contentEncoding;
+    if (encoding !== undefined) {
+        if (!isContentEncodingName(encoding)) {
+            throw new UnsupportedKeywordError("contentEncoding", `"${encoding}" is not one of the encodings stringContentEncoding ` +
+                "recognises; 1.x accepted every unknown name and validated nothing");
+        }
+        chain = applyKeywordBinding(chain, contentEncodingBinding, encoding);
+    }
+    return readRules(chain);
+}
+/**
+ * Draft-07 §7.2: an unknown format is an ANNOTATION and passes. A format the
+ * table declares out of scope is a different answer and throws — 1.x confused
+ * the two and its validator and its error generator disagreed about which.
+ */
+export function declareFormatRules(schema, context) {
+    const format = schema.format;
+    if (format === undefined)
+        return NO_RULES;
+    const handling = findFormatHandling(format);
+    if (handling === undefined)
+        return NO_RULES;
+    if (handling.handling === "unsupported") {
+        throw new UnsupportedKeywordError(`format: ${format}`, handling.reason);
+    }
+    const chain = emptyStringChain(context.bag, context);
+    return readRules(applyKeywordBinding(chain, handling, "format"));
+}
+export function declareNumberRules(schema, context) {
+    let chain = createFieldSlots(context.bag, context.build).number;
+    if (schema.minimum !== undefined) {
+        chain = applyKeywordBinding(chain, minimumBinding, schema.minimum);
+    }
+    if (schema.maximum !== undefined) {
+        chain = applyKeywordBinding(chain, maximumBinding, schema.maximum);
+    }
+    if (schema.exclusiveMinimum !== undefined) {
+        chain = applyKeywordBinding(chain, exclusiveMinimumBinding, schema.exclusiveMinimum);
+    }
+    if (schema.exclusiveMaximum !== undefined) {
+        chain = applyKeywordBinding(chain, exclusiveMaximumBinding, schema.exclusiveMaximum);
+    }
+    if (schema.multipleOf !== undefined) {
+        chain = applyKeywordBinding(chain, multipleOfBinding, schema.multipleOf);
+    }
+    return readRules(chain);
+}

package/dist/json-schema/declare-value-keywords.d.ts

@@ -0,0 +1,23 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { Draft07SchemaObject, Draft07TypeKeyword } from "./draft07.types";
+import type { StructuralContext } from "./structural-expansion.types";
+/** The declared names, always as a list, with unknown names rejected loudly. */
+export declare function readDeclaredTypes(schema: Draft07SchemaObject): readonly Draft07TypeKeyword[];
+/** True when the document permits an explicit null at this position. */
+export declare function permitsNull(schema: Draft07SchemaObject): boolean;
+/**
+ * One check for the whole list: `type: ["string","number"]` is a union, and
+ * running one rule per member would report a failure per member for a value
+ * that fails all of them.
+ */
+export declare function declareTypeRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+/** `type: "integer"` is the only `type` member that adds a chain method. */
+export declare function declareIntegerRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+export declare function declareConstRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+/**
+ * `enum` drives the `.oneOf()` METHOD, which is a different thing from the
+ * `oneOf` KEYWORD. The list is typed against the FIELD (readonly SelfValue[]),
+ * so it carries a marker and can never be a keyword binding; the converter
+ * resolves the list and calls the plugin itself, exactly as the table says.
+ */
+export declare function declareEnumRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

package/dist/json-schema/declare-value-keywords.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDeclaredTypes = readDeclaredTypes;
+exports.permitsNull = permitsNull;
+exports.declareTypeRules = declareTypeRules;
+exports.declareIntegerRules = declareIntegerRules;
+exports.declareConstRules = declareConstRules;
+exports.declareEnumRules = declareEnumRules;
+// ===========================================================================
+// L8  src/json-schema/declare-value-keywords.ts — the keywords
+// that judge the VALUE ITSELF: `type`, `enum` and `const`.
+//
+// The keyword table calls `type` structural because it "chooses the slot".
+// Choosing a slot is a TYPE-LEVEL act and asserts nothing at run time, so a
+// converter that only chose a slot would accept `42` for `{"type":"string"}` —
+// which is precisely what 1.x did (docs/legacy-spec/json-schema-mapping.md).
+// The slot choice is still made, in declare-scalar-keywords; the RULE is made
+// here, from create-rule, because no plugin in JsonSchemaBag asserts a
+// primitive type (`object` is the only type plugin in the catalogue and it is
+// not in the bag).
+//
+// `null` never reaches a check — src/runtime/decide-presence.ts settles absence
+// first — so `type: "null"` reads as "every value that got this far is wrong",
+// which is exactly right: the only null-shaped value was already accepted by
+// the nullable presence rule this module's neighbour declares.
+// ===========================================================================
+const create_chain_node_1 = require("../chain/create-chain-node");
+const create_field_slots_1 = require("../chain/create-field-slots");
+const create_rule_1 = require("../plugin-kit/create-rule");
+const types_1 = require("../types");
+const apply_keyword_binding_1 = require("./apply-keyword-binding");
+const keyword_map_core_1 = require("./keyword-map-core");
+const NO_RULES = Object.freeze([]);
+/** Every Draft-07 `type` name, so an unknown one is a build-time refusal. */
+const JSON_TYPE_TESTS = {
+    string: types_1.isString,
+    number: (value) => typeof value === "number",
+    integer: (value) => typeof value === "number" && Number.isInteger(value),
+    boolean: (value) => typeof value === "boolean",
+    array: types_1.isArray,
+    object: types_1.isPlainObject,
+    null: (value) => value === null,
+};
+function isTypeKeyword(name) {
+    return Object.prototype.hasOwnProperty.call(JSON_TYPE_TESTS, name);
+}
+/** The declared names, always as a list, with unknown names rejected loudly. */
+function readDeclaredTypes(schema) {
+    const declared = schema.type;
+    if (declared === undefined)
+        return Object.freeze([]);
+    const names = (0, types_1.isArray)(declared) ? declared : [declared];
+    return Object.freeze(names.filter((name) => isTypeKeyword(name)));
+}
+/** True when the document permits an explicit null at this position. */
+function permitsNull(schema) {
+    const declared = readDeclaredTypes(schema);
+    return declared.length === 0 || declared.includes("null");
+}
+function describeActual(value) {
+    if (value === null)
+        return "null";
+    if ((0, types_1.isArray)(value))
+        return "array";
+    return typeof value;
+}
+/**
+ * One check for the whole list: `type: ["string","number"]` is a union, and
+ * running one rule per member would report a failure per member for a value
+ * that fails all of them.
+ */
+function declareTypeRules(schema, context) {
+    const declared = readDeclaredTypes(schema);
+    if (declared.length === 0)
+        return NO_RULES;
+    const tests = declared.map((name) => JSON_TYPE_TESTS[name]);
+    const rendered = declared.join(" or ");
+    return Object.freeze([
+        (0, create_rule_1.check)({
+            code: "type",
+            severity: context.build.config.defaultSeverity,
+            run: (value) => tests.some((test) => test(value))
+                ? types_1.PASS
+                : (0, types_1.fail)({ expected: rendered, actual: describeActual(value) }),
+            describe: (detail) => `Value must be of type ${rendered}, but got ${String(detail.actual)}`,
+            buildMessageContext: () => ({}),
+        }),
+    ]);
+}
+/** `type: "integer"` is the only `type` member that adds a chain method. */
+function declareIntegerRules(schema, context) {
+    if (!readDeclaredTypes(schema).includes("integer"))
+        return NO_RULES;
+    const plugin = context.bag.numberInteger;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "type")),
+    ]);
+}
+function declareConstRules(schema, context) {
+    if (!Object.prototype.hasOwnProperty.call(schema, "const"))
+        return NO_RULES;
+    const chain = (0, create_field_slots_1.createFieldSlots)(context.bag, context.build).any;
+    const applied = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_core_1.constBinding, schema.const);
+    return (0, create_chain_node_1.readChainRules)(applied) ?? NO_RULES;
+}
+/**
+ * `enum` drives the `.oneOf()` METHOD, which is a different thing from the
+ * `oneOf` KEYWORD. The list is typed against the FIELD (readonly SelfValue[]),
+ * so it carries a marker and can never be a keyword binding; the converter
+ * resolves the list and calls the plugin itself, exactly as the table says.
+ */
+function declareEnumRules(schema, context) {
+    const allowed = schema.enum;
+    if (allowed === undefined || allowed.length === 0)
+        return NO_RULES;
+    const plugin = context.bag.oneOf;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "enum"), allowed),
+    ]);
+}