@maroonedog/luq 2.0.0 → 2.1.0

package/dist/json-schema/collect-sub-schema-rules.mjs

@@ -18,20 +18,17 @@
 // ===========================================================================
 import { composite, fieldsBranch } from "../plugin-kit/create-rule.mjs";
 import { PASS } from "../types/index.mjs";
-import { resolveSchemaNode } from "./collect-definitions.mjs";
+import { resolveSchemaNodeInScope } from "./collect-definitions.mjs";
 import { declarePresenceRules } from "./declare-presence.mjs";
-import { permitsNull } from "./declare-value-keywords.mjs";
 import { EACH_STEP } from "./flatten-array-schema.mjs";
 import { expandSchemaRules, readChildSchemas } from "./schema-to-declarations.mjs";
 const NO_BRANCH_FIELDS = Object.freeze([]);
 function toBranchField(child, context) {
-    const node = resolveSchemaNode(child.schema, context.root);
     return {
         path: child.step,
         rules: Object.freeze([
             ...declarePresenceRules({
                 isRequired: child.isRequired,
-                allowsNull: permitsNull(node),
                 severity: context.build.config.defaultSeverity,
             }),
             ...context.collectSubSchemaRules(child.schema),
@@ -52,9 +49,31 @@ function composeProperties(children, context) {
         }),
     ];
 }
+/**
+ * Every sub-schema subject gets the same one-line statement: null is a VALUE
+ * here, so the checks run on it.
+ *
+ * src/runtime/run-field.ts settles presence BEFORE any check, and a subject
+ * with no presence rule carries OPEN_PRESENCE, which ends the field on null.
+ * A branch subject and an array element both arrive without one, so every
+ * check the sub-schema declared was skipped for null: `[null]` passed
+ * `{"items":{"type":"boolean"}}`, and `additionalItems: false` accepted a
+ * trailing null. Deciding it from `type` alone is not enough either —
+ * `false`, `{"not": {}}` and an `enum` without null forbid null while
+ * saying nothing about `type`.
+ */
+function declareOwnNullPolicy(context) {
+    return declarePresenceRules({
+        isRequired: false,
+        severity: context.build.config.defaultSeverity,
+    });
+}
 export function collectSubSchemaRules(schema, context) {
-    const node = resolveSchemaNode(schema, context.root);
-    const rules = [...expandSchemaRules(node, context)];
+    const node = resolveSchemaNodeInScope(schema, context.scope).node;
+    const rules = [
+        ...declareOwnNullPolicy(context),
+        ...expandSchemaRules(node, context),
+    ];
     const children = readChildSchemas(node);
     const properties = children.filter((child) => child.step !== EACH_STEP);
     if (properties.length > 0) {
@@ -68,11 +87,22 @@ export function collectSubSchemaRules(schema, context) {
     }
     return Object.freeze(rules);
 }
-/** Every branch of every composite is built here, so a branch is one shape. */
+/**
+ * Every branch of every composite is built here, so a branch is one shape.
+ *
+ * The call is to the function above and NOT to `context.collectSubSchemaRules`,
+ * and the difference is load-bearing. `context` is already the child context
+ * that createStructuralContext produced by DESCENDING through this schema, so
+ * a `$ref` here is already recorded in `visitedRefs`. Going through the
+ * context would descend the same `$ref` a second time, the recursion guard
+ * would see it as a cycle, and the branch would come back with no rules at all
+ * — `{"items":[{"$ref":"#/definitions/x"}]}` constrained nothing while the
+ * inline form `{"items":[{"type":"integer"}]}` worked.
+ */
 export function toSchemaBranch(label, schema, context) {
     return {
         label,
-        rules: context.collectSubSchemaRules(schema),
+        rules: collectSubSchemaRules(schema, context),
         fields: NO_BRANCH_FIELDS,
     };
 }

package/dist/json-schema/create-structural-context.d.ts

@@ -1,10 +1,20 @@
 import type { ChainBuildContext } from "../chain/create-chain-node";
-import type { Draft07Schema, Draft07SchemaObject } from "./draft07.types";
+import type { RefScope } from "./ref-scope";
+import type { Draft07SchemaObject } from "./draft07.types";
 import type { JsonSchemaBag } from "./json-schema-bag.types";
 import type { StructuralContext } from "./structural-expansion.types";
+/** Shared by every context of ONE conversion, so the budget is the whole. */
+interface ExpansionBudget {
+    remaining: number;
+}
 export interface ConversionSeed {
     readonly bag: JsonSchemaBag;
-    readonly root: Draft07Schema;
+    readonly scope: RefScope;
     readonly chain: ChainBuildContext;
+    /** Created by the entry point; every nested context shares this one. */
+    readonly budget?: ExpansionBudget;
 }
-export declare function createStructuralContext(seed: ConversionSeed, node: Draft07SchemaObject, visitedRefs: readonly string[]): StructuralContext;
+/** The budget a conversion starts with. One per document, not one per node. */
+export declare function createExpansionBudget(): ExpansionBudget;
+export declare function createStructuralContext(seed: ConversionSeed, node: Draft07SchemaObject, visitedRefs: readonly string[], scope?: RefScope): StructuralContext;
+export {};

package/dist/json-schema/create-structural-context.js

@@ -1,25 +1,91 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExpansionBudget = createExpansionBudget;
 exports.createStructuralContext = createStructuralContext;
 const collect_definitions_1 = require("./collect-definitions");
 const collect_sub_schema_rules_1 = require("./collect-sub-schema-rules");
 const NO_RULES = Object.freeze([]);
+/**
+ * How many times one `$ref` may be entered on a single branch of the
+ * conversion, and how much expansion the whole conversion may do.
+ *
+ * A recursive definition has infinitely many declared paths and Luq declares
+ * finite ones, so SOMETHING has to stop. It used to stop at the FIRST repeat,
+ * which is why a mutually recursive schema (tree -> node -> tree) checked only
+ * two levels and silently accepted anything deeper.
+ *
+ * Unrolling further is exponential in the number of mutually recursive
+ * definitions, and the measurement says so plainly. A three-way cycle
+ * (a -> b -> c -> a, each also naming the others) builds in:
+ *
+ *     1 unroll    17 ms      2 unrolls    55 ms
+ *     3 unrolls  538 ms      4 unrolls  9257 ms
+ *
+ * Three is what the corpus needs (the mutually recursive tree in ref.json
+ * puts its invalid value three levels down) and is where the cost is still
+ * a fraction of a second. It is a BUILD-time cost, paid once per document.
+ *
+ * The per-ref cap bounds the depth and leaves the WIDTH to the document, so
+ * it is not a bound on the work by itself. EXPANSION_BUDGET is: it caps the
+ * total number of `$ref` expansions one conversion may do, whatever shape
+ * the document has. It is deliberately far above what a real schema reaches
+ * — the whole official corpus stays under it — so it changes nothing for
+ * ordinary documents and only stops a pathological one from running away.
+ *
+ * Running out is not an error. The conversion stops adding rules, exactly as
+ * it did at the first repeat before, and the document is checked to the depth
+ * that was reached — the same silence as before, moved further out.
+ */
+const MAX_REF_UNROLL = 3;
+const EXPANSION_BUDGET = 100000;
+function countOf(pointers, pointer) {
+    let count = 0;
+    for (const one of pointers)
+        if (one === pointer)
+            count += 1;
+    return count;
+}
+/** The budget a conversion starts with. One per document, not one per node. */
+function createExpansionBudget() {
+    return { remaining: EXPANSION_BUDGET };
+}
 function propertyKeysOf(schema) {
     return Object.freeze(Object.keys(schema.properties ?? {}));
 }
-function createStructuralContext(seed, node, visitedRefs) {
+function createStructuralContext(seed, node, visitedRefs, scope = seed.scope) {
+    const budget = seed.budget ?? createExpansionBudget();
     const build = {
         fieldPath: seed.chain.fieldPath,
         declaredSiblingKeys: propertyKeysOf(node),
         config: seed.chain.config,
     };
+    /**
+     * One descent: the node this schema really is, and the context inside it.
+     *
+     * The RESOLVED node is handed back, and callers must use it rather than the
+     * schema they passed in. Resolving the same `$ref` a second time — which
+     * is what happens if the original is passed on — moves the base twice, so
+     * a relative reference under a relative `$id` doubles its own folder.
+     */
     const descend = (schema) => {
         const pointer = (0, collect_definitions_1.readRefPointer)(schema);
-        if (pointer !== undefined && visitedRefs.includes(pointer)) {
+        if (pointer !== undefined &&
+            countOf(visitedRefs, pointer) >= MAX_REF_UNROLL) {
             return undefined;
         }
+        if (pointer !== undefined) {
+            if (budget.remaining <= 0)
+                return undefined;
+            budget.remaining -= 1;
+        }
         const seen = pointer === undefined ? visitedRefs : [...visitedRefs, pointer];
-        return createStructuralContext(seed, (0, collect_definitions_1.resolveSchemaNode)(schema, seed.root), seen);
+        // The scope moves with the node: following a `$ref` into another
+        // document makes THAT document's base the one its own refs resolve in.
+        const resolved = (0, collect_definitions_1.resolveSchemaNodeInScope)(schema, scope);
+        return {
+            node: resolved.node,
+            context: createStructuralContext({ ...seed, budget }, resolved.node, seen, resolved.scope),
+        };
     };
     const ruleContextFor = (pluginName, code) => ({
         pluginName,
@@ -32,19 +98,19 @@ function createStructuralContext(seed, node, visitedRefs) {
     return {
         bag: seed.bag,
         build,
-        root: seed.root,
+        scope,
         visitedRefs,
         collectSubSchemaRules: (schema) => {
             const child = descend(schema);
             return child === undefined
                 ? NO_RULES
-                : (0, collect_sub_schema_rules_1.collectSubSchemaRules)(schema, child);
+                : (0, collect_sub_schema_rules_1.collectSubSchemaRules)(child.node, child.context);
         },
         toBranch: (label, schema) => {
             const child = descend(schema);
             return child === undefined
                 ? { label, rules: NO_RULES, fields: [] }
-                : (0, collect_sub_schema_rules_1.toSchemaBranch)(label, schema, child);
+                : (0, collect_sub_schema_rules_1.toSchemaBranch)(label, child.node, child.context);
         },
         ruleContextFor,
     };

package/dist/json-schema/create-structural-context.mjs

@@ -1,22 +1,87 @@
-import { readRefPointer, resolveSchemaNode } from "./collect-definitions.mjs";
+import { readRefPointer, resolveSchemaNodeInScope, } from "./collect-definitions.mjs";
 import { collectSubSchemaRules, toSchemaBranch, } from "./collect-sub-schema-rules.mjs";
 const NO_RULES = Object.freeze([]);
+/**
+ * How many times one `$ref` may be entered on a single branch of the
+ * conversion, and how much expansion the whole conversion may do.
+ *
+ * A recursive definition has infinitely many declared paths and Luq declares
+ * finite ones, so SOMETHING has to stop. It used to stop at the FIRST repeat,
+ * which is why a mutually recursive schema (tree -> node -> tree) checked only
+ * two levels and silently accepted anything deeper.
+ *
+ * Unrolling further is exponential in the number of mutually recursive
+ * definitions, and the measurement says so plainly. A three-way cycle
+ * (a -> b -> c -> a, each also naming the others) builds in:
+ *
+ *     1 unroll    17 ms      2 unrolls    55 ms
+ *     3 unrolls  538 ms      4 unrolls  9257 ms
+ *
+ * Three is what the corpus needs (the mutually recursive tree in ref.json
+ * puts its invalid value three levels down) and is where the cost is still
+ * a fraction of a second. It is a BUILD-time cost, paid once per document.
+ *
+ * The per-ref cap bounds the depth and leaves the WIDTH to the document, so
+ * it is not a bound on the work by itself. EXPANSION_BUDGET is: it caps the
+ * total number of `$ref` expansions one conversion may do, whatever shape
+ * the document has. It is deliberately far above what a real schema reaches
+ * — the whole official corpus stays under it — so it changes nothing for
+ * ordinary documents and only stops a pathological one from running away.
+ *
+ * Running out is not an error. The conversion stops adding rules, exactly as
+ * it did at the first repeat before, and the document is checked to the depth
+ * that was reached — the same silence as before, moved further out.
+ */
+const MAX_REF_UNROLL = 3;
+const EXPANSION_BUDGET = 100000;
+function countOf(pointers, pointer) {
+    let count = 0;
+    for (const one of pointers)
+        if (one === pointer)
+            count += 1;
+    return count;
+}
+/** The budget a conversion starts with. One per document, not one per node. */
+export function createExpansionBudget() {
+    return { remaining: EXPANSION_BUDGET };
+}
 function propertyKeysOf(schema) {
     return Object.freeze(Object.keys(schema.properties ?? {}));
 }
-export function createStructuralContext(seed, node, visitedRefs) {
+export function createStructuralContext(seed, node, visitedRefs, scope = seed.scope) {
+    const budget = seed.budget ?? createExpansionBudget();
     const build = {
         fieldPath: seed.chain.fieldPath,
         declaredSiblingKeys: propertyKeysOf(node),
         config: seed.chain.config,
     };
+    /**
+     * One descent: the node this schema really is, and the context inside it.
+     *
+     * The RESOLVED node is handed back, and callers must use it rather than the
+     * schema they passed in. Resolving the same `$ref` a second time — which
+     * is what happens if the original is passed on — moves the base twice, so
+     * a relative reference under a relative `$id` doubles its own folder.
+     */
     const descend = (schema) => {
         const pointer = readRefPointer(schema);
-        if (pointer !== undefined && visitedRefs.includes(pointer)) {
+        if (pointer !== undefined &&
+            countOf(visitedRefs, pointer) >= MAX_REF_UNROLL) {
             return undefined;
         }
+        if (pointer !== undefined) {
+            if (budget.remaining <= 0)
+                return undefined;
+            budget.remaining -= 1;
+        }
         const seen = pointer === undefined ? visitedRefs : [...visitedRefs, pointer];
-        return createStructuralContext(seed, resolveSchemaNode(schema, seed.root), seen);
+        // The scope moves with the node: following a `$ref` into another
+        // document makes THAT document's base the one its own refs resolve in.
+        const resolved = resolveSchemaNodeInScope(schema, scope);
+        return {
+            node: resolved.node,
+            context: createStructuralContext({ ...seed, budget }, resolved.node, seen, resolved.scope),
+        };
     };
     const ruleContextFor = (pluginName, code) => ({
         pluginName,
@@ -29,19 +94,19 @@ export function createStructuralContext(seed, node, visitedRefs) {
     return {
         bag: seed.bag,
         build,
-        root: seed.root,
+        scope,
         visitedRefs,
         collectSubSchemaRules: (schema) => {
             const child = descend(schema);
             return child === undefined
                 ? NO_RULES
-                : collectSubSchemaRules(schema, child);
+                : collectSubSchemaRules(child.node, child.context);
         },
         toBranch: (label, schema) => {
             const child = descend(schema);
             return child === undefined
                 ? { label, rules: NO_RULES, fields: [] }
-                : toSchemaBranch(label, schema, child);
+                : toSchemaBranch(label, child.node, child.context);
         },
         ruleContextFor,
     };

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

@@ -0,0 +1,19 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { ConverterChain } from "./apply-keyword-binding";
+import type { Draft07SchemaObject } from "./draft07.types";
+import type { StructuralContext } from "./structural-expansion.types";
+/**
+ * `patternProperties` のキー、つまり正規表現の文字列。
+ * additionalProperties が「該当しないキー」を選ぶのに要る。
+ */
+export declare function patternPropertyKeys(schema: Draft07SchemaObject): readonly string[];
+/**
+ * BOOLEAN 形。
+ *
+ * キーワード束縛は自分の値 (boolean) しか運べないので、パターンがあるときだけ
+ * プラグインを直接呼ぶ。束縛のほうは残す: キーワード表と「そのメソッドが
+ * 実在する」というコンパイル時のゲートはそちらが持っている。
+ */
+export declare function applyAdditionalPropertiesBoolean(chain: ConverterChain<"object">, schema: Draft07SchemaObject, allowed: boolean): ConverterChain<"object">;
+/** SCHEMA 形: 宣言にもパターンにも該当しない値が、そのスキーマに従う。 */
+export declare function declareAdditionalPropertiesSchema(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patternPropertyKeys = patternPropertyKeys;
+exports.applyAdditionalPropertiesBoolean = applyAdditionalPropertiesBoolean;
+exports.declareAdditionalPropertiesSchema = declareAdditionalPropertiesSchema;
+const apply_keyword_binding_1 = require("./apply-keyword-binding");
+const keyword_map_object_1 = require("./keyword-map-object");
+const NO_RULES = Object.freeze([]);
+/**
+ * `patternProperties` のキー、つまり正規表現の文字列。
+ * additionalProperties が「該当しないキー」を選ぶのに要る。
+ */
+function patternPropertyKeys(schema) {
+    const patterns = schema.patternProperties;
+    if (patterns === undefined || patterns === null)
+        return Object.freeze([]);
+    return Object.freeze(Object.keys(patterns));
+}
+/**
+ * BOOLEAN 形。
+ *
+ * キーワード束縛は自分の値 (boolean) しか運べないので、パターンがあるときだけ
+ * プラグインを直接呼ぶ。束縛のほうは残す: キーワード表と「そのメソッドが
+ * 実在する」というコンパイル時のゲートはそちらが持っている。
+ */
+function applyAdditionalPropertiesBoolean(chain, schema, allowed) {
+    const patterns = patternPropertyKeys(schema);
+    return patterns.length === 0
+        ? (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_object_1.additionalPropertiesBinding, allowed)
+        : chain.additionalProperties(allowed, undefined, patterns);
+}
+/** SCHEMA 形: 宣言にもパターンにも該当しない値が、そのスキーマに従う。 */
+function declareAdditionalPropertiesSchema(schema, context) {
+    const additional = schema.additionalProperties;
+    if (additional === undefined || typeof additional === "boolean") {
+        return NO_RULES;
+    }
+    const plugin = context.bag.objectAdditionalPropertiesSchema;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "additionalProperties"), context.collectSubSchemaRules(additional), undefined, patternPropertyKeys(schema)),
+    ]);
+}

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

@@ -0,0 +1,37 @@
+import { applyKeywordBinding } from "./apply-keyword-binding.mjs";
+import { additionalPropertiesBinding } from "./keyword-map-object.mjs";
+const NO_RULES = Object.freeze([]);
+/**
+ * `patternProperties` のキー、つまり正規表現の文字列。
+ * additionalProperties が「該当しないキー」を選ぶのに要る。
+ */
+export function patternPropertyKeys(schema) {
+    const patterns = schema.patternProperties;
+    if (patterns === undefined || patterns === null)
+        return Object.freeze([]);
+    return Object.freeze(Object.keys(patterns));
+}
+/**
+ * BOOLEAN 形。
+ *
+ * キーワード束縛は自分の値 (boolean) しか運べないので、パターンがあるときだけ
+ * プラグインを直接呼ぶ。束縛のほうは残す: キーワード表と「そのメソッドが
+ * 実在する」というコンパイル時のゲートはそちらが持っている。
+ */
+export function applyAdditionalPropertiesBoolean(chain, schema, allowed) {
+    const patterns = patternPropertyKeys(schema);
+    return patterns.length === 0
+        ? applyKeywordBinding(chain, additionalPropertiesBinding, allowed)
+        : chain.additionalProperties(allowed, undefined, patterns);
+}
+/** SCHEMA 形: 宣言にもパターンにも該当しない値が、そのスキーマに従う。 */
+export function declareAdditionalPropertiesSchema(schema, context) {
+    const additional = schema.additionalProperties;
+    if (additional === undefined || typeof additional === "boolean") {
+        return NO_RULES;
+    }
+    const plugin = context.bag.objectAdditionalPropertiesSchema;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "additionalProperties"), context.collectSubSchemaRules(additional), undefined, patternPropertyKeys(schema)),
+    ]);
+}

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

@@ -2,8 +2,6 @@ import type { Rule } from "../plugin-kit/compiled-rule";
 import type { Draft07Schema, Draft07SchemaObject } from "./draft07.types";
 import type { StructuralContext } from "./structural-expansion.types";
 export declare function declareObjectRules(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
-/** The SCHEMA form of `additionalProperties`: every undeclared value obeys it. */
-export declare function declareAdditionalPropertiesSchema(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
 /** EVERY matching pattern applies; 1.x broke after the first match. */
 export declare function declarePatternProperties(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
 /** A sub-chain over the property NAMES, which are always strings. */

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.declareObjectRules = declareObjectRules;
-exports.declareAdditionalPropertiesSchema = declareAdditionalPropertiesSchema;
 exports.declarePatternProperties = declarePatternProperties;
 exports.declarePropertyNames = declarePropertyNames;
 exports.declareDependencies = declareDependencies;
@@ -23,6 +22,7 @@ exports.readPropertyChildren = readPropertyChildren;
 const create_chain_node_1 = require("../chain/create-chain-node");
 const create_field_slots_1 = require("../chain/create-field-slots");
 const types_1 = require("../types");
+const declare_additional_properties_1 = require("./declare-additional-properties");
 const apply_keyword_binding_1 = require("./apply-keyword-binding");
 const collect_definitions_1 = require("./collect-definitions");
 const keyword_map_object_1 = require("./keyword-map-object");
@@ -40,21 +40,14 @@ function declareObjectRules(schema, context) {
     }
     const additional = schema.additionalProperties;
     if (typeof additional === "boolean") {
-        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_object_1.additionalPropertiesBinding, additional);
+        // §6.5.4 の対象は「properties にも patternProperties にも該当しない」キー。
+        // キーワード束縛は自分の値 (boolean) しか運べないので、パターンがある
+        // ときだけプラグインを直接呼ぶ。束縛のほうは残す: キーワード表と
+        // 「そのメソッドが実在する」というコンパイル時のゲートはそちらが持つ。
+        chain = (0, declare_additional_properties_1.applyAdditionalPropertiesBoolean)(chain, schema, additional);
     }
     return readRules(chain);
 }
-/** The SCHEMA form of `additionalProperties`: every undeclared value obeys it. */
-function declareAdditionalPropertiesSchema(schema, context) {
-    const additional = schema.additionalProperties;
-    if (additional === undefined || typeof additional === "boolean") {
-        return NO_RULES;
-    }
-    const plugin = context.bag.objectAdditionalPropertiesSchema;
-    return Object.freeze([
-        plugin.build(context.ruleContextFor(plugin.name, "additionalProperties"), context.collectSubSchemaRules(additional)),
-    ]);
-}
 /** EVERY matching pattern applies; 1.x broke after the first match. */
 function declarePatternProperties(schema, context) {
     const patterns = schema.patternProperties;

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

@@ -15,9 +15,10 @@
 import { readChainRules } from "../chain/create-chain-node.mjs";
 import { createFieldSlots } from "../chain/create-field-slots.mjs";
 import { isStringArray } from "../types/index.mjs";
+import { applyAdditionalPropertiesBoolean } from "./declare-additional-properties.mjs";
 import { applyKeywordBinding } from "./apply-keyword-binding.mjs";
 import { toSchemaObject } from "./collect-definitions.mjs";
-import { additionalPropertiesBinding, maxPropertiesBinding, minPropertiesBinding, } from "./keyword-map-object.mjs";
+import { maxPropertiesBinding, minPropertiesBinding, } from "./keyword-map-object.mjs";
 const NO_RULES = Object.freeze([]);
 function readRules(chain) {
     return readChainRules(chain) ?? NO_RULES;
@@ -32,21 +33,14 @@ export function declareObjectRules(schema, context) {
     }
     const additional = schema.additionalProperties;
     if (typeof additional === "boolean") {
-        chain = applyKeywordBinding(chain, additionalPropertiesBinding, additional);
+        // §6.5.4 の対象は「properties にも patternProperties にも該当しない」キー。
+        // キーワード束縛は自分の値 (boolean) しか運べないので、パターンがある
+        // ときだけプラグインを直接呼ぶ。束縛のほうは残す: キーワード表と
+        // 「そのメソッドが実在する」というコンパイル時のゲートはそちらが持つ。
+        chain = applyAdditionalPropertiesBoolean(chain, schema, additional);
     }
     return readRules(chain);
 }
-/** The SCHEMA form of `additionalProperties`: every undeclared value obeys it. */
-export function declareAdditionalPropertiesSchema(schema, context) {
-    const additional = schema.additionalProperties;
-    if (additional === undefined || typeof additional === "boolean") {
-        return NO_RULES;
-    }
-    const plugin = context.bag.objectAdditionalPropertiesSchema;
-    return Object.freeze([
-        plugin.build(context.ruleContextFor(plugin.name, "additionalProperties"), context.collectSubSchemaRules(additional)),
-    ]);
-}
 /** EVERY matching pattern applies; 1.x broke after the first match. */
 export function declarePatternProperties(schema, context) {
     const patterns = schema.patternProperties;

package/dist/json-schema/declare-presence.d.ts

@@ -2,11 +2,17 @@ import type { Rule } from "../plugin-kit/compiled-rule";
 import type { IssueSeverity } from "../types";
 export interface PresenceDeclaration {
     readonly isRequired: boolean;
-    readonly allowsNull: boolean;
     readonly severity: IssueSeverity;
 }
 /**
- * A field that may be absent AND may be null needs no rule at all: that is
- * OPEN_PRESENCE, the policy a field with no presence rule already carries.
+ * 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 declare function declarePresenceRules(declaration: PresenceDeclaration): readonly Rule[];

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

@@ -23,20 +23,26 @@ exports.declarePresenceRules = declarePresenceRules;
 // ===========================================================================
 const create_rule_1 = require("../plugin-kit/create-rule");
 /**
- * A field that may be absent AND may be null needs no rule at all: that is
- * OPEN_PRESENCE, the policy a field with no presence rule already carries.
+ * 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) {
-    if (!declaration.isRequired && declaration.allowsNull) {
-        return Object.freeze([]);
-    }
     return Object.freeze([
         (0, create_rule_1.presence)({
             code: declaration.isRequired ? "required" : "type",
             severity: declaration.severity,
             allowUndefined: !declaration.isRequired,
-            allowNull: declaration.allowsNull,
+            // 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`,

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

@@ -20,20 +20,26 @@
 // ===========================================================================
 import { presence } from "../plugin-kit/create-rule.mjs";
 /**
- * A field that may be absent AND may be null needs no rule at all: that is
- * OPEN_PRESENCE, the policy a field with no presence rule already carries.
+ * 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) {
-    if (!declaration.isRequired && declaration.allowsNull) {
-        return Object.freeze([]);
-    }
     return Object.freeze([
         presence({
             code: declaration.isRequired ? "required" : "type",
             severity: declaration.severity,
             allowUndefined: !declaration.isRequired,
-            allowNull: declaration.allowsNull,
+            // 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`,

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

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