@maroonedog/luq 2.0.0 → 2.1.0

package/dist/json-schema/schema-registry.mjs

@@ -0,0 +1,139 @@
+// ===========================================================================
+// L8  src/json-schema/schema-registry.ts — どの URI がどのスキーマを指すか。
+//
+// Draft-07 §8.2 では `$id` が二つの働きをする: 場所を示す URI はベースを
+// 立て直し、`#name` の形は**位置に依らない名前**を付ける。どちらも
+// 「この URI はこのノード」という索引で、それがこのファイルの責務である。
+// ポインタ (`#/definitions/x`) を辿るのは場所の話なので resolve-ref.ts が持つ。
+//
+// 外部文書は**呼び出し側が渡したものだけ**である。Luq は取りに行かない:
+// 関数ではなく地図 (`externalDocuments`) を受けるのは、そうすれば
+//   * スキーマに書かれた URI でプロセスがソケットを開くことがない (SSRF)、
+//   * 変換が同期のままで、CSP でも動く、
+//   * 何が読まれうるかが呼び出し側のコードに全部書いてある、
+// の三つが同時に成り立つからで、非同期ローダーではどれも失われる。
+// ===========================================================================
+import { isDraft07Schema, isSchemaObject } from "./draft07.types.mjs";
+import { isArray, isPlainObject } from "../types/index.mjs";
+import { nextBaseUri, normalizeUri, readAnchor } from "./uri-reference.mjs";
+/** Keywords whose value is ONE schema. */
+const SCHEMA_VALUED = Object.freeze([
+    "additionalProperties",
+    "additionalItems",
+    "contains",
+    "propertyNames",
+    "not",
+    "if",
+    "then",
+    "else",
+]);
+/** Keywords whose value is an ARRAY of schemas. `items` is in both lists. */
+const SCHEMA_LIST_VALUED = Object.freeze([
+    "allOf",
+    "anyOf",
+    "oneOf",
+]);
+/** Keywords whose value is a MAP of name to schema. */
+const SCHEMA_MAP_VALUED = Object.freeze([
+    "properties",
+    "patternProperties",
+    "definitions",
+    "$defs",
+    "dependencies",
+]);
+function walkSchema(schema, base, document, register) {
+    if (!isSchemaObject(schema))
+        return;
+    const id = typeof schema.$id === "string" ? schema.$id : undefined;
+    const here = nextBaseUri(base, id);
+    // A base-setting `$id` starts a new resource, so the node becomes the
+    // document every relative pointer under it resolves against.
+    const startsResource = id !== undefined && here !== base;
+    const inner = startsResource ? schema : document;
+    if (startsResource) {
+        register(normalizeUri(here), { schema, baseUri: here, document: schema });
+    }
+    const anchor = readAnchor(id);
+    if (anchor !== undefined) {
+        register(normalizeUri(`${here}#${anchor}`), {
+            schema,
+            baseUri: here,
+            document: inner,
+        });
+    }
+    walkMembers(schema, here, inner, register);
+}
+/**
+ * Read by ENTRY rather than by indexing the typed node: Draft07SchemaObject
+ * declares its keywords and carries no index signature, and reaching a keyword
+ * by name would need an assertion — src/core/type-erasure.ts is the only place
+ * permitted to write one, and this is not it.
+ */
+function walkMembers(schema, base, document, register) {
+    for (const [keyword, value] of Object.entries(schema)) {
+        if (keyword === "items") {
+            // The one keyword with both shapes, so it is walked as both.
+            walkIfSchema(value, base, document, register);
+            walkList(value, base, document, register);
+            continue;
+        }
+        if (SCHEMA_VALUED.includes(keyword)) {
+            walkIfSchema(value, base, document, register);
+        }
+        else if (SCHEMA_LIST_VALUED.includes(keyword)) {
+            walkList(value, base, document, register);
+        }
+        else if (SCHEMA_MAP_VALUED.includes(keyword)) {
+            walkMap(value, base, document, register);
+        }
+    }
+}
+function walkIfSchema(value, base, document, register) {
+    if (!isDraft07Schema(value))
+        return;
+    walkSchema(value, base, document, register);
+}
+function walkList(value, base, document, register) {
+    if (!isArray(value))
+        return;
+    for (const member of value)
+        walkIfSchema(member, base, document, register);
+}
+function walkMap(value, base, document, register) {
+    if (!isPlainObject(value))
+        return;
+    for (const member of Object.values(value)) {
+        walkIfSchema(member, base, document, register);
+    }
+}
+/**
+ * Every `$id` in `root` and in each supplied external document.
+ *
+ * The external map's KEY is a URI in its own right: the suite (and real
+ * callers) fetch `http://host/a.json` into a document that does not repeat its
+ * own `$id`, so the key is what a `$ref` will name. A document that DOES carry
+ * `$id` registers that too, and the `$id` wins where they disagree — it is the
+ * document's own statement about its identity.
+ */
+export function createSchemaRegistry(root, externalDocuments = {}) {
+    const byUri = new Map();
+    const register = (uri, target) => {
+        if (!byUri.has(uri))
+            byUri.set(uri, target);
+    };
+    for (const [uri, document] of Object.entries(externalDocuments)) {
+        if (!isDraft07Schema(document))
+            continue;
+        const key = normalizeUri(uri);
+        register(key, { schema: document, baseUri: key, document });
+    }
+    for (const [uri, document] of Object.entries(externalDocuments)) {
+        if (!isDraft07Schema(document))
+            continue;
+        walkSchema(document, normalizeUri(uri), document, register);
+    }
+    walkSchema(root, "", root, register);
+    return {
+        findIdentified: (uri) => byUri.get(normalizeUri(uri)),
+    };
+}

package/dist/json-schema/schema-to-declarations.js

@@ -7,6 +7,7 @@ exports.expandSchemaRules = expandSchemaRules;
 const collect_definitions_1 = require("./collect-definitions");
 const compose_conditional_1 = require("./compose-conditional");
 const compose_keyword_1 = require("./compose-keyword");
+const declare_additional_properties_1 = require("./declare-additional-properties");
 const declare_object_keywords_1 = require("./declare-object-keywords");
 const declare_required_properties_1 = require("./declare-required-properties");
 const declare_scalar_keywords_1 = require("./declare-scalar-keywords");
@@ -103,7 +104,7 @@ function expandSchemaRules(schema, context) {
         ...(0, flatten_array_schema_1.declareArrayRules)(schema, context),
         ...(0, declare_object_keywords_1.declareObjectRules)(schema, context),
         ...(0, declare_value_keywords_1.declareConstRules)(schema, context),
-        ...(0, declare_object_keywords_1.declareAdditionalPropertiesSchema)(schema, context),
+        ...(0, declare_additional_properties_1.declareAdditionalPropertiesSchema)(schema, context),
         ...(0, declare_required_properties_1.declareRequiredProperties)(schema, context),
     ];
     for (const keyword of Object.keys(schema)) {

package/dist/json-schema/schema-to-declarations.mjs

@@ -1,7 +1,8 @@
 import { isDefinitionContainer } from "./collect-definitions.mjs";
 import { composeConditional } from "./compose-conditional.mjs";
 import { composeAllOf, composeAnyOf, composeNot, composeOneOf, } from "./compose-keyword.mjs";
-import { declareAdditionalPropertiesSchema, declareDependencies, declareObjectRules, declarePatternProperties, declarePropertyNames, readPropertyChildren, } from "./declare-object-keywords.mjs";
+import { declareAdditionalPropertiesSchema } from "./declare-additional-properties.mjs";
+import { declareDependencies, declareObjectRules, declarePatternProperties, declarePropertyNames, readPropertyChildren, } from "./declare-object-keywords.mjs";
 import { declareRequiredProperties } from "./declare-required-properties.mjs";
 import { declareFormatRules, declareNumberRules, declareStringRules, } from "./declare-scalar-keywords.mjs";
 import { declareConstRules, declareEnumRules, declareIntegerRules, declareTypeRules, } from "./declare-value-keywords.mjs";

package/dist/json-schema/structural-expansion.types.d.ts

@@ -3,6 +3,7 @@ import type { CompositeBranch, Rule } from "../plugin-kit/compiled-rule";
 import type { RuleBuildContext } from "../plugin-kit/rule-build-context";
 import type { MessageContextExtra } from "../types";
 import type { Draft07Schema, Draft07SchemaObject } from "./draft07.types";
+import type { RefScope } from "./ref-scope";
 import type { JsonSchemaBag } from "./json-schema-bag.types";
 /**
  * The nineteen keywords `draft07KeywordMap` marks `structural`. Written out by
@@ -31,7 +32,13 @@ export interface ChildSchema {
 export interface StructuralContext {
     readonly bag: JsonSchemaBag;
     readonly build: ChainBuildContext;
-    readonly root: Draft07Schema;
+    /**
+     * WHERE this node is being read from. It replaces the bare `root` this
+     * interface used to carry: a `$ref` is a URI reference, so resolving one
+     * needs the base URI in force and the index of what a URI can name, and a
+     * root cannot express either. See ref-scope.ts.
+     */
+    readonly scope: RefScope;
     /**
      * The `$ref` pointers already entered on this branch of the conversion. A
      * repeat is a RECURSIVE definition, whose expansion does not terminate, so

package/dist/json-schema/uri-reference.d.ts

@@ -0,0 +1,29 @@
+/** A URI with its fragment split off. `resource` is what identifies a document. */
+export interface SplitUri {
+    readonly resource: string;
+    /** Without the leading "#". Empty when the URI carries no fragment. */
+    readonly fragment: string;
+}
+export declare function splitUri(uri: string): SplitUri;
+/**
+ * `reference` resolved against `base`, both as written in the document.
+ *
+ * A base that is not itself absolute cannot resolve anything — that is the
+ * document that declared no `$id`, and it is the common case — so the
+ * reference is returned unchanged rather than guessed at. Callers then look
+ * the reference up verbatim, which is exactly what a local `#/...` pointer
+ * needs.
+ */
+export declare function resolveUriReference(base: string, reference: string): string;
+/** The same normalisation resolution applies, for a URI used as a KEY. */
+export declare function normalizeUri(uri: string): string;
+/**
+ * The base URI in force inside a node that declares `$id`.
+ *
+ * `$id: "#name"` is an ANCHOR, not a base: §8.2.3 gives it a plain-name
+ * fragment, and the base stays whatever it was. Treating it as a base would
+ * silently move every `$ref` written next to it.
+ */
+export declare function nextBaseUri(base: string, id: string | undefined): string;
+/** The anchor `$id` declares, if it declares one: `"#name"` -> `"name"`. */
+export declare function readAnchor(id: string | undefined): string | undefined;

package/dist/json-schema/uri-reference.js

@@ -0,0 +1,118 @@
+"use strict";
+// ===========================================================================
+// L8  src/json-schema/uri-reference.ts — `$id` と `$ref` の URI 演算。
+//
+// Draft-07 §8.2 の `$id` はベース URI を立て、`$ref` はその上で解決される。
+// つまり `$ref` は「文書内のポインタ」ではなく **URI 参照** であり、
+// 同じ文字列でも、どの `$id` の下に書かれたかで別の場所を指す。
+//
+// 解決は WHATWG URL に任せる。RFC 3986 §5.3 を手で書き直しても、
+// パーセント符号化・ドットセグメント・スキーム相対 (`//host/x`) の三つで
+// 必ずずれる — そして URL はブラウザにも Node にもある標準グローバルで、
+// eval も new Function も使わない (check:no-dynamic-code が見ている)。
+//
+// ネットワークには**触れない**。ここにあるのは文字列演算だけで、
+// 解決した URI をどう手に入れるかは呼び出し側の責任である
+// (schema-registry.ts の externalDocuments)。スキーマが書いた URI で
+// このプロセスがソケットを開くことは無い。
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitUri = splitUri;
+exports.resolveUriReference = resolveUriReference;
+exports.normalizeUri = normalizeUri;
+exports.nextBaseUri = nextBaseUri;
+exports.readAnchor = readAnchor;
+function splitUri(uri) {
+    const hash = uri.indexOf("#");
+    if (hash < 0)
+        return { resource: uri, fragment: "" };
+    return { resource: uri.slice(0, hash), fragment: uri.slice(hash + 1) };
+}
+// RFC 3986 §3.1: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) ":".
+// Scanned by code point rather than matched by a regex, because
+// test/unit/json-schema/core/format-map.test.ts forbids a character class
+// anywhere in this layer — 1.x grew a second and a third format table that
+// way, and the rule that prevents it is worth more than the two lines it costs.
+const COLON = 58;
+const PLUS = 43;
+const HYPHEN = 45;
+const DOT = 46;
+function isLetter(code) {
+    return (code > 64 && code < 91) || (code > 96 && code < 123);
+}
+function isDigit(code) {
+    return code > 47 && code < 58;
+}
+function isSchemeChar(code) {
+    return (isLetter(code) ||
+        isDigit(code) ||
+        code === PLUS ||
+        code === HYPHEN ||
+        code === DOT);
+}
+/** True when the reference names its own scheme, so no base is needed. */
+function isAbsolute(reference) {
+    if (reference.length === 0 || !isLetter(reference.charCodeAt(0))) {
+        return false;
+    }
+    for (let index = 1; index < reference.length; index += 1) {
+        const code = reference.charCodeAt(index);
+        if (code === COLON)
+            return true;
+        if (!isSchemeChar(code))
+            return false;
+    }
+    return false;
+}
+/**
+ * `reference` resolved against `base`, both as written in the document.
+ *
+ * A base that is not itself absolute cannot resolve anything — that is the
+ * document that declared no `$id`, and it is the common case — so the
+ * reference is returned unchanged rather than guessed at. Callers then look
+ * the reference up verbatim, which is exactly what a local `#/...` pointer
+ * needs.
+ */
+function resolveUriReference(base, reference) {
+    if (base === "" || !isAbsolute(base)) {
+        return isAbsolute(reference) ? normalizeUri(reference) : reference;
+    }
+    try {
+        return new URL(reference, base).href;
+    }
+    catch {
+        return reference;
+    }
+}
+/** The same normalisation resolution applies, for a URI used as a KEY. */
+function normalizeUri(uri) {
+    if (!isAbsolute(uri))
+        return uri;
+    try {
+        return new URL(uri).href;
+    }
+    catch {
+        return uri;
+    }
+}
+/**
+ * The base URI in force inside a node that declares `$id`.
+ *
+ * `$id: "#name"` is an ANCHOR, not a base: §8.2.3 gives it a plain-name
+ * fragment, and the base stays whatever it was. Treating it as a base would
+ * silently move every `$ref` written next to it.
+ */
+function nextBaseUri(base, id) {
+    if (id === undefined || id === "" || id.startsWith("#"))
+        return base;
+    return resolveUriReference(base, id);
+}
+/** The anchor `$id` declares, if it declares one: `"#name"` -> `"name"`. */
+function readAnchor(id) {
+    if (id === undefined || !id.startsWith("#") || id.length === 1) {
+        return undefined;
+    }
+    const anchor = id.slice(1);
+    // A pointer fragment is not an anchor; `#/a/b` names a location.
+    return anchor.startsWith("/") ? undefined : anchor;
+}

package/dist/json-schema/uri-reference.mjs

@@ -0,0 +1,111 @@
+// ===========================================================================
+// L8  src/json-schema/uri-reference.ts — `$id` と `$ref` の URI 演算。
+//
+// Draft-07 §8.2 の `$id` はベース URI を立て、`$ref` はその上で解決される。
+// つまり `$ref` は「文書内のポインタ」ではなく **URI 参照** であり、
+// 同じ文字列でも、どの `$id` の下に書かれたかで別の場所を指す。
+//
+// 解決は WHATWG URL に任せる。RFC 3986 §5.3 を手で書き直しても、
+// パーセント符号化・ドットセグメント・スキーム相対 (`//host/x`) の三つで
+// 必ずずれる — そして URL はブラウザにも Node にもある標準グローバルで、
+// eval も new Function も使わない (check:no-dynamic-code が見ている)。
+//
+// ネットワークには**触れない**。ここにあるのは文字列演算だけで、
+// 解決した URI をどう手に入れるかは呼び出し側の責任である
+// (schema-registry.ts の externalDocuments)。スキーマが書いた URI で
+// このプロセスがソケットを開くことは無い。
+// ===========================================================================
+export function splitUri(uri) {
+    const hash = uri.indexOf("#");
+    if (hash < 0)
+        return { resource: uri, fragment: "" };
+    return { resource: uri.slice(0, hash), fragment: uri.slice(hash + 1) };
+}
+// RFC 3986 §3.1: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) ":".
+// Scanned by code point rather than matched by a regex, because
+// test/unit/json-schema/core/format-map.test.ts forbids a character class
+// anywhere in this layer — 1.x grew a second and a third format table that
+// way, and the rule that prevents it is worth more than the two lines it costs.
+const COLON = 58;
+const PLUS = 43;
+const HYPHEN = 45;
+const DOT = 46;
+function isLetter(code) {
+    return (code > 64 && code < 91) || (code > 96 && code < 123);
+}
+function isDigit(code) {
+    return code > 47 && code < 58;
+}
+function isSchemeChar(code) {
+    return (isLetter(code) ||
+        isDigit(code) ||
+        code === PLUS ||
+        code === HYPHEN ||
+        code === DOT);
+}
+/** True when the reference names its own scheme, so no base is needed. */
+function isAbsolute(reference) {
+    if (reference.length === 0 || !isLetter(reference.charCodeAt(0))) {
+        return false;
+    }
+    for (let index = 1; index < reference.length; index += 1) {
+        const code = reference.charCodeAt(index);
+        if (code === COLON)
+            return true;
+        if (!isSchemeChar(code))
+            return false;
+    }
+    return false;
+}
+/**
+ * `reference` resolved against `base`, both as written in the document.
+ *
+ * A base that is not itself absolute cannot resolve anything — that is the
+ * document that declared no `$id`, and it is the common case — so the
+ * reference is returned unchanged rather than guessed at. Callers then look
+ * the reference up verbatim, which is exactly what a local `#/...` pointer
+ * needs.
+ */
+export function resolveUriReference(base, reference) {
+    if (base === "" || !isAbsolute(base)) {
+        return isAbsolute(reference) ? normalizeUri(reference) : reference;
+    }
+    try {
+        return new URL(reference, base).href;
+    }
+    catch {
+        return reference;
+    }
+}
+/** The same normalisation resolution applies, for a URI used as a KEY. */
+export function normalizeUri(uri) {
+    if (!isAbsolute(uri))
+        return uri;
+    try {
+        return new URL(uri).href;
+    }
+    catch {
+        return uri;
+    }
+}
+/**
+ * The base URI in force inside a node that declares `$id`.
+ *
+ * `$id: "#name"` is an ANCHOR, not a base: §8.2.3 gives it a plain-name
+ * fragment, and the base stays whatever it was. Treating it as a base would
+ * silently move every `$ref` written next to it.
+ */
+export function nextBaseUri(base, id) {
+    if (id === undefined || id === "" || id.startsWith("#"))
+        return base;
+    return resolveUriReference(base, id);
+}
+/** The anchor `$id` declares, if it declares one: `"#name"` -> `"name"`. */
+export function readAnchor(id) {
+    if (id === undefined || !id.startsWith("#") || id.length === 1) {
+        return undefined;
+    }
+    const anchor = id.slice(1);
+    // A pointer fragment is not an anchor; `#/a/b` names a location.
+    return anchor.startsWith("/") ? undefined : anchor;
+}

package/dist/path/create-value-writer.js

@@ -35,9 +35,32 @@ function writeInto(container, keys, depth, value) {
  * conjure an array — the declaration grammar cannot express `items[0]`, so a
  * numeric key here is a Record key.
  */
+/**
+ * キーを own プロパティとして置く。**代入演算子を使わない。**
+ *
+ * `copy[key] = value` は key が "__proto__" のとき Object.prototype の
+ * アクセサ (setter) を呼び、own プロパティを作る代わりにプロトタイプを
+ * 差し替えてしまう。defineProperty はアクセサを見ずに own プロパティを
+ * 定義するので、"__proto__" という名前のプロパティを安全に持てる。
+ *
+ * "constructor" と "prototype" は Object.prototype 上でデータプロパティ
+ * なので代入でも own プロパティになるが、キーごとに分岐すると分岐のほうを
+ * 間違えるので一律にこちらを通す。
+ *
+ * これが「宣言パスに __proto__ を書けるようにする」の前提。書き込みが安全に
+ * なったので、パス文法の側で拒否する必要が無くなった (reserved-segment.ts)。
+ */
+function putOwnProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+}
 function vivify(key, written) {
     const created = {};
-    created[key] = written;
+    putOwnProperty(created, key, written);
     return created;
 }
 function copyWith(container, key, value) {
@@ -49,7 +72,9 @@ function copyWith(container, key, value) {
         copy[index] = value;
         return copy;
     }
+    // スプレッドは own の列挙可能プロパティを CreateDataProperty で写すので、
+    // ここでは setter は動かない。危ないのは下の代入だけ。
     const copy = { ...container };
-    copy[key] = value;
+    putOwnProperty(copy, key, value);
     return copy;
 }

package/dist/path/create-value-writer.mjs

@@ -32,9 +32,32 @@ function writeInto(container, keys, depth, value) {
  * conjure an array — the declaration grammar cannot express `items[0]`, so a
  * numeric key here is a Record key.
  */
+/**
+ * キーを own プロパティとして置く。**代入演算子を使わない。**
+ *
+ * `copy[key] = value` は key が "__proto__" のとき Object.prototype の
+ * アクセサ (setter) を呼び、own プロパティを作る代わりにプロトタイプを
+ * 差し替えてしまう。defineProperty はアクセサを見ずに own プロパティを
+ * 定義するので、"__proto__" という名前のプロパティを安全に持てる。
+ *
+ * "constructor" と "prototype" は Object.prototype 上でデータプロパティ
+ * なので代入でも own プロパティになるが、キーごとに分岐すると分岐のほうを
+ * 間違えるので一律にこちらを通す。
+ *
+ * これが「宣言パスに __proto__ を書けるようにする」の前提。書き込みが安全に
+ * なったので、パス文法の側で拒否する必要が無くなった (reserved-segment.ts)。
+ */
+function putOwnProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+}
 function vivify(key, written) {
     const created = {};
-    created[key] = written;
+    putOwnProperty(created, key, written);
     return created;
 }
 function copyWith(container, key, value) {
@@ -46,7 +69,9 @@ function copyWith(container, key, value) {
         copy[index] = value;
         return copy;
     }
+    // スプレッドは own の列挙可能プロパティを CreateDataProperty で写すので、
+    // ここでは setter は動かない。危ないのは下の代入だけ。
     const copy = { ...container };
-    copy[key] = value;
+    putOwnProperty(copy, key, value);
     return copy;
 }

package/dist/path/reserved-segment.d.ts

@@ -1,7 +1,25 @@
-/** Segment names that reach `Object.prototype` and must never be walked,
- *  written, or vivified. `fromJsonSchema` derives segments verbatim from
- *  untrusted schema property names, so this list is a security boundary, not a
- *  style preference. */
+/**
+ * `Object.prototype` 上に同名のものがあるキー。
+ *
+ * **これはもう拒否リストではない。** 以前はこの3つを宣言パスに書けなくして
+ * いたが、その拒否は過剰だった。危険なのは書き込みだけで、しかも本当に危ない
+ * のは "__proto__" ひとつである:
+ *
+ *   読み取り  create-value-reader.ts が hasOwnProperty.call で own プロパティ
+ *             しか読まないので、プロトタイプは最初から辿らない
+ *   書き込み  `target[key] = value` は "__proto__" のとき Object.prototype の
+ *             **アクセサ** を呼び、own プロパティを作らずプロトタイプを差し替える。
+ *             "constructor" と "prototype" はデータプロパティなので代入でも
+ *             own プロパティになるだけで、汚染にはならない
+ *
+ * create-value-writer.ts が代入をやめて defineProperty に移したことで、
+ * この経路が閉じた。したがって名前で拒否する必要が無くなり、
+ * `{ "properties": { "__proto__": ... } }` のようなスキーマを検証できる
+ * ようになった (JSON-Schema-Test-Suite の properties.json が要求している)。
+ *
+ * リスト自体は残す。テストが「この3つを書いても Object.prototype が汚れない」
+ * ことを名指しで確認するのに使う (test/unit/path/create-value-writer.test.ts)。
+ */
 export declare const RESERVED_SEGMENTS: readonly string[];
 /** Thrown at BUILD time for every malformed or unsafe path. A declared rule
  *  must either execute or fail loudly; the legacy silent `return () => null`

package/dist/path/reserved-segment.js

@@ -13,10 +13,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PathSyntaxError = exports.RESERVED_SEGMENTS = void 0;
 exports.isReservedSegment = isReservedSegment;
 exports.assertDeclarableKey = assertDeclarableKey;
-/** Segment names that reach `Object.prototype` and must never be walked,
- *  written, or vivified. `fromJsonSchema` derives segments verbatim from
- *  untrusted schema property names, so this list is a security boundary, not a
- *  style preference. */
+/**
+ * `Object.prototype` 上に同名のものがあるキー。
+ *
+ * **これはもう拒否リストではない。** 以前はこの3つを宣言パスに書けなくして
+ * いたが、その拒否は過剰だった。危険なのは書き込みだけで、しかも本当に危ない
+ * のは "__proto__" ひとつである:
+ *
+ *   読み取り  create-value-reader.ts が hasOwnProperty.call で own プロパティ
+ *             しか読まないので、プロトタイプは最初から辿らない
+ *   書き込み  `target[key] = value` は "__proto__" のとき Object.prototype の
+ *             **アクセサ** を呼び、own プロパティを作らずプロトタイプを差し替える。
+ *             "constructor" と "prototype" はデータプロパティなので代入でも
+ *             own プロパティになるだけで、汚染にはならない
+ *
+ * create-value-writer.ts が代入をやめて defineProperty に移したことで、
+ * この経路が閉じた。したがって名前で拒否する必要が無くなり、
+ * `{ "properties": { "__proto__": ... } }` のようなスキーマを検証できる
+ * ようになった (JSON-Schema-Test-Suite の properties.json が要求している)。
+ *
+ * リスト自体は残す。テストが「この3つを書いても Object.prototype が汚れない」
+ * ことを名指しで確認するのに使う (test/unit/path/create-value-writer.test.ts)。
+ */
 exports.RESERVED_SEGMENTS = Object.freeze([
     "__proto__",
     "constructor",
@@ -62,7 +80,9 @@ function assertDeclarableKey(key, source) {
         throw new PathSyntaxError(source, `the key ${JSON.stringify(key)} contains a bracket; "[*]" is the only ` +
             "bracket form and it must trail a key");
     }
-    if (isReservedSegment(key)) {
-        throw new PathSyntaxError(source, `${JSON.stringify(key)} is a reserved segment (prototype pollution)`);
-    }
+    // 予約セグメントの拒否はここから外した。理由は RESERVED_SEGMENTS の
+    // コメントに書いてある。要約すると、危険なのは書き込みだけで、その書き込みは
+    // create-value-writer.ts が defineProperty に移したので安全になった。
+    // 名前で拒否する必要が無くなり、JSON Schema が "__proto__" というキーを
+    // 持つオブジェクトを検証できるようになった。
 }

package/dist/path/reserved-segment.mjs

@@ -8,10 +8,28 @@
 // Putting the class the other way round would make the two files mutually
 // dependent for no gain.
 // ===========================================================================
-/** Segment names that reach `Object.prototype` and must never be walked,
- *  written, or vivified. `fromJsonSchema` derives segments verbatim from
- *  untrusted schema property names, so this list is a security boundary, not a
- *  style preference. */
+/**
+ * `Object.prototype` 上に同名のものがあるキー。
+ *
+ * **これはもう拒否リストではない。** 以前はこの3つを宣言パスに書けなくして
+ * いたが、その拒否は過剰だった。危険なのは書き込みだけで、しかも本当に危ない
+ * のは "__proto__" ひとつである:
+ *
+ *   読み取り  create-value-reader.ts が hasOwnProperty.call で own プロパティ
+ *             しか読まないので、プロトタイプは最初から辿らない
+ *   書き込み  `target[key] = value` は "__proto__" のとき Object.prototype の
+ *             **アクセサ** を呼び、own プロパティを作らずプロトタイプを差し替える。
+ *             "constructor" と "prototype" はデータプロパティなので代入でも
+ *             own プロパティになるだけで、汚染にはならない
+ *
+ * create-value-writer.ts が代入をやめて defineProperty に移したことで、
+ * この経路が閉じた。したがって名前で拒否する必要が無くなり、
+ * `{ "properties": { "__proto__": ... } }` のようなスキーマを検証できる
+ * ようになった (JSON-Schema-Test-Suite の properties.json が要求している)。
+ *
+ * リスト自体は残す。テストが「この3つを書いても Object.prototype が汚れない」
+ * ことを名指しで確認するのに使う (test/unit/path/create-value-writer.test.ts)。
+ */
 export const RESERVED_SEGMENTS = Object.freeze([
     "__proto__",
     "constructor",
@@ -56,7 +74,9 @@ export function assertDeclarableKey(key, source) {
         throw new PathSyntaxError(source, `the key ${JSON.stringify(key)} contains a bracket; "[*]" is the only ` +
             "bracket form and it must trail a key");
     }
-    if (isReservedSegment(key)) {
-        throw new PathSyntaxError(source, `${JSON.stringify(key)} is a reserved segment (prototype pollution)`);
-    }
+    // 予約セグメントの拒否はここから外した。理由は RESERVED_SEGMENTS の
+    // コメントに書いてある。要約すると、危険なのは書き込みだけで、その書き込みは
+    // create-value-writer.ts が defineProperty に移したので安全になった。
+    // 名前で拒否する必要が無くなり、JSON Schema が "__proto__" というキーを
+    // 持つオブジェクトを検証できるようになった。
 }