@maroonedog/luq 0.1.2-alpha → 2.1.0

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

@@ -0,0 +1,117 @@
+"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, 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 &&
+            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];
+        // 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,
+        code,
+        severity: build.config.defaultSeverity,
+        config: build.config,
+        fieldPath: build.fieldPath,
+        declaredSiblingKeys: build.declaredSiblingKeys,
+    });
+    return {
+        bag: seed.bag,
+        build,
+        scope,
+        visitedRefs,
+        collectSubSchemaRules: (schema) => {
+            const child = descend(schema);
+            return child === undefined
+                ? NO_RULES
+                : (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, child.node, child.context);
+        },
+        ruleContextFor,
+    };
+}

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

@@ -0,0 +1,113 @@
+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, 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 &&
+            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];
+        // 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,
+        code,
+        severity: build.config.defaultSeverity,
+        config: build.config,
+        fieldPath: build.fieldPath,
+        declaredSiblingKeys: build.declaredSiblingKeys,
+    });
+    return {
+        bag: seed.bag,
+        build,
+        scope,
+        visitedRefs,
+        collectSubSchemaRules: (schema) => {
+            const child = descend(schema);
+            return child === undefined
+                ? NO_RULES
+                : collectSubSchemaRules(child.node, child.context);
+        },
+        toBranch: (label, schema) => {
+            const child = descend(schema);
+            return child === undefined
+                ? { label, rules: NO_RULES, fields: [] }
+                : 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

@@ -0,0 +1,22 @@
+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[];
+/** 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. */
+export declare function declarePropertyNames(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+export declare function declareDependencies(schema: Draft07SchemaObject, context: StructuralContext): readonly Rule[];
+/**
+ * `properties` becomes one declared path per key; see flatten-schema.ts.
+ *
+ * Every child is declared NOT required here: requiredness belongs to the object
+ * (declareRequiredProperties). A name in `required` with no `properties` entry
+ * still gets a path on the empty schema, because §6.5.3 makes the two keywords
+ * independent and the root distribution needs the path to exist.
+ */
+export declare function readPropertyChildren(schema: Draft07SchemaObject): readonly {
+    step: string;
+    schema: Draft07Schema;
+    isRequired: boolean;
+}[];

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.declareObjectRules = declareObjectRules;
+exports.declarePatternProperties = declarePatternProperties;
+exports.declarePropertyNames = declarePropertyNames;
+exports.declareDependencies = declareDependencies;
+exports.readPropertyChildren = readPropertyChildren;
+// ===========================================================================
+// L8  src/json-schema/declare-object-keywords.ts — the object keywords: the
+// three that bind, and the four object shapes that expand.
+//
+// THE NORMALISATIONS THE COMPILER FORCES (draft07-keyword-value.types.ts):
+//   additionalProperties  a schema is a sub-CHAIN and only the boolean form
+//                         binds. `declaredSiblingKeys` on the chain context is
+//                         set by schema-to-declarations to THIS schema's own
+//                         `properties` keys, so the plugin's allowed set is the
+//                         draft's — 1.x defaulted it to the empty list and
+//                         `additionalProperties: false` rejected every property.
+//   dependencies          one keyword, two chain methods: a key list drives
+//                         .dependentRequired(), a sub-schema .dependentSchemas().
+// ===========================================================================
+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");
+const NO_RULES = Object.freeze([]);
+function readRules(chain) {
+    return (0, create_chain_node_1.readChainRules)(chain) ?? NO_RULES;
+}
+function declareObjectRules(schema, context) {
+    let chain = (0, create_field_slots_1.createFieldSlots)(context.bag, context.build).object;
+    if (schema.minProperties !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_object_1.minPropertiesBinding, schema.minProperties);
+    }
+    if (schema.maxProperties !== undefined) {
+        chain = (0, apply_keyword_binding_1.applyKeywordBinding)(chain, keyword_map_object_1.maxPropertiesBinding, schema.maxProperties);
+    }
+    const additional = schema.additionalProperties;
+    if (typeof additional === "boolean") {
+        // §6.5.4 の対象は「properties にも patternProperties にも該当しない」キー。
+        // キーワード束縛は自分の値 (boolean) しか運べないので、パターンがある
+        // ときだけプラグインを直接呼ぶ。束縛のほうは残す: キーワード表と
+        // 「そのメソッドが実在する」というコンパイル時のゲートはそちらが持つ。
+        chain = (0, declare_additional_properties_1.applyAdditionalPropertiesBoolean)(chain, schema, additional);
+    }
+    return readRules(chain);
+}
+/** EVERY matching pattern applies; 1.x broke after the first match. */
+function declarePatternProperties(schema, context) {
+    const patterns = schema.patternProperties;
+    if (patterns === undefined)
+        return NO_RULES;
+    const byPattern = {};
+    for (const [pattern, member] of Object.entries(patterns)) {
+        byPattern[pattern] = context.collectSubSchemaRules(member);
+    }
+    const plugin = context.bag.objectPatternProperties;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "patternProperties"), Object.freeze(byPattern)),
+    ]);
+}
+/** A sub-chain over the property NAMES, which are always strings. */
+function declarePropertyNames(schema, context) {
+    const names = schema.propertyNames;
+    if (names === undefined)
+        return NO_RULES;
+    const plugin = context.bag.objectPropertyNames;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "propertyNames"), context.collectSubSchemaRules(names)),
+    ]);
+}
+function splitDependencies(dependencies) {
+    const required = {};
+    const schemas = {};
+    for (const [key, dependency] of Object.entries(dependencies)) {
+        if ((0, types_1.isStringArray)(dependency)) {
+            required[key] = dependency;
+            continue;
+        }
+        schemas[key] = (0, collect_definitions_1.toSchemaObject)(dependency);
+    }
+    return { required, schemas };
+}
+function declareDependencies(schema, context) {
+    const dependencies = schema.dependencies;
+    if (dependencies === undefined)
+        return NO_RULES;
+    const split = splitDependencies(dependencies);
+    const rules = [];
+    if (Object.keys(split.required).length > 0) {
+        const plugin = context.bag.objectDependentRequired;
+        rules.push(plugin.build(context.ruleContextFor(plugin.name, "dependencies"), Object.freeze(split.required)));
+    }
+    const schemaKeys = Object.keys(split.schemas);
+    if (schemaKeys.length > 0) {
+        const byKey = {};
+        for (const key of schemaKeys) {
+            const member = split.schemas[key];
+            if (member === undefined)
+                continue;
+            byKey[key] = context.collectSubSchemaRules(member);
+        }
+        const plugin = context.bag.objectDependentSchemas;
+        rules.push(plugin.build(context.ruleContextFor(plugin.name, "dependencies"), Object.freeze(byKey)));
+    }
+    return Object.freeze(rules);
+}
+/**
+ * `properties` becomes one declared path per key; see flatten-schema.ts.
+ *
+ * Every child is declared NOT required here: requiredness belongs to the object
+ * (declareRequiredProperties). A name in `required` with no `properties` entry
+ * still gets a path on the empty schema, because §6.5.3 makes the two keywords
+ * independent and the root distribution needs the path to exist.
+ */
+function readPropertyChildren(schema) {
+    const properties = schema.properties ?? {};
+    const required = schema.required ?? [];
+    const children = Object.entries(properties).map(([key, member]) => ({
+        step: key,
+        schema: member,
+        isRequired: false,
+    }));
+    for (const key of required) {
+        if (Object.prototype.hasOwnProperty.call(properties, key))
+            continue;
+        children.push({ step: key, schema: true, isRequired: false });
+    }
+    return Object.freeze(children);
+}

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

@@ -0,0 +1,126 @@
+// ===========================================================================
+// L8  src/json-schema/declare-object-keywords.ts — the object keywords: the
+// three that bind, and the four object shapes that expand.
+//
+// THE NORMALISATIONS THE COMPILER FORCES (draft07-keyword-value.types.ts):
+//   additionalProperties  a schema is a sub-CHAIN and only the boolean form
+//                         binds. `declaredSiblingKeys` on the chain context is
+//                         set by schema-to-declarations to THIS schema's own
+//                         `properties` keys, so the plugin's allowed set is the
+//                         draft's — 1.x defaulted it to the empty list and
+//                         `additionalProperties: false` rejected every property.
+//   dependencies          one keyword, two chain methods: a key list drives
+//                         .dependentRequired(), a sub-schema .dependentSchemas().
+// ===========================================================================
+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 { maxPropertiesBinding, minPropertiesBinding, } from "./keyword-map-object.mjs";
+const NO_RULES = Object.freeze([]);
+function readRules(chain) {
+    return readChainRules(chain) ?? NO_RULES;
+}
+export function declareObjectRules(schema, context) {
+    let chain = createFieldSlots(context.bag, context.build).object;
+    if (schema.minProperties !== undefined) {
+        chain = applyKeywordBinding(chain, minPropertiesBinding, schema.minProperties);
+    }
+    if (schema.maxProperties !== undefined) {
+        chain = applyKeywordBinding(chain, maxPropertiesBinding, schema.maxProperties);
+    }
+    const additional = schema.additionalProperties;
+    if (typeof additional === "boolean") {
+        // §6.5.4 の対象は「properties にも patternProperties にも該当しない」キー。
+        // キーワード束縛は自分の値 (boolean) しか運べないので、パターンがある
+        // ときだけプラグインを直接呼ぶ。束縛のほうは残す: キーワード表と
+        // 「そのメソッドが実在する」というコンパイル時のゲートはそちらが持つ。
+        chain = applyAdditionalPropertiesBoolean(chain, schema, additional);
+    }
+    return readRules(chain);
+}
+/** EVERY matching pattern applies; 1.x broke after the first match. */
+export function declarePatternProperties(schema, context) {
+    const patterns = schema.patternProperties;
+    if (patterns === undefined)
+        return NO_RULES;
+    const byPattern = {};
+    for (const [pattern, member] of Object.entries(patterns)) {
+        byPattern[pattern] = context.collectSubSchemaRules(member);
+    }
+    const plugin = context.bag.objectPatternProperties;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "patternProperties"), Object.freeze(byPattern)),
+    ]);
+}
+/** A sub-chain over the property NAMES, which are always strings. */
+export function declarePropertyNames(schema, context) {
+    const names = schema.propertyNames;
+    if (names === undefined)
+        return NO_RULES;
+    const plugin = context.bag.objectPropertyNames;
+    return Object.freeze([
+        plugin.build(context.ruleContextFor(plugin.name, "propertyNames"), context.collectSubSchemaRules(names)),
+    ]);
+}
+function splitDependencies(dependencies) {
+    const required = {};
+    const schemas = {};
+    for (const [key, dependency] of Object.entries(dependencies)) {
+        if (isStringArray(dependency)) {
+            required[key] = dependency;
+            continue;
+        }
+        schemas[key] = toSchemaObject(dependency);
+    }
+    return { required, schemas };
+}
+export function declareDependencies(schema, context) {
+    const dependencies = schema.dependencies;
+    if (dependencies === undefined)
+        return NO_RULES;
+    const split = splitDependencies(dependencies);
+    const rules = [];
+    if (Object.keys(split.required).length > 0) {
+        const plugin = context.bag.objectDependentRequired;
+        rules.push(plugin.build(context.ruleContextFor(plugin.name, "dependencies"), Object.freeze(split.required)));
+    }
+    const schemaKeys = Object.keys(split.schemas);
+    if (schemaKeys.length > 0) {
+        const byKey = {};
+        for (const key of schemaKeys) {
+            const member = split.schemas[key];
+            if (member === undefined)
+                continue;
+            byKey[key] = context.collectSubSchemaRules(member);
+        }
+        const plugin = context.bag.objectDependentSchemas;
+        rules.push(plugin.build(context.ruleContextFor(plugin.name, "dependencies"), Object.freeze(byKey)));
+    }
+    return Object.freeze(rules);
+}
+/**
+ * `properties` becomes one declared path per key; see flatten-schema.ts.
+ *
+ * Every child is declared NOT required here: requiredness belongs to the object
+ * (declareRequiredProperties). A name in `required` with no `properties` entry
+ * still gets a path on the empty schema, because §6.5.3 makes the two keywords
+ * independent and the root distribution needs the path to exist.
+ */
+export function readPropertyChildren(schema) {
+    const properties = schema.properties ?? {};
+    const required = schema.required ?? [];
+    const children = Object.entries(properties).map(([key, member]) => ({
+        step: key,
+        schema: member,
+        isRequired: false,
+    }));
+    for (const key of required) {
+        if (Object.prototype.hasOwnProperty.call(properties, key))
+            continue;
+        children.push({ step: key, schema: true, isRequired: false });
+    }
+    return Object.freeze(children);
+}

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

@@ -0,0 +1,18 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { IssueSeverity } from "../types";
+export interface PresenceDeclaration {
+    readonly isRequired: boolean;
+    readonly severity: IssueSeverity;
+}
+/**
+ * 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[];