@maroonedog/luq 2.0.0 → 2.2.0

package/dist/json-schema/collect-definitions.mjs

@@ -1,5 +1,7 @@
 import { isSchemaObject } from "./draft07.types.mjs";
-import { resolveRef } from "./resolve-ref.mjs";
+import { createLocalScope } from "./ref-scope.mjs";
+import { resolveRefInScope } from "./resolve-ref.mjs";
+import { nextBaseUri } from "./uri-reference.mjs";
 /** `true`: matches every instance. */
 const ALWAYS_SCHEMA = Object.freeze({});
 /** `false`: matches nothing. `not` of the empty schema, so no new rule kind. */
@@ -28,10 +30,50 @@ export function toSchemaObject(schema) {
  * this draft `$ref` replaces the object it appears in.
  */
 export function resolveSchemaNode(schema, root) {
+    return resolveSchemaNodeInScope(schema, createLocalScope(root)).node;
+}
+/**
+ * The scope-aware form, and the one the converter uses.
+ *
+ * The returned scope is not the one passed in: following a `$ref` can cross
+ * into another document, and a `$ref` written inside THAT document resolves
+ * against ITS base. Returning only the node — which is what the root-taking
+ * form above can do — loses that, and is why a two-document schema resolved
+ * its second hop against the first document.
+ */
+export function resolveSchemaNodeInScope(schema, scope) {
     const node = toSchemaObject(schema);
-    if (node.$ref === undefined)
-        return node;
-    return toSchemaObject(resolveRef(node.$ref, root));
+    if (node.$ref === undefined) {
+        // A node's own `$id` moves the base for everything inside it (§8.2).
+        return { node, scope: advanceBase(scope, node) };
+    }
+    // Following a `$ref` lands in whatever base the TARGET lives in, and
+    // resolve-ref already knows it — for a document fetched by URI that is the
+    // retrieval URI, which the draft says wins over the document's own `$id`.
+    const resolved = resolveRefInScope(node.$ref, scope);
+    return { node: toSchemaObject(resolved.schema), scope: resolved.scope };
+}
+/**
+ * The ONE place a base URI advances. It was also being done by the caller,
+ * and doing it in both meant a relative `$id` was applied twice: a `$ref`
+ * of "nested/foo.json" under `$id: "nested/"` went looking for
+ * ".../nested/nested/foo.json".
+ *
+ * A base-setting `$id` starts a new RESOURCE, so the node also becomes the
+ * document that `#/definitions/x` written under it resolves against. Moving
+ * the base without moving the document is why
+ * `{"$id":"a.json","properties":{"foo":{"$id":"b.json","definitions":{...},
+ * "allOf":[{"$ref":"#/definitions/inner"}]}}}` looked for `inner` in the
+ * OUTER document, where it does not exist.
+ */
+export function advanceBase(scope, node) {
+    const id = node.$id;
+    if (typeof id !== "string" || id === "")
+        return scope;
+    const baseUri = nextBaseUri(scope.baseUri, id);
+    if (baseUri === scope.baseUri)
+        return scope;
+    return { ...scope, baseUri, document: node };
 }
 /**
  * The pointer a node forwards to, or undefined. Used by the flattener to spot

package/dist/json-schema/collect-sub-schema-rules.d.ts

@@ -2,5 +2,16 @@ import type { CompositeBranch, Rule } from "../plugin-kit/compiled-rule";
 import type { Draft07Schema } from "./draft07.types";
 import type { StructuralContext } from "./structural-expansion.types";
 export declare function collectSubSchemaRules(schema: Draft07Schema, context: StructuralContext): readonly Rule[];
-/** 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 declare function toSchemaBranch(label: string, schema: Draft07Schema, context: StructuralContext): CompositeBranch;

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

@@ -24,18 +24,15 @@ const create_rule_1 = require("../plugin-kit/create-rule");
 const types_1 = require("../types");
 const collect_definitions_1 = require("./collect-definitions");
 const declare_presence_1 = require("./declare-presence");
-const declare_value_keywords_1 = require("./declare-value-keywords");
 const flatten_array_schema_1 = require("./flatten-array-schema");
 const schema_to_declarations_1 = require("./schema-to-declarations");
 const NO_BRANCH_FIELDS = Object.freeze([]);
 function toBranchField(child, context) {
-    const node = (0, collect_definitions_1.resolveSchemaNode)(child.schema, context.root);
     return {
         path: child.step,
         rules: Object.freeze([
             ...(0, declare_presence_1.declarePresenceRules)({
                 isRequired: child.isRequired,
-                allowsNull: (0, declare_value_keywords_1.permitsNull)(node),
                 severity: context.build.config.defaultSeverity,
             }),
             ...context.collectSubSchemaRules(child.schema),
@@ -56,9 +53,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 (0, declare_presence_1.declarePresenceRules)({
+        isRequired: false,
+        severity: context.build.config.defaultSeverity,
+    });
+}
 function collectSubSchemaRules(schema, context) {
-    const node = (0, collect_definitions_1.resolveSchemaNode)(schema, context.root);
-    const rules = [...(0, schema_to_declarations_1.expandSchemaRules)(node, context)];
+    const node = (0, collect_definitions_1.resolveSchemaNodeInScope)(schema, context.scope).node;
+    const rules = [
+        ...declareOwnNullPolicy(context),
+        ...(0, schema_to_declarations_1.expandSchemaRules)(node, context),
+    ];
     const children = (0, schema_to_declarations_1.readChildSchemas)(node);
     const properties = children.filter((child) => child.step !== flatten_array_schema_1.EACH_STEP);
     if (properties.length > 0) {
@@ -72,11 +91,22 @@ 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.
+ */
 function toSchemaBranch(label, schema, context) {
     return {
         label,
-        rules: context.collectSubSchemaRules(schema),
+        rules: collectSubSchemaRules(schema, context),
         fields: NO_BRANCH_FIELDS,
     };
 }

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;