@maroonedog/luq 2.1.0 → 2.3.0

package/dist/plugins/stitch-with/index.mjs

@@ -0,0 +1 @@
+export { stitchWithPlugin } from "./stitch-with.mjs";

package/dist/plugins/stitch-with/stitch-with.d.ts

@@ -0,0 +1,12 @@
+import type { MessageContextExtra } from "../../types";
+import type { BundleOut, NarrowedChain } from "../../plugin-kit/marker.types";
+/** Alias to a path from the root. At run time, a table of strings. */
+export type BundleAliasMap = Readonly<Record<string, string>>;
+export interface StitchWithExtra extends MessageContextExtra {
+    readonly aliases: readonly string[];
+}
+export declare const stitchWithPlugin: import("../../plugin-kit/plugin-definition").PluginDefinition<"stitchWith", "stitchWith", readonly ["string", "number", "boolean", "date", "object", "array", "tuple", "union"], {
+    args: readonly [fields: BundleAliasMap, define: NarrowedChain];
+    out: BundleOut;
+    context: StitchWithExtra;
+}>;

package/dist/plugins/stitch-with/stitch-with.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stitchWithPlugin = void 0;
+// ===========================================================================
+// L7  src/plugins/stitch-with/stitch-with.ts — EXPERIMENTAL.
+// The typed successor to `stitch`, for cross-field validation.
+//
+// The point of stitching is to bring SEVERAL FIELDS INTO ONE JUDGEMENT, so
+// the subject is the bundle itself and not each alias. Listing rules per alias
+// is writable but cannot express `total === price * quantity`, at which point
+// it is no longer stitching.
+//
+// One difference from `stitch`. There the bundle reaches the predicate as
+// `Readonly<Record<string, unknown>>`, so the type says nothing about its
+// contents. Here the bundle is assembled from a mapping and IS TYPED:
+//
+//     .v("total", (b) => b.number.stitchWith(
+//       { cost: "price", count: "quantity" },
+//       (f) => f.object.custom((bundle) => bundle.cost * bundle.count === 100)
+//     ))
+//
+// `bundle` is `{ cost: number; count: number }`, not a Record. Misspell a
+// member or mistake its type and it fails to compile.
+//
+// Why aliases rather than paths as keys. A path string used as a bundle key is
+// interpreted AS A PATH where it is declared, so `"user.name"` goes looking
+// for `user.name` inside the bundle and never finds it, the bundle being
+// flat. An alias is a bare identifier, so that collision cannot happen and the
+// only things referable are the aliases actually declared.
+//
+// No judgement happens in this file. The sub-chain resolves to
+// `readonly Rule[]` through the same route a narrowed chain takes, and the
+// engine runs it. A bundle-specific collector in the core was built and
+// measured; it added bytes to everyone who never stitches, so this rides the
+// existing route instead and adds none.
+// ===========================================================================
+const types_1 = require("../../types");
+const create_rule_1 = require("../../plugin-kit/create-rule");
+const plugin_definition_1 = require("../../plugin-kit/plugin-definition");
+const index_1 = require("../../path/index");
+const STITCH_WITH_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "object",
+    "array",
+    "tuple",
+    "union",
+];
+const BUNDLE_BRANCH_LABEL = "bundle";
+function readMembers(aliasMap) {
+    return Object.freeze(Object.entries(aliasMap).map(([alias, path]) => ({
+        alias,
+        read: (0, index_1.createValueReader)((0, index_1.parseFieldPath)(path)),
+    })));
+}
+/** Assembles the bundle from the root; this object is the branch's subject. */
+function collectBundle(members, root) {
+    const bundle = {};
+    for (const member of members)
+        bundle[member.alias] = member.read(root);
+    return bundle;
+}
+exports.stitchWithPlugin = (0, plugin_definition_1.definePlugin)()({
+    name: "stitchWith",
+    method: "stitchWith",
+    slots: STITCH_WITH_SLOTS,
+    build: (ctx, aliasMap, rules) => {
+        const members = readMembers((0, types_1.isPlainObject)(aliasMap) ? aliasMap : {});
+        const aliases = Object.freeze(members.map((member) => member.alias));
+        return (0, create_rule_1.composite)({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            branches: [(0, create_rule_1.branch)(BUNDLE_BRANCH_LABEL, rules)],
+            // The field's own value is not read. Only the assembled bundle is.
+            combine: (runners) => {
+                const runner = runners[0];
+                if (runner === undefined)
+                    return () => types_1.PASS;
+                return (_value, runCtx) => {
+                    const outcome = runner.run(collectBundle(members, runCtx.root), runCtx);
+                    return outcome.ok ? types_1.PASS : (0, types_1.fail)({ ...outcome.detail });
+                };
+            },
+            describe: (_detail, msgCtx) => `Cross-field validation failed for ${msgCtx.path}`,
+            buildMessageContext: () => ({ aliases }),
+        });
+    },
+    subChainArguments: [1],
+});

package/dist/plugins/stitch-with/stitch-with.mjs

@@ -0,0 +1,89 @@
+// ===========================================================================
+// L7  src/plugins/stitch-with/stitch-with.ts — EXPERIMENTAL.
+// The typed successor to `stitch`, for cross-field validation.
+//
+// The point of stitching is to bring SEVERAL FIELDS INTO ONE JUDGEMENT, so
+// the subject is the bundle itself and not each alias. Listing rules per alias
+// is writable but cannot express `total === price * quantity`, at which point
+// it is no longer stitching.
+//
+// One difference from `stitch`. There the bundle reaches the predicate as
+// `Readonly<Record<string, unknown>>`, so the type says nothing about its
+// contents. Here the bundle is assembled from a mapping and IS TYPED:
+//
+//     .v("total", (b) => b.number.stitchWith(
+//       { cost: "price", count: "quantity" },
+//       (f) => f.object.custom((bundle) => bundle.cost * bundle.count === 100)
+//     ))
+//
+// `bundle` is `{ cost: number; count: number }`, not a Record. Misspell a
+// member or mistake its type and it fails to compile.
+//
+// Why aliases rather than paths as keys. A path string used as a bundle key is
+// interpreted AS A PATH where it is declared, so `"user.name"` goes looking
+// for `user.name` inside the bundle and never finds it, the bundle being
+// flat. An alias is a bare identifier, so that collision cannot happen and the
+// only things referable are the aliases actually declared.
+//
+// No judgement happens in this file. The sub-chain resolves to
+// `readonly Rule[]` through the same route a narrowed chain takes, and the
+// engine runs it. A bundle-specific collector in the core was built and
+// measured; it added bytes to everyone who never stitches, so this rides the
+// existing route instead and adds none.
+// ===========================================================================
+import { PASS, fail, isPlainObject } from "../../types/index.mjs";
+import { branch, composite } from "../../plugin-kit/create-rule.mjs";
+import { definePlugin } from "../../plugin-kit/plugin-definition.mjs";
+import { createValueReader, parseFieldPath } from "../../path/index.mjs";
+const STITCH_WITH_SLOTS = [
+    "string",
+    "number",
+    "boolean",
+    "date",
+    "object",
+    "array",
+    "tuple",
+    "union",
+];
+const BUNDLE_BRANCH_LABEL = "bundle";
+function readMembers(aliasMap) {
+    return Object.freeze(Object.entries(aliasMap).map(([alias, path]) => ({
+        alias,
+        read: createValueReader(parseFieldPath(path)),
+    })));
+}
+/** Assembles the bundle from the root; this object is the branch's subject. */
+function collectBundle(members, root) {
+    const bundle = {};
+    for (const member of members)
+        bundle[member.alias] = member.read(root);
+    return bundle;
+}
+export const stitchWithPlugin = /*#__PURE__*/ definePlugin()({
+    name: "stitchWith",
+    method: "stitchWith",
+    slots: STITCH_WITH_SLOTS,
+    build: (ctx, aliasMap, rules) => {
+        const members = readMembers(isPlainObject(aliasMap) ? aliasMap : {});
+        const aliases = Object.freeze(members.map((member) => member.alias));
+        return composite({
+            code: ctx.code,
+            messageFactory: ctx.messageFactory,
+            severity: ctx.severity,
+            branches: [branch(BUNDLE_BRANCH_LABEL, rules)],
+            // The field's own value is not read. Only the assembled bundle is.
+            combine: (runners) => {
+                const runner = runners[0];
+                if (runner === undefined)
+                    return () => PASS;
+                return (_value, runCtx) => {
+                    const outcome = runner.run(collectBundle(members, runCtx.root), runCtx);
+                    return outcome.ok ? PASS : fail({ ...outcome.detail });
+                };
+            },
+            describe: (_detail, msgCtx) => `Cross-field validation failed for ${msgCtx.path}`,
+            buildMessageContext: () => ({ aliases }),
+        });
+    },
+    subChainArguments: [1],
+});

package/dist/plugins/stitchWith.d.ts

@@ -0,0 +1 @@
+export * from "./stitch-with/index";

package/dist/plugins/stitchWith.js

@@ -0,0 +1,2 @@
+"use strict";
+module.exports = require("./stitch-with/index");

package/dist/plugins/stitchWith.mjs

@@ -0,0 +1 @@
+export * from "./stitch-with/index.mjs";

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

@@ -23,9 +23,25 @@ exports.stringMinPlugin = (0, plugin_definition_1.definePlugin)()({
             code: ctx.code,
             messageFactory: ctx.messageFactory,
             severity: ctx.severity,
-            run: (value) => !(0, types_1.isString)(value) || (0, types_1.countCodePoints)(value) >= min
-                ? types_1.PASS
-                : (0, types_1.fail)({ expected: min, actual: (0, types_1.countCodePoints)(value) }),
+            // Stops as soon as min is reached. The full length is only needed to
+            // REPORT a failure, and a failing value is shorter than min, so that
+            // walk is short too. Counting is still by code point, not UTF-16 unit;
+            // the only thing that changed is when it stops.
+            run: (value) => {
+                if (!(0, types_1.isString)(value))
+                    return types_1.PASS;
+                // min of 0 admits the empty string. The loop body never runs on an
+                // empty string, so without this line the empty string fails with 0.
+                if (min === 0)
+                    return types_1.PASS;
+                let count = 0;
+                for (const _character of value) {
+                    count += 1;
+                    if (count >= min)
+                        return types_1.PASS;
+                }
+                return (0, types_1.fail)({ expected: min, actual: count });
+            },
             describe: (detail) => `String must have at least ${String(min)} characters, but got ` +
                 `${String(detail.actual)}`,
             buildMessageContext: (detail) => ({

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,25 @@ 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) }),
+            // Stops as soon as min is reached. The full length is only needed to
+            // REPORT a failure, and a failing value is shorter than min, so that
+            // walk is short too. Counting is still by code point, not UTF-16 unit;
+            // the only thing that changed is when it stops.
+            run: (value) => {
+                if (!isString(value))
+                    return PASS;
+                // min of 0 admits the empty string. The loop body never runs on an
+                // empty string, so without this line the empty string fails with 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,164 @@
+/**
+ * Present, absent, null. Nearly every declaration uses one of the three.
+ */
+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;
+    }>;
+}>;
+/** The everyday string checks. */
+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;
+        };
+    }>;
+}>;
+/** The everyday number checks. */
+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;
+    }>;
+}>;
+/** The everyday array checks. Per-element rules ride on 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;
+    }>;
+}>;
+/**
+ * The four bundles above, together.
+ *
+ * Not called "common", because that name says nothing — and lint bans it. It
+ * holds presence plus the everyday string, number and array checks, and the
+ * name is the claim that this is the range people write day to day.
+ *
+ * Still not everything. For everything there is the `@maroonedog/luq/plugins`
+ * barrel, which costs accordingly.
+ */
+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,79 @@
+"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 — predefined plugin bundles.
+//
+// Why they exist. Importing plugins one at a time is the very mechanism behind
+// "you only ship what you used", but making someone write fifteen use() lines
+// for their first validator is imposing that correctness on them.
+//
+// Why several small ones rather than one big one. A single everything-bundle
+// bills the person who needs five plugins for forty. A bundle is just a
+// `PluginBag`, so useAll() takes only the ones wanted, and mixing them is
+// first-wins rather than a collision:
+//
+//     Builder().useAll(presence).useAll(strings).for<User>()
+//
+// Membership was chosen from how often each plugin is actually used across
+// this repository, most-used first.
+//
+// What a bundle costs in bytes is measured by the size budget. A preset trades
+// bytes for convenience, so the price should be measured rather than asserted.
+// ===========================================================================
+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");
+/**
+ * Present, absent, null. Nearly every declaration uses one of the three.
+ */
+exports.presence = Object.freeze({
+    required: required_1.requiredPlugin,
+    optional: optional_1.optionalPlugin,
+    nullable: nullable_1.nullablePlugin,
+});
+/** The everyday string checks. */
+exports.strings = Object.freeze({
+    stringMin: string_min_1.stringMinPlugin,
+    stringMax: string_max_1.stringMaxPlugin,
+    stringPattern: string_pattern_1.stringPatternPlugin,
+    stringEmail: string_email_1.stringEmailPlugin,
+});
+/** The everyday number checks. */
+exports.numbers = Object.freeze({
+    numberMin: number_min_1.numberMinPlugin,
+    numberMax: number_max_1.numberMaxPlugin,
+    numberInteger: number_integer_1.numberIntegerPlugin,
+});
+/** The everyday array checks. Per-element rules ride on arrayEach. */
+exports.arrays = Object.freeze({
+    arrayMinLength: array_min_length_1.arrayMinLengthPlugin,
+    arrayMaxLength: array_max_length_1.arrayMaxLengthPlugin,
+    arrayEach: array_each_1.arrayEachPlugin,
+});
+/**
+ * The four bundles above, together.
+ *
+ * Not called "common", because that name says nothing — and lint bans it. It
+ * holds presence plus the everyday string, number and array checks, and the
+ * name is the claim that this is the range people write day to day.
+ *
+ * Still not everything. For everything there is the `@maroonedog/luq/plugins`
+ * barrel, which costs accordingly.
+ */
+exports.everydayRules = Object.freeze({
+    ...exports.presence,
+    ...exports.strings,
+    ...exports.numbers,
+    ...exports.arrays,
+});

package/dist/presets/presets.mjs

@@ -0,0 +1,76 @@
+// ===========================================================================
+// L7  src/presets/presets.ts — predefined plugin bundles.
+//
+// Why they exist. Importing plugins one at a time is the very mechanism behind
+// "you only ship what you used", but making someone write fifteen use() lines
+// for their first validator is imposing that correctness on them.
+//
+// Why several small ones rather than one big one. A single everything-bundle
+// bills the person who needs five plugins for forty. A bundle is just a
+// `PluginBag`, so useAll() takes only the ones wanted, and mixing them is
+// first-wins rather than a collision:
+//
+//     Builder().useAll(presence).useAll(strings).for<User>()
+//
+// Membership was chosen from how often each plugin is actually used across
+// this repository, most-used first.
+//
+// What a bundle costs in bytes is measured by the size budget. A preset trades
+// bytes for convenience, so the price should be measured rather than asserted.
+// ===========================================================================
+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";
+/**
+ * Present, absent, null. Nearly every declaration uses one of the three.
+ */
+export const presence = Object.freeze({
+    required: requiredPlugin,
+    optional: optionalPlugin,
+    nullable: nullablePlugin,
+});
+/** The everyday string checks. */
+export const strings = Object.freeze({
+    stringMin: stringMinPlugin,
+    stringMax: stringMaxPlugin,
+    stringPattern: stringPatternPlugin,
+    stringEmail: stringEmailPlugin,
+});
+/** The everyday number checks. */
+export const numbers = Object.freeze({
+    numberMin: numberMinPlugin,
+    numberMax: numberMaxPlugin,
+    numberInteger: numberIntegerPlugin,
+});
+/** The everyday array checks. Per-element rules ride on arrayEach. */
+export const arrays = Object.freeze({
+    arrayMinLength: arrayMinLengthPlugin,
+    arrayMaxLength: arrayMaxLengthPlugin,
+    arrayEach: arrayEachPlugin,
+});
+/**
+ * The four bundles above, together.
+ *
+ * Not called "common", because that name says nothing — and lint bans it. It
+ * holds presence plus the everyday string, number and array checks, and the
+ * name is the claim that this is the range people write day to day.
+ *
+ * Still not everything. For everything there is the `@maroonedog/luq/plugins`
+ * barrel, which costs accordingly.
+ */
+export const everydayRules = Object.freeze({
+    ...presence,
+    ...strings,
+    ...numbers,
+    ...arrays,
+});

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

@@ -56,15 +56,29 @@ 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) };
+/**
+ * Walks the template **once** and folds it into a wrapping function.
+ *
+ * Walking it per validation re-read each segment's kind every time, which is
+ * exactly the thing validation time must not do: what something IS was settled
+ * at compile time. The non-wildcard route was always shaped this way.
+ */
+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) {