@maroonedog/luq 0.1.1-alpha → 2.0.0

package/dist/builder/resolve-field-default.d.ts

@@ -0,0 +1,14 @@
+import type { FieldOptions } from "./field-options.types";
+export interface FieldDefaultPolicy {
+    readonly defaultOf: ((root: unknown) => unknown) | null;
+    readonly applyDefaultToNull: boolean;
+}
+/**
+ * A declaration that names no default at all shares one frozen policy, so the
+ * overwhelmingly common field allocates nothing.
+ *
+ * `default: undefined` is read as "no default": undefined is precisely the
+ * value a default exists to replace, so storing it would build a writer that
+ * writes back what it read.
+ */
+export declare function resolveFieldDefault<TValue>(options: FieldOptions<TValue> | undefined): FieldDefaultPolicy;

package/dist/builder/resolve-field-default.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFieldDefault = resolveFieldDefault;
+// ===========================================================================
+// L6  src/builder/resolve-field-default.ts
+// `.v()`'s third argument becomes the two members CompiledField reads. Doing it
+// HERE, at declaration time, is what keeps run-field's applyDefault free of a
+// "is this a factory or a literal" test on the hot path: the eager form is
+// wrapped into a factory once, at build().
+// ===========================================================================
+const compile_field_1 = require("../compile/compile-field");
+const NO_DEFAULT = Object.freeze({
+    defaultOf: null,
+    applyDefaultToNull: compile_field_1.APPLIES_DEFAULT_TO_NULL_BY_DEFAULT,
+});
+/**
+ * A declaration that names no default at all shares one frozen policy, so the
+ * overwhelmingly common field allocates nothing.
+ *
+ * `default: undefined` is read as "no default": undefined is precisely the
+ * value a default exists to replace, so storing it would build a writer that
+ * writes back what it read.
+ */
+function resolveFieldDefault(options) {
+    const applyDefaultToNull = options?.applyDefaultToNull ?? compile_field_1.APPLIES_DEFAULT_TO_NULL_BY_DEFAULT;
+    const declared = options?.default;
+    if (declared === undefined) {
+        return applyDefaultToNull === compile_field_1.APPLIES_DEFAULT_TO_NULL_BY_DEFAULT
+            ? NO_DEFAULT
+            : Object.freeze({ defaultOf: null, applyDefaultToNull });
+    }
+    return Object.freeze({
+        defaultOf: toDefaultFactory(declared),
+        applyDefaultToNull,
+    });
+}
+/**
+ * A type GUARD rather than an assertion: this file is not permitted to assert
+ * and does not need to. `typeof === "function"` is the same test the legacy
+ * applyDefault made, kept because the documented option really is
+ * `T | (() => T)`.
+ */
+function isDefaultFactory(declared) {
+    return typeof declared === "function";
+}
+function toDefaultFactory(declared) {
+    if (isDefaultFactory(declared))
+        return (root) => declared(root);
+    return () => declared;
+}

package/dist/builder/resolve-field-default.mjs

@@ -0,0 +1,47 @@
+// ===========================================================================
+// L6  src/builder/resolve-field-default.ts
+// `.v()`'s third argument becomes the two members CompiledField reads. Doing it
+// HERE, at declaration time, is what keeps run-field's applyDefault free of a
+// "is this a factory or a literal" test on the hot path: the eager form is
+// wrapped into a factory once, at build().
+// ===========================================================================
+import { APPLIES_DEFAULT_TO_NULL_BY_DEFAULT } from "../compile/compile-field.mjs";
+const NO_DEFAULT = Object.freeze({
+    defaultOf: null,
+    applyDefaultToNull: APPLIES_DEFAULT_TO_NULL_BY_DEFAULT,
+});
+/**
+ * A declaration that names no default at all shares one frozen policy, so the
+ * overwhelmingly common field allocates nothing.
+ *
+ * `default: undefined` is read as "no default": undefined is precisely the
+ * value a default exists to replace, so storing it would build a writer that
+ * writes back what it read.
+ */
+export function resolveFieldDefault(options) {
+    const applyDefaultToNull = options?.applyDefaultToNull ?? APPLIES_DEFAULT_TO_NULL_BY_DEFAULT;
+    const declared = options?.default;
+    if (declared === undefined) {
+        return applyDefaultToNull === APPLIES_DEFAULT_TO_NULL_BY_DEFAULT
+            ? NO_DEFAULT
+            : Object.freeze({ defaultOf: null, applyDefaultToNull });
+    }
+    return Object.freeze({
+        defaultOf: toDefaultFactory(declared),
+        applyDefaultToNull,
+    });
+}
+/**
+ * A type GUARD rather than an assertion: this file is not permitted to assert
+ * and does not need to. `typeof === "function"` is the same test the legacy
+ * applyDefault made, kept because the documented option really is
+ * `T | (() => T)`.
+ */
+function isDefaultFactory(declared) {
+    return typeof declared === "function";
+}
+function toDefaultFactory(declared) {
+    if (isDefaultFactory(declared))
+        return (root) => declared(root);
+    return () => declared;
+}

package/dist/builder/validator.types.d.ts

@@ -0,0 +1,28 @@
+import type { FieldPath } from "../path/field-path.types";
+import type { PickPaths, ValueAtPath } from "../path/value-at-path.types";
+import type { ValidateOptions, ValidationResult } from "../types/validation-result.types";
+/**
+ * A single field lifted out of a built validator. `siblings` is the legacy
+ * `allValues?: Partial<T>` argument: rules that reference other fields
+ * (compareField, requiredIf, ...) read the root through it.
+ */
+export interface FieldValidator<TRoot extends object, TValue> {
+    readonly path: string;
+    validate(value: unknown, siblings?: Partial<TRoot>, options?: ValidateOptions): ValidationResult<TValue>;
+}
+/**
+ * THE CONSUMER OF PickPaths. A form validates several named paths at once and
+ * wants back exactly those paths, keyed by the path string it asked for — not a
+ * Partial<T> the caller has to re-narrow. `pickAll` builds one of these; the
+ * paths are pre-resolved at that moment, matching user decision 1.
+ */
+export interface SubsetValidator<TRoot extends object, TPaths extends readonly string[]> {
+    readonly paths: TPaths;
+    validate(value: unknown, options?: ValidateOptions): ValidationResult<PickPaths<TRoot, TPaths>>;
+}
+export interface Validator<T extends object, TParsed = T> {
+    validate(value: unknown, options?: ValidateOptions): ValidationResult<T>;
+    parse(value: unknown, options?: ValidateOptions): ValidationResult<TParsed>;
+    pick<K extends FieldPath<T> & string>(key: K): FieldValidator<T, ValueAtPath<T, K>>;
+    pickAll<const P extends readonly (FieldPath<T> & string)[]>(paths: P): SubsetValidator<T, P>;
+}

package/dist/builder/validator.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/builder/validator.types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/chain/attach-slot-methods.d.ts

@@ -0,0 +1,17 @@
+import type { TypeName } from "../types";
+import type { AnyPlugin } from "../plugin-kit/plugin-definition";
+import type { PluginBag } from "./plugin-bag.types";
+/** The owner named for a clash with a method the chain itself provides. */
+export declare const CHAIN_BUILT_IN_OWNER = "luq:chain (built-in refine method)";
+export declare class PluginMethodCollisionError extends Error {
+    readonly methodName: string;
+    readonly slot: TypeName;
+    readonly firstPluginName: string;
+    readonly secondPluginName: string;
+    constructor(methodName: string, slot: TypeName, firstPluginName: string, secondPluginName: string);
+}
+/**
+ * Installs one method per plugin serving `slot` onto `target`. `createMethod`
+ * is supplied by the node so this module never needs to know what a rule is.
+ */
+export declare function attachSlotMethods(target: Record<string, unknown>, bag: PluginBag, slot: TypeName, createMethod: (plugin: AnyPlugin) => (...args: readonly unknown[]) => unknown): void;

package/dist/chain/attach-slot-methods.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginMethodCollisionError = exports.CHAIN_BUILT_IN_OWNER = void 0;
+exports.attachSlotMethods = attachSlotMethods;
+const refine_methods_types_1 = require("./refine-methods.types");
+/** The owner named for a clash with a method the chain itself provides. */
+exports.CHAIN_BUILT_IN_OWNER = "luq:chain (built-in refine method)";
+class PluginMethodCollisionError extends Error {
+    constructor(methodName, slot, firstPluginName, secondPluginName) {
+        super(`Method "${methodName}" on the "${slot}" slot is claimed by both ` +
+            `"${firstPluginName}" and "${secondPluginName}". Rename one of them ` +
+            `or register only one of the two plugins.`);
+        this.methodName = methodName;
+        this.slot = slot;
+        this.firstPluginName = firstPluginName;
+        this.secondPluginName = secondPluginName;
+        this.name = "PluginMethodCollisionError";
+    }
+}
+exports.PluginMethodCollisionError = PluginMethodCollisionError;
+function isRefineMethodName(methodName) {
+    return Object.prototype.hasOwnProperty.call(refine_methods_types_1.REFINE_METHOD_SLOTS, methodName);
+}
+/**
+ * Installs one method per plugin serving `slot` onto `target`. `createMethod`
+ * is supplied by the node so this module never needs to know what a rule is.
+ */
+function attachSlotMethods(target, bag, slot, createMethod) {
+    const claimedBy = new Map();
+    for (const key of Object.keys(bag)) {
+        const plugin = bag[key];
+        if (plugin === undefined)
+            continue;
+        if (!plugin.slots.includes(slot))
+            continue;
+        const methodName = plugin.method;
+        if (isRefineMethodName(methodName)) {
+            throw new PluginMethodCollisionError(methodName, slot, exports.CHAIN_BUILT_IN_OWNER, plugin.name);
+        }
+        const claimant = claimedBy.get(methodName);
+        if (claimant !== undefined) {
+            throw new PluginMethodCollisionError(methodName, slot, claimant, plugin.name);
+        }
+        claimedBy.set(methodName, plugin.name);
+        target[methodName] = createMethod(plugin);
+    }
+}

package/dist/chain/attach-slot-methods.mjs

@@ -0,0 +1,42 @@
+import { REFINE_METHOD_SLOTS } from "./refine-methods.types.mjs";
+/** The owner named for a clash with a method the chain itself provides. */
+export const CHAIN_BUILT_IN_OWNER = "luq:chain (built-in refine method)";
+export class PluginMethodCollisionError extends Error {
+    constructor(methodName, slot, firstPluginName, secondPluginName) {
+        super(`Method "${methodName}" on the "${slot}" slot is claimed by both ` +
+            `"${firstPluginName}" and "${secondPluginName}". Rename one of them ` +
+            `or register only one of the two plugins.`);
+        this.methodName = methodName;
+        this.slot = slot;
+        this.firstPluginName = firstPluginName;
+        this.secondPluginName = secondPluginName;
+        this.name = "PluginMethodCollisionError";
+    }
+}
+function isRefineMethodName(methodName) {
+    return Object.prototype.hasOwnProperty.call(REFINE_METHOD_SLOTS, methodName);
+}
+/**
+ * Installs one method per plugin serving `slot` onto `target`. `createMethod`
+ * is supplied by the node so this module never needs to know what a rule is.
+ */
+export function attachSlotMethods(target, bag, slot, createMethod) {
+    const claimedBy = new Map();
+    for (const key of Object.keys(bag)) {
+        const plugin = bag[key];
+        if (plugin === undefined)
+            continue;
+        if (!plugin.slots.includes(slot))
+            continue;
+        const methodName = plugin.method;
+        if (isRefineMethodName(methodName)) {
+            throw new PluginMethodCollisionError(methodName, slot, CHAIN_BUILT_IN_OWNER, plugin.name);
+        }
+        const claimant = claimedBy.get(methodName);
+        if (claimant !== undefined) {
+            throw new PluginMethodCollisionError(methodName, slot, claimant, plugin.name);
+        }
+        claimedBy.set(methodName, plugin.name);
+        target[methodName] = createMethod(plugin);
+    }
+}

package/dist/chain/chain-method.types.d.ts

@@ -0,0 +1,16 @@
+import type { GuardOut, TransformOut } from "../plugin-kit/marker.types";
+import type { PluginDefinition, PluginSignature } from "../plugin-kit/plugin-definition";
+import type { Present, RuleOptions, TypeName } from "../types";
+import type { PluginBag } from "./plugin-bag.types";
+import type { ChainState, CoverWith } from "./chain-state.types";
+import type { ResolveArgs, ResolveOut } from "./resolve-args.types";
+import type { AnyChain, FieldChain } from "./field-chain.types";
+import type { FieldSlots } from "./field-slots.types";
+/** One plugin definition -> one call signature. */
+export type ChainMethod<P, B extends PluginBag, S extends TypeName, TRoot, TValue, TState extends ChainState> = P extends PluginDefinition<string, string, readonly TypeName[], infer Sig extends PluginSignature> ? [Sig["out"]] extends [TransformOut] ? <R>(map: (value: Present<TValue, TState>) => R, options?: RuleOptions<Sig["context"]>) => FieldChain<B, S, TRoot, R, TState> : [Sig["out"]] extends [GuardOut] ? <X extends Present<TValue, TState>>(condition: (value: Present<TValue, TState>) => value is X, define: (b: FieldSlots<TRoot, B, X>) => AnyChain, options?: RuleOptions<Sig["context"]>) => FieldChain<B, S, TRoot, TValue, CoverWith<TState, X>> : (...args: [
+    ...ResolveArgs<Sig["args"], B, TRoot, TValue, TState>,
+    options?: RuleOptions<Sig["context"]>
+]) => ResolveOut<Sig["out"], TValue, TState> extends [
+    infer V,
+    infer St extends ChainState
+] ? FieldChain<B, S, TRoot, V, St> : never : never;

package/dist/chain/chain-method.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/chain/chain-method.types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/chain/chain-state.types.d.ts

@@ -0,0 +1,47 @@
+import type { PresenceState } from "../types";
+export interface ChainState extends PresenceState {
+    /** Union of the members already claimed by a `.guard()` call. `never` = none. */
+    readonly covered: unknown;
+}
+export interface OpenState extends ChainState {
+    readonly undefinedAllowed: true;
+    readonly nullAllowed: true;
+    readonly covered: never;
+}
+/** `.required()`: neither undefined nor null may reach the value. */
+export interface ExcludeMissing<S extends ChainState> extends ChainState {
+    readonly undefinedAllowed: false;
+    readonly nullAllowed: false;
+    readonly covered: S["covered"];
+}
+export interface ExcludeUndefined<S extends ChainState> extends ChainState {
+    readonly undefinedAllowed: false;
+    readonly nullAllowed: S["nullAllowed"];
+    readonly covered: S["covered"];
+}
+export interface ExcludeNull<S extends ChainState> extends ChainState {
+    readonly undefinedAllowed: S["undefinedAllowed"];
+    readonly nullAllowed: false;
+    readonly covered: S["covered"];
+}
+export interface AllowNull<S extends ChainState> extends ChainState {
+    readonly undefinedAllowed: S["undefinedAllowed"];
+    readonly nullAllowed: true;
+    readonly covered: S["covered"];
+}
+export interface CoverWith<S extends ChainState, X> extends ChainState {
+    readonly undefinedAllowed: S["undefinedAllowed"];
+    readonly nullAllowed: S["nullAllowed"];
+    readonly covered: S["covered"] | X;
+}
+/** Members of TValue no `.guard()` has claimed. */
+export type UncoveredMembers<TValue, S extends ChainState> = [
+    S["covered"]
+] extends [never] ? never : Exclude<TValue, S["covered"]>;
+/** Returned by `.v()` instead of the builder when guards do not cover TValue. */
+export interface UnionGuardCoverageError<TPath extends string, TUncovered> {
+    readonly luqError: "unionGuardNotExhaustive";
+    readonly message: "Add a .guard() for every member of this union, or drop the guards entirely.";
+    readonly path: TPath;
+    readonly uncovered: TUncovered;
+}

package/dist/chain/chain-state.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/chain/chain-state.types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/chain/collect-branch-rules.d.ts

@@ -0,0 +1,18 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { AnyPlugin } from "../plugin-kit/plugin-definition";
+import type { PluginBag } from "./plugin-bag.types";
+import { type ChainBuildContext } from "./create-chain-node";
+export type SubChainDefine = (slots: unknown) => unknown;
+export type SlotSurfaceFactory = (bag: PluginBag, context: ChainBuildContext) => Readonly<Record<string, unknown>>;
+/** What a plugin adds to its definition to declare its sub-chain positions. */
+export interface SubChainArgumentDeclaration {
+    readonly subChainArguments: readonly number[];
+}
+export declare class SubChainResultError extends Error {
+    readonly fieldPath: string;
+    constructor(fieldPath: string);
+}
+/** Runs ONE sub-chain callback exactly once and freezes what it produced. */
+export declare function collectBranchRules(bag: PluginBag, context: ChainBuildContext, define: SubChainDefine, createSlots: SlotSurfaceFactory): readonly Rule[];
+/** Replaces every DECLARED sub-chain position with its collected rules. */
+export declare function resolvePluginArguments(bag: PluginBag, context: ChainBuildContext, createSlots: SlotSurfaceFactory, plugin: AnyPlugin, declared: readonly unknown[]): unknown[];

package/dist/chain/collect-branch-rules.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubChainResultError = void 0;
+exports.collectBranchRules = collectBranchRules;
+exports.resolvePluginArguments = resolvePluginArguments;
+// ===========================================================================
+// L3  src/chain/collect-branch-rules.ts — where the EAGER-RESOLUTION invariant
+// lives (verification.md, CONTRADICTION A-2).
+//
+// ElementChain / NarrowedChain / PropertyValueChain / PropertyKeyChain all
+// resolve to `readonly Rule[]`, never to a thunk: the chain runs the sub-chain
+// callback ONCE, here, and hands the plugin a frozen array. A plugin therefore
+// cannot run a user callback zero times or twice.
+//
+// WHICH argument positions carry a sub-chain cannot be recovered from the
+// plugin's TYPE at run time (`signature` is type-only, and a NarrowedChain and
+// a RootPredicate are both plain functions once erased), so a plugin that takes
+// one DECLARES the positions. The container is then read from the value:
+// a function is one sub-chain, an array is a list of them (tupleBuilder), a
+// plain object is a keyed set of them (patternProperties, dependentSchemas).
+// ===========================================================================
+const types_1 = require("../types");
+const create_chain_node_1 = require("./create-chain-node");
+const NO_SUB_CHAINS = Object.freeze([]);
+class SubChainResultError extends Error {
+    constructor(fieldPath) {
+        super(`A sub-chain callback for "${fieldPath}" did not return a chain. ` +
+            `End it on a slot method, for example \`(b) => b.string.required()\`.`);
+        this.fieldPath = fieldPath;
+        this.name = "SubChainResultError";
+    }
+}
+exports.SubChainResultError = SubChainResultError;
+function isSubChainDefine(value) {
+    return typeof value === "function";
+}
+function readSubChainArguments(plugin) {
+    const declared = plugin.subChainArguments;
+    return declared === undefined ? NO_SUB_CHAINS : declared;
+}
+/** Runs ONE sub-chain callback exactly once and freezes what it produced. */
+function collectBranchRules(bag, context, define, createSlots) {
+    const rules = (0, create_chain_node_1.readChainRules)(define(createSlots(bag, context)));
+    if (rules === undefined)
+        throw new SubChainResultError(context.fieldPath);
+    return Object.freeze(rules.slice());
+}
+function resolveSubChainArgument(bag, context, createSlots, value) {
+    if (isSubChainDefine(value))
+        return collectBranchRules(bag, context, value, createSlots);
+    if ((0, types_1.isArray)(value)) {
+        return Object.freeze(value.map((entry) => resolveSubChainArgument(bag, context, createSlots, entry)));
+    }
+    if ((0, types_1.isPlainObject)(value)) {
+        const resolved = {};
+        for (const [key, entry] of Object.entries(value)) {
+            resolved[key] = resolveSubChainArgument(bag, context, createSlots, entry);
+        }
+        return Object.freeze(resolved);
+    }
+    return value;
+}
+/** Replaces every DECLARED sub-chain position with its collected rules. */
+function resolvePluginArguments(bag, context, createSlots, plugin, declared) {
+    const positions = readSubChainArguments(plugin);
+    if (positions.length === 0)
+        return declared.slice();
+    return declared.map((value, index) => positions.includes(index)
+        ? resolveSubChainArgument(bag, context, createSlots, value)
+        : value);
+}

package/dist/chain/collect-branch-rules.mjs

@@ -0,0 +1,65 @@
+// ===========================================================================
+// L3  src/chain/collect-branch-rules.ts — where the EAGER-RESOLUTION invariant
+// lives (verification.md, CONTRADICTION A-2).
+//
+// ElementChain / NarrowedChain / PropertyValueChain / PropertyKeyChain all
+// resolve to `readonly Rule[]`, never to a thunk: the chain runs the sub-chain
+// callback ONCE, here, and hands the plugin a frozen array. A plugin therefore
+// cannot run a user callback zero times or twice.
+//
+// WHICH argument positions carry a sub-chain cannot be recovered from the
+// plugin's TYPE at run time (`signature` is type-only, and a NarrowedChain and
+// a RootPredicate are both plain functions once erased), so a plugin that takes
+// one DECLARES the positions. The container is then read from the value:
+// a function is one sub-chain, an array is a list of them (tupleBuilder), a
+// plain object is a keyed set of them (patternProperties, dependentSchemas).
+// ===========================================================================
+import { isArray, isPlainObject } from "../types/index.mjs";
+import { readChainRules } from "./create-chain-node.mjs";
+const NO_SUB_CHAINS = Object.freeze([]);
+export class SubChainResultError extends Error {
+    constructor(fieldPath) {
+        super(`A sub-chain callback for "${fieldPath}" did not return a chain. ` +
+            `End it on a slot method, for example \`(b) => b.string.required()\`.`);
+        this.fieldPath = fieldPath;
+        this.name = "SubChainResultError";
+    }
+}
+function isSubChainDefine(value) {
+    return typeof value === "function";
+}
+function readSubChainArguments(plugin) {
+    const declared = plugin.subChainArguments;
+    return declared === undefined ? NO_SUB_CHAINS : declared;
+}
+/** Runs ONE sub-chain callback exactly once and freezes what it produced. */
+export function collectBranchRules(bag, context, define, createSlots) {
+    const rules = readChainRules(define(createSlots(bag, context)));
+    if (rules === undefined)
+        throw new SubChainResultError(context.fieldPath);
+    return Object.freeze(rules.slice());
+}
+function resolveSubChainArgument(bag, context, createSlots, value) {
+    if (isSubChainDefine(value))
+        return collectBranchRules(bag, context, value, createSlots);
+    if (isArray(value)) {
+        return Object.freeze(value.map((entry) => resolveSubChainArgument(bag, context, createSlots, entry)));
+    }
+    if (isPlainObject(value)) {
+        const resolved = {};
+        for (const [key, entry] of Object.entries(value)) {
+            resolved[key] = resolveSubChainArgument(bag, context, createSlots, entry);
+        }
+        return Object.freeze(resolved);
+    }
+    return value;
+}
+/** Replaces every DECLARED sub-chain position with its collected rules. */
+export function resolvePluginArguments(bag, context, createSlots, plugin, declared) {
+    const positions = readSubChainArguments(plugin);
+    if (positions.length === 0)
+        return declared.slice();
+    return declared.map((value, index) => positions.includes(index)
+        ? resolveSubChainArgument(bag, context, createSlots, value)
+        : value);
+}

package/dist/chain/collect-field-rules.d.ts

@@ -0,0 +1,10 @@
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { PluginBag } from "./plugin-bag.types";
+import type { AnyChain } from "./field-chain.types";
+import type { FieldSlots } from "./field-slots.types";
+import { type ChainBuildContext } from "./create-chain-node";
+export declare class FieldChainResultError extends Error {
+    readonly fieldPath: string;
+    constructor(fieldPath: string);
+}
+export declare function collectFieldRules<TRoot, B extends PluginBag, TField>(bag: B, context: ChainBuildContext, define: (b: FieldSlots<TRoot, B, TField>) => AnyChain): readonly Rule[];

package/dist/chain/collect-field-rules.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldChainResultError = void 0;
+exports.collectFieldRules = collectFieldRules;
+const create_chain_node_1 = require("./create-chain-node");
+const create_field_slots_1 = require("./create-field-slots");
+class FieldChainResultError extends Error {
+    constructor(fieldPath) {
+        super(`The definition of "${fieldPath}" did not return a chain. End it on a ` +
+            `slot method, for example \`(b) => b.string.required()\`.`);
+        this.fieldPath = fieldPath;
+        this.name = "FieldChainResultError";
+    }
+}
+exports.FieldChainResultError = FieldChainResultError;
+function collectFieldRules(bag, context, define) {
+    const chain = define((0, create_field_slots_1.createFieldSlots)(bag, context));
+    const rules = (0, create_chain_node_1.readChainRules)(chain);
+    if (rules === undefined)
+        throw new FieldChainResultError(context.fieldPath);
+    return Object.freeze(rules.slice());
+}

package/dist/chain/collect-field-rules.mjs

@@ -0,0 +1,17 @@
+import { readChainRules } from "./create-chain-node.mjs";
+import { createFieldSlots } from "./create-field-slots.mjs";
+export class FieldChainResultError extends Error {
+    constructor(fieldPath) {
+        super(`The definition of "${fieldPath}" did not return a chain. End it on a ` +
+            `slot method, for example \`(b) => b.string.required()\`.`);
+        this.fieldPath = fieldPath;
+        this.name = "FieldChainResultError";
+    }
+}
+export function collectFieldRules(bag, context, define) {
+    const chain = define(createFieldSlots(bag, context));
+    const rules = readChainRules(chain);
+    if (rules === undefined)
+        throw new FieldChainResultError(context.fieldPath);
+    return Object.freeze(rules.slice());
+}

package/dist/chain/create-chain-node.d.ts

@@ -0,0 +1,26 @@
+import type { TypeName } from "../types";
+import type { ResolvedGlobalConfig } from "../types/global-config";
+import type { Rule } from "../plugin-kit/compiled-rule";
+import type { AnyPlugin } from "../plugin-kit/plugin-definition";
+import type { PluginBag } from "./plugin-bag.types";
+export declare const EMPTY_RULES: readonly Rule[];
+/** What a chain needs to build a rule, independent of which slot it is on. */
+export interface ChainBuildContext {
+    readonly fieldPath: string;
+    readonly declaredSiblingKeys: readonly string[];
+    readonly config: ResolvedGlobalConfig;
+}
+/**
+ * The parts a node cannot make for itself. `resolveArguments` is injected so
+ * that create-field-slots owns the recursive knot (a sub-chain needs slots,
+ * slots need nodes, a node needs sub-chains) and no import cycle forms.
+ */
+export interface ChainNodeWiring {
+    readonly bag: PluginBag;
+    readonly context: ChainBuildContext;
+    resolveArguments(plugin: AnyPlugin, declared: readonly unknown[]): unknown[];
+}
+/** The runtime value behind FieldChain. Erased to its type by its callers. */
+export declare function createChainNode(wiring: ChainNodeWiring, slot: TypeName, rules: readonly Rule[]): Readonly<Record<string, unknown>>;
+/** The one way back out of a chain: undefined when the value is not a node. */
+export declare function readChainRules(candidate: unknown): readonly Rule[] | undefined;