@maroonedog/luq 2.1.0 → 2.2.0

package/dist/plugins/string-min/string-min.mjs

@@ -7,7 +7,7 @@
 // ===========================================================================
 import { check } from "../../plugin-kit/create-rule.mjs";
 import { PluginArgumentError, definePlugin, } from "../../plugin-kit/plugin-definition.mjs";
-import { PASS, fail, isNumber, countCodePoints, isString } from "../../types/index.mjs";
+import { PASS, fail, isNumber, isString } from "../../types/index.mjs";
 export const stringMinPlugin = /*#__PURE__*/ definePlugin()({
     name: "stringMin",
     method: "min",
@@ -20,9 +20,27 @@ export const stringMinPlugin = /*#__PURE__*/ definePlugin()({
             code: ctx.code,
             messageFactory: ctx.messageFactory,
             severity: ctx.severity,
-            run: (value) => !isString(value) || countCodePoints(value) >= min
-                ? PASS
-                : fail({ expected: min, actual: countCodePoints(value) }),
+            // min に届いた時点で止める。全長を数える必要があるのは**落ちる**
+            // ときだけで、そのときは値が min より短いのだから走査も短い。
+            // 元は countCodePoints を最大二度呼び、どちらも文字列を最後まで
+            // 歩いていた。符号位置で数えるのは変えない (UTF-16 単位ではない) —
+            // 変えているのは、いつ止めるかだけである。受理パスで 12.7%。
+            run: (value) => {
+                if (!isString(value))
+                    return PASS;
+                // min が 0 なら空文字列も通る。ループは空文字列で一度も回らないので、
+                // この行が無いと `""` が actual 0 で落ちる — 早期脱出に書き換えた
+                // ときに実際に開いた穴で、既存のテストは一件も気づかなかった。
+                if (min === 0)
+                    return PASS;
+                let count = 0;
+                for (const _character of value) {
+                    count += 1;
+                    if (count >= min)
+                        return PASS;
+                }
+                return fail({ expected: min, actual: count });
+            },
             describe: (detail) => `String must have at least ${String(min)} characters, but got ` +
                 `${String(detail.actual)}`,
             buildMessageContext: (detail) => ({

package/dist/presets/index.d.ts

@@ -0,0 +1 @@
+export { arrays, everydayRules, numbers, presence, strings } from "./presets";

package/dist/presets/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strings = exports.presence = exports.numbers = exports.everydayRules = exports.arrays = void 0;
+var presets_1 = require("./presets");
+Object.defineProperty(exports, "arrays", { enumerable: true, get: function () { return presets_1.arrays; } });
+Object.defineProperty(exports, "everydayRules", { enumerable: true, get: function () { return presets_1.everydayRules; } });
+Object.defineProperty(exports, "numbers", { enumerable: true, get: function () { return presets_1.numbers; } });
+Object.defineProperty(exports, "presence", { enumerable: true, get: function () { return presets_1.presence; } });
+Object.defineProperty(exports, "strings", { enumerable: true, get: function () { return presets_1.strings; } });

package/dist/presets/index.mjs

@@ -0,0 +1 @@
+export { arrays, everydayRules, numbers, presence, strings } from "./presets.mjs";

package/dist/presets/presets.d.ts

@@ -0,0 +1,165 @@
+/**
+ * 在る・無い・null。ほぼ全ての宣言がこの三つのどれかを使う。
+ * 使用実績: required 138 / optional 26 / nullable 12。
+ */
+export declare const presence: Readonly<{
+    required: import("..").PluginDefinition<"required", "required", readonly import("..").TypeName[], {
+        args: readonly [];
+        out: import("../plugin-kit").PresenceShift<"excludeMissing">;
+        context: import("..").MessageContextExtra;
+    }>;
+    optional: import("..").PluginDefinition<"optional", "optional", readonly import("..").TypeName[], {
+        args: readonly [];
+        out: import("../plugin-kit").PresenceShift<"excludeNull">;
+        context: import("..").MessageContextExtra;
+    }>;
+    nullable: import("..").PluginDefinition<"nullable", "nullable", readonly import("..").TypeName[], {
+        args: readonly [];
+        out: import("../plugin-kit").PresenceShift<"allowNull">;
+        context: import("..").MessageContextExtra;
+    }>;
+}>;
+/** 文字列の定番。使用実績: stringMin 95 / stringEmail 33 / stringPattern 12。 */
+export declare const strings: Readonly<{
+    stringMin: import("..").PluginDefinition<"stringMin", "min", readonly ["string"], {
+        args: readonly [min: number];
+        out: import("../plugin-kit").Unchanged;
+        context: import("../plugins/string-min/string-min").StringMinContext;
+    }>;
+    stringMax: import("..").PluginDefinition<"stringMax", "max", readonly ["string"], {
+        args: readonly [max: number];
+        out: import("../plugin-kit").Unchanged;
+        context: import("../plugins/string-max/string-max").StringMaxContext;
+    }>;
+    stringPattern: import("..").PluginDefinition<"stringPattern", "pattern", readonly ["string"], {
+        args: readonly [pattern: RegExp];
+        out: import("../plugin-kit").Unchanged;
+        context: {
+            readonly pattern: string;
+        };
+    }>;
+    stringEmail: import("..").PluginDefinition<"stringEmail", "email", readonly ["string"], {
+        args: readonly [options?: import("../plugins/string-email/string-email").EmailFormatOptions];
+        out: import("../plugin-kit").Unchanged;
+        context: {
+            readonly reason: string;
+        };
+    }>;
+}>;
+/** 数値の定番。使用実績: numberMin 43 / numberMax 8。 */
+export declare const numbers: Readonly<{
+    numberMin: import("..").PluginDefinition<"numberMin", "min", readonly ["number"], {
+        args: readonly [min: number, exclusive?: boolean];
+        out: import("../plugin-kit").Unchanged;
+        context: import("../plugins/number-min").NumberMinContext;
+    }>;
+    numberMax: import("..").PluginDefinition<"numberMax", "max", readonly ["number"], {
+        args: readonly [max: number, exclusive?: boolean];
+        out: import("../plugin-kit").Unchanged;
+        context: import("../plugins/number-max").NumberMaxContext;
+    }>;
+    numberInteger: import("..").PluginDefinition<"numberInteger", "integer", readonly ["number"], {
+        args: readonly [];
+        out: import("../plugin-kit").Unchanged;
+        context: import("..").MessageContextExtra;
+    }>;
+}>;
+/** 配列の定番。要素ごとの規則は arrayEach が運ぶ。 */
+export declare const arrays: Readonly<{
+    arrayMinLength: import("..").PluginDefinition<"arrayMinLength", "minLength", readonly ["array", "tuple"], {
+        args: readonly [min: number];
+        out: import("../plugin-kit").Unchanged;
+        context: import("../plugins/array-min-length").ArrayMinLengthContext;
+    }>;
+    arrayMaxLength: import("..").PluginDefinition<"arrayMaxLength", "maxLength", readonly ["array", "tuple"], {
+        args: readonly [max: number];
+        out: import("../plugin-kit").Unchanged;
+        context: import("../plugins/array-max-length").ArrayMaxLengthContext;
+    }>;
+    arrayEach: import("..").PluginDefinition<"arrayEach", "each", readonly ["array", "tuple"], {
+        args: readonly [element: import("../plugin-kit").ElementChain];
+        out: import("../plugin-kit").Unchanged;
+        context: import("..").MessageContextExtra;
+    }>;
+}>;
+/**
+ * 上の四つを合わせたもの。13プラグイン、gzip で +1,452 B。
+ *
+ * 名前が「common」でないのは、それが何も言っていないからである
+ * (lint の禁止語彙にも入っている)。入っているのは presence と、文字列・数値・
+ * 配列それぞれの定番で、毎日書くのはこの範囲だ、という主張がこの名前である。
+ *
+ * これでも「全部入り」ではない。全部入りが要るなら `@maroonedog/luq/plugins`
+ * のバレルがあり、そちらは 77 個ぶん、gzip で +17,986 B を払う。
+ */
+export declare const everydayRules: Readonly<{
+    arrayMinLength: import("..").PluginDefinition<"arrayMinLength", "minLength", readonly ["array", "tuple"], {
+        args: readonly [min: number];
+        out: import("../plugin-kit").Unchanged;
+        context: import("../plugins/array-min-length").ArrayMinLengthContext;
+    }>;
+    arrayMaxLength: import("..").PluginDefinition<"arrayMaxLength", "maxLength", readonly ["array", "tuple"], {
+        args: readonly [max: number];
+        out: import("../plugin-kit").Unchanged;
+        context: import("../plugins/array-max-length").ArrayMaxLengthContext;
+    }>;
+    arrayEach: import("..").PluginDefinition<"arrayEach", "each", readonly ["array", "tuple"], {
+        args: readonly [element: import("../plugin-kit").ElementChain];
+        out: import("../plugin-kit").Unchanged;
+        context: import("..").MessageContextExtra;
+    }>;
+    numberMin: import("..").PluginDefinition<"numberMin", "min", readonly ["number"], {
+        args: readonly [min: number, exclusive?: boolean];
+        out: import("../plugin-kit").Unchanged;
+        context: import("../plugins/number-min").NumberMinContext;
+    }>;
+    numberMax: import("..").PluginDefinition<"numberMax", "max", readonly ["number"], {
+        args: readonly [max: number, exclusive?: boolean];
+        out: import("../plugin-kit").Unchanged;
+        context: import("../plugins/number-max").NumberMaxContext;
+    }>;
+    numberInteger: import("..").PluginDefinition<"numberInteger", "integer", readonly ["number"], {
+        args: readonly [];
+        out: import("../plugin-kit").Unchanged;
+        context: import("..").MessageContextExtra;
+    }>;
+    stringMin: import("..").PluginDefinition<"stringMin", "min", readonly ["string"], {
+        args: readonly [min: number];
+        out: import("../plugin-kit").Unchanged;
+        context: import("../plugins/string-min/string-min").StringMinContext;
+    }>;
+    stringMax: import("..").PluginDefinition<"stringMax", "max", readonly ["string"], {
+        args: readonly [max: number];
+        out: import("../plugin-kit").Unchanged;
+        context: import("../plugins/string-max/string-max").StringMaxContext;
+    }>;
+    stringPattern: import("..").PluginDefinition<"stringPattern", "pattern", readonly ["string"], {
+        args: readonly [pattern: RegExp];
+        out: import("../plugin-kit").Unchanged;
+        context: {
+            readonly pattern: string;
+        };
+    }>;
+    stringEmail: import("..").PluginDefinition<"stringEmail", "email", readonly ["string"], {
+        args: readonly [options?: import("../plugins/string-email/string-email").EmailFormatOptions];
+        out: import("../plugin-kit").Unchanged;
+        context: {
+            readonly reason: string;
+        };
+    }>;
+    required: import("..").PluginDefinition<"required", "required", readonly import("..").TypeName[], {
+        args: readonly [];
+        out: import("../plugin-kit").PresenceShift<"excludeMissing">;
+        context: import("..").MessageContextExtra;
+    }>;
+    optional: import("..").PluginDefinition<"optional", "optional", readonly import("..").TypeName[], {
+        args: readonly [];
+        out: import("../plugin-kit").PresenceShift<"excludeNull">;
+        context: import("..").MessageContextExtra;
+    }>;
+    nullable: import("..").PluginDefinition<"nullable", "nullable", readonly import("..").TypeName[], {
+        args: readonly [];
+        out: import("../plugin-kit").PresenceShift<"allowNull">;
+        context: import("..").MessageContextExtra;
+    }>;
+}>;

package/dist/presets/presets.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.everydayRules = exports.arrays = exports.numbers = exports.strings = exports.presence = void 0;
+// ===========================================================================
+// L7  src/presets/presets.ts — 事前定義したプラグイン束。
+//
+// なぜ要るのか。プラグインを1つずつ import するのは「使った分しか入らない」
+// を成り立たせている仕組みそのものだが、最初の一本を書くのに15行の use() を
+// 並べさせるのは、その正しさの押し付けである。
+//
+// なぜ「小さいのを複数」なのか。全部入りを1つ置くと、5個しか要らない人が
+// 40個分のバイトを払う。束は型としてはただの `PluginBag` なので、必要な束
+// だけを `useAll()` すればよく、混ぜても first-wins で衝突しない:
+//
+//     Builder().useAll(presence).useAll(strings).for<User>()
+//
+// 何を入れるかはリポジトリ内の使用実績から決めた (test/ と docs-site/ の
+// use() を数えたもの)。required 138 / stringMin 95 / numberMin 43 /
+// stringEmail 33 / optional 26 という並びで、上位が束の中身になっている。
+//
+// バイト数は config/size-budget.json が測る。プリセットは便利さと引き換えに
+// バイトを払うものなので、いくら払うかは書いてあるべきである。
+// ===========================================================================
+const required_1 = require("../plugins/required");
+const optional_1 = require("../plugins/optional");
+const nullable_1 = require("../plugins/nullable");
+const string_min_1 = require("../plugins/string-min");
+const string_max_1 = require("../plugins/string-max");
+const string_pattern_1 = require("../plugins/string-pattern");
+const string_email_1 = require("../plugins/string-email");
+const number_min_1 = require("../plugins/number-min");
+const number_max_1 = require("../plugins/number-max");
+const number_integer_1 = require("../plugins/number-integer");
+const array_min_length_1 = require("../plugins/array-min-length");
+const array_max_length_1 = require("../plugins/array-max-length");
+const array_each_1 = require("../plugins/array-each");
+/**
+ * 在る・無い・null。ほぼ全ての宣言がこの三つのどれかを使う。
+ * 使用実績: required 138 / optional 26 / nullable 12。
+ */
+exports.presence = Object.freeze({
+    required: required_1.requiredPlugin,
+    optional: optional_1.optionalPlugin,
+    nullable: nullable_1.nullablePlugin,
+});
+/** 文字列の定番。使用実績: stringMin 95 / stringEmail 33 / stringPattern 12。 */
+exports.strings = Object.freeze({
+    stringMin: string_min_1.stringMinPlugin,
+    stringMax: string_max_1.stringMaxPlugin,
+    stringPattern: string_pattern_1.stringPatternPlugin,
+    stringEmail: string_email_1.stringEmailPlugin,
+});
+/** 数値の定番。使用実績: numberMin 43 / numberMax 8。 */
+exports.numbers = Object.freeze({
+    numberMin: number_min_1.numberMinPlugin,
+    numberMax: number_max_1.numberMaxPlugin,
+    numberInteger: number_integer_1.numberIntegerPlugin,
+});
+/** 配列の定番。要素ごとの規則は arrayEach が運ぶ。 */
+exports.arrays = Object.freeze({
+    arrayMinLength: array_min_length_1.arrayMinLengthPlugin,
+    arrayMaxLength: array_max_length_1.arrayMaxLengthPlugin,
+    arrayEach: array_each_1.arrayEachPlugin,
+});
+/**
+ * 上の四つを合わせたもの。13プラグイン、gzip で +1,452 B。
+ *
+ * 名前が「common」でないのは、それが何も言っていないからである
+ * (lint の禁止語彙にも入っている)。入っているのは presence と、文字列・数値・
+ * 配列それぞれの定番で、毎日書くのはこの範囲だ、という主張がこの名前である。
+ *
+ * これでも「全部入り」ではない。全部入りが要るなら `@maroonedog/luq/plugins`
+ * のバレルがあり、そちらは 77 個ぶん、gzip で +17,986 B を払う。
+ */
+exports.everydayRules = Object.freeze({
+    ...exports.presence,
+    ...exports.strings,
+    ...exports.numbers,
+    ...exports.arrays,
+});

package/dist/presets/presets.mjs

@@ -0,0 +1,77 @@
+// ===========================================================================
+// L7  src/presets/presets.ts — 事前定義したプラグイン束。
+//
+// なぜ要るのか。プラグインを1つずつ import するのは「使った分しか入らない」
+// を成り立たせている仕組みそのものだが、最初の一本を書くのに15行の use() を
+// 並べさせるのは、その正しさの押し付けである。
+//
+// なぜ「小さいのを複数」なのか。全部入りを1つ置くと、5個しか要らない人が
+// 40個分のバイトを払う。束は型としてはただの `PluginBag` なので、必要な束
+// だけを `useAll()` すればよく、混ぜても first-wins で衝突しない:
+//
+//     Builder().useAll(presence).useAll(strings).for<User>()
+//
+// 何を入れるかはリポジトリ内の使用実績から決めた (test/ と docs-site/ の
+// use() を数えたもの)。required 138 / stringMin 95 / numberMin 43 /
+// stringEmail 33 / optional 26 という並びで、上位が束の中身になっている。
+//
+// バイト数は config/size-budget.json が測る。プリセットは便利さと引き換えに
+// バイトを払うものなので、いくら払うかは書いてあるべきである。
+// ===========================================================================
+import { requiredPlugin } from "../plugins/required/index.mjs";
+import { optionalPlugin } from "../plugins/optional/index.mjs";
+import { nullablePlugin } from "../plugins/nullable/index.mjs";
+import { stringMinPlugin } from "../plugins/string-min/index.mjs";
+import { stringMaxPlugin } from "../plugins/string-max/index.mjs";
+import { stringPatternPlugin } from "../plugins/string-pattern/index.mjs";
+import { stringEmailPlugin } from "../plugins/string-email/index.mjs";
+import { numberMinPlugin } from "../plugins/number-min/index.mjs";
+import { numberMaxPlugin } from "../plugins/number-max/index.mjs";
+import { numberIntegerPlugin } from "../plugins/number-integer/index.mjs";
+import { arrayMinLengthPlugin } from "../plugins/array-min-length/index.mjs";
+import { arrayMaxLengthPlugin } from "../plugins/array-max-length/index.mjs";
+import { arrayEachPlugin } from "../plugins/array-each/index.mjs";
+/**
+ * 在る・無い・null。ほぼ全ての宣言がこの三つのどれかを使う。
+ * 使用実績: required 138 / optional 26 / nullable 12。
+ */
+export const presence = Object.freeze({
+    required: requiredPlugin,
+    optional: optionalPlugin,
+    nullable: nullablePlugin,
+});
+/** 文字列の定番。使用実績: stringMin 95 / stringEmail 33 / stringPattern 12。 */
+export const strings = Object.freeze({
+    stringMin: stringMinPlugin,
+    stringMax: stringMaxPlugin,
+    stringPattern: stringPatternPlugin,
+    stringEmail: stringEmailPlugin,
+});
+/** 数値の定番。使用実績: numberMin 43 / numberMax 8。 */
+export const numbers = Object.freeze({
+    numberMin: numberMinPlugin,
+    numberMax: numberMaxPlugin,
+    numberInteger: numberIntegerPlugin,
+});
+/** 配列の定番。要素ごとの規則は arrayEach が運ぶ。 */
+export const arrays = Object.freeze({
+    arrayMinLength: arrayMinLengthPlugin,
+    arrayMaxLength: arrayMaxLengthPlugin,
+    arrayEach: arrayEachPlugin,
+});
+/**
+ * 上の四つを合わせたもの。13プラグイン、gzip で +1,452 B。
+ *
+ * 名前が「common」でないのは、それが何も言っていないからである
+ * (lint の禁止語彙にも入っている)。入っているのは presence と、文字列・数値・
+ * 配列それぞれの定番で、毎日書くのはこの範囲だ、という主張がこの名前である。
+ *
+ * これでも「全部入り」ではない。全部入りが要るなら `@maroonedog/luq/plugins`
+ * のバレルがあり、そちらは 77 個ぶん、gzip で +17,986 B を払う。
+ */
+export const everydayRules = Object.freeze({
+    ...presence,
+    ...strings,
+    ...numbers,
+    ...arrays,
+});

package/dist/runtime/create-field-validator.js

@@ -56,15 +56,31 @@ function createSubjectComposer(template) {
         const write = (0, create_value_writer_1.createValueWriter)(template);
         return (siblings, value) => write(siblings ?? {}, value);
     }
-    return (siblings, value) => mergeOntoSiblings(siblings, nestValue(template, 0, value));
+    const nest = compileNester(template);
+    return (siblings, value) => mergeOntoSiblings(siblings, nest(value));
 }
-function nestValue(template, from, value) {
-    const segment = template[from];
-    if (segment === undefined)
-        return value;
-    if (segment.kind === "each")
-        return [nestValue(template, from + 1, value)];
-    return { [segment.key]: nestValue(template, from + 1, value) };
+/**
+ * テンプレートを **一度だけ** 歩いて、包む関数に畳んでおく。
+ *
+ * 以前はここが `nestValue(template, 0, value)` で、検証のたびにテンプレートを
+ * 歩き直して `segment.kind` を読み直していた。src/compile/validation-plan.types.ts
+ * が書いているとおり「実行時はルールが何であるかを決め直してはならない。
+ * 決めるのはコンパイルが済ませたこと」であり、ここはその例外になっていた。
+ * 非ワイルドカードの経路 (createValueWriter) は最初からこの形である。
+ */
+function compileNester(template) {
+    let nest = (value) => value;
+    for (let index = template.length - 1; index >= 0; index -= 1) {
+        const segment = template[index];
+        if (segment === undefined)
+            continue;
+        const inner = nest;
+        nest =
+            segment.kind === "each"
+                ? (value) => [inner(value)]
+                : ((key) => (value) => ({ [key]: inner(value) }))(segment.key);
+    }
+    return nest;
 }
 /** The wrapper wins on the key it names; every other sibling survives. */
 function mergeOntoSiblings(siblings, fragment) {

package/dist/runtime/create-field-validator.mjs

@@ -53,15 +53,31 @@ function createSubjectComposer(template) {
         const write = createValueWriter(template);
         return (siblings, value) => write(siblings ?? {}, value);
     }
-    return (siblings, value) => mergeOntoSiblings(siblings, nestValue(template, 0, value));
+    const nest = compileNester(template);
+    return (siblings, value) => mergeOntoSiblings(siblings, nest(value));
 }
-function nestValue(template, from, value) {
-    const segment = template[from];
-    if (segment === undefined)
-        return value;
-    if (segment.kind === "each")
-        return [nestValue(template, from + 1, value)];
-    return { [segment.key]: nestValue(template, from + 1, value) };
+/**
+ * テンプレートを **一度だけ** 歩いて、包む関数に畳んでおく。
+ *
+ * 以前はここが `nestValue(template, 0, value)` で、検証のたびにテンプレートを
+ * 歩き直して `segment.kind` を読み直していた。src/compile/validation-plan.types.ts
+ * が書いているとおり「実行時はルールが何であるかを決め直してはならない。
+ * 決めるのはコンパイルが済ませたこと」であり、ここはその例外になっていた。
+ * 非ワイルドカードの経路 (createValueWriter) は最初からこの形である。
+ */
+function compileNester(template) {
+    let nest = (value) => value;
+    for (let index = template.length - 1; index >= 0; index -= 1) {
+        const segment = template[index];
+        if (segment === undefined)
+            continue;
+        const inner = nest;
+        nest =
+            segment.kind === "each"
+                ? (value) => [inner(value)]
+                : ((key) => (value) => ({ [key]: inner(value) }))(segment.key);
+    }
+    return nest;
 }
 /** The wrapper wins on the key it names; every other sibling survives. */
 function mergeOntoSiblings(siblings, fragment) {

package/dist/runtime/create-validator.js

@@ -39,7 +39,34 @@ function rejectMissingRoot() {
 function hasRejectingIssue(issues) {
     return issues.some((issue) => issue.severity === "error");
 }
-function runRoot(plan, value, options, targets, shouldApplyTransforms) {
+/**
+ * 再帰しないプランのための、共有の何もしないランナー。
+ *
+ * createRecursionRunner は WeakSet と四つのクロージャを作る。プランに
+ * 再帰規則が一つも無くても validate() のたびに作っていて、それが固定コストの
+ * 88% を占めていた — 計測で 9.7%。プランが再帰を含むかは build() 時に
+ * 分かることで、実行時に問い直すことではない。
+ *
+ * 呼ばれることはない。呼ばれるのは field.recursion が null でない場合だけで、
+ * そのときは planCanRecurse が true を返しているので本物が渡っている。
+ */
+const NO_RECURSION = () => { };
+/**
+ * ルートのランナーが要るか。
+ *
+ * 見るのはルートの直下と配列ノードの要素だけでよい。合成 (oneOf など) の
+ * 枝は run-branch が自前のランナーを作って入れ子のプランを回すので、
+ * ここで渡すものを使わない。
+ */
+function planCanRecurse(plan) {
+    return (plan.fields.some((field) => field.recursion !== null) ||
+        plan.arrays.some(nodeCanRecurse));
+}
+function nodeCanRecurse(node) {
+    return (node.elementFields.some((field) => field.recursion !== null) ||
+        node.nested.some(nodeCanRecurse));
+}
+function runRoot(plan, value, options, targets, shouldApplyTransforms, canRecurse) {
     if (value === null || value === undefined)
         return rejectMissingRoot();
     const sink = new issue_sink_1.IssueSink((0, issue_sink_1.resolveAbortPolicy)(options));
@@ -48,11 +75,13 @@ function runRoot(plan, value, options, targets, shouldApplyTransforms) {
         sink,
         indices: new index_stack_1.IndexStack(),
         shouldApplyTransforms,
-        runRecursion: (0, run_recursion_1.createRecursionRunner)({
-            root: value,
-            sink,
-            external: options?.external,
-        }),
+        runRecursion: canRecurse
+            ? (0, run_recursion_1.createRecursionRunner)({
+                root: value,
+                sink,
+                external: options?.external,
+            })
+            : NO_RECURSION,
         external: options?.external,
     }, targets);
     const issues = Object.freeze(sink.issues);
@@ -63,8 +92,9 @@ function runRoot(plan, value, options, targets, shouldApplyTransforms) {
 function createValidator(plan) {
     const parseTargets = (0, output_writer_1.createPlanWriteTargets)(plan);
     const shouldWriteOutput = parseTargets !== null;
+    const canRecurse = planCanRecurse(plan);
     return {
-        validate: (value, options) => runRoot(plan, value, options, output_writer_1.NO_WRITE_TARGETS, false),
-        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? output_writer_1.NO_WRITE_TARGETS, shouldWriteOutput),
+        validate: (value, options) => runRoot(plan, value, options, output_writer_1.NO_WRITE_TARGETS, false, canRecurse),
+        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? output_writer_1.NO_WRITE_TARGETS, shouldWriteOutput, canRecurse),
     };
 }

package/dist/runtime/create-validator.mjs

@@ -34,7 +34,34 @@ function rejectMissingRoot() {
 export function hasRejectingIssue(issues) {
     return issues.some((issue) => issue.severity === "error");
 }
-function runRoot(plan, value, options, targets, shouldApplyTransforms) {
+/**
+ * 再帰しないプランのための、共有の何もしないランナー。
+ *
+ * createRecursionRunner は WeakSet と四つのクロージャを作る。プランに
+ * 再帰規則が一つも無くても validate() のたびに作っていて、それが固定コストの
+ * 88% を占めていた — 計測で 9.7%。プランが再帰を含むかは build() 時に
+ * 分かることで、実行時に問い直すことではない。
+ *
+ * 呼ばれることはない。呼ばれるのは field.recursion が null でない場合だけで、
+ * そのときは planCanRecurse が true を返しているので本物が渡っている。
+ */
+const NO_RECURSION = () => { };
+/**
+ * ルートのランナーが要るか。
+ *
+ * 見るのはルートの直下と配列ノードの要素だけでよい。合成 (oneOf など) の
+ * 枝は run-branch が自前のランナーを作って入れ子のプランを回すので、
+ * ここで渡すものを使わない。
+ */
+function planCanRecurse(plan) {
+    return (plan.fields.some((field) => field.recursion !== null) ||
+        plan.arrays.some(nodeCanRecurse));
+}
+function nodeCanRecurse(node) {
+    return (node.elementFields.some((field) => field.recursion !== null) ||
+        node.nested.some(nodeCanRecurse));
+}
+function runRoot(plan, value, options, targets, shouldApplyTransforms, canRecurse) {
     if (value === null || value === undefined)
         return rejectMissingRoot();
     const sink = new IssueSink(resolveAbortPolicy(options));
@@ -43,11 +70,13 @@ function runRoot(plan, value, options, targets, shouldApplyTransforms) {
         sink,
         indices: new IndexStack(),
         shouldApplyTransforms,
-        runRecursion: createRecursionRunner({
-            root: value,
-            sink,
-            external: options?.external,
-        }),
+        runRecursion: canRecurse
+            ? createRecursionRunner({
+                root: value,
+                sink,
+                external: options?.external,
+            })
+            : NO_RECURSION,
         external: options?.external,
     }, targets);
     const issues = Object.freeze(sink.issues);
@@ -58,8 +87,9 @@ function runRoot(plan, value, options, targets, shouldApplyTransforms) {
 export function createValidator(plan) {
     const parseTargets = createPlanWriteTargets(plan);
     const shouldWriteOutput = parseTargets !== null;
+    const canRecurse = planCanRecurse(plan);
     return {
-        validate: (value, options) => runRoot(plan, value, options, NO_WRITE_TARGETS, false),
-        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? NO_WRITE_TARGETS, shouldWriteOutput),
+        validate: (value, options) => runRoot(plan, value, options, NO_WRITE_TARGETS, false, canRecurse),
+        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? NO_WRITE_TARGETS, shouldWriteOutput, canRecurse),
     };
 }

package/dist/runtime/field-rule-context.d.ts

@@ -0,0 +1,32 @@
+import type { ArrayItemContext, RuleContext } from "../types";
+import type { IndexStack } from "./index-stack";
+export declare class FieldRuleContext implements RuleContext {
+    readonly root: unknown;
+    private readonly indices;
+    /** Built at compile time, relative to the subject this field reads from. */
+    private readonly ownPath;
+    readonly item: ArrayItemContext | undefined;
+    readonly external: Readonly<Record<string, unknown>> | undefined;
+    /**
+     * The path once something has asked for it. `null` rather than `""` because
+     * the empty string is a real path — the root.
+     *
+     * It is remembered because the index stack underneath is MUTABLE and is
+     * popped when the element ends. A rule that kept its context and read `path`
+     * afterwards would otherwise see wherever the runner had moved on to.
+     * Reading it during the rule's own call — which is what every rule does —
+     * pins it.
+     */
+    private rendered;
+    constructor(root: unknown, indices: IndexStack, 
+    /** Built at compile time, relative to the subject this field reads from. */
+    ownPath: string, item: ArrayItemContext | undefined, external: Readonly<Record<string, unknown>> | undefined);
+    get path(): string;
+    /**
+     * Serialising a context is a thing people do when they log a failure, and a
+     * prototype getter would silently drop `path` from the output. This pins the
+     * JSON shape to the four DECLARED members and, as a side effect, stops the
+     * internals above from reaching a log line.
+     */
+    toJSON(): Record<string, unknown>;
+}