@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/path/path-segment.types.mjs

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

package/dist/path/property-value-of.types.d.ts

@@ -0,0 +1,2 @@
+import type { IsOpaqueObject } from "./opaque-object.types";
+export type PropertyValueOf<T> = unknown extends T ? unknown : NonNullable<T> extends infer U ? U extends readonly unknown[] ? never : IsOpaqueObject<U> extends true ? never : U extends object ? U[Extract<keyof U, string>] : never : never;

package/dist/path/property-value-of.types.js

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

package/dist/path/property-value-of.types.mjs

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

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

@@ -0,0 +1,46 @@
+/**
+ * `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`
+ *  turned a typo into a rule that never ran. */
+export declare class PathSyntaxError extends Error {
+    readonly path: string;
+    constructor(path: string, reason: string);
+}
+export declare function isReservedSegment(key: string): boolean;
+/**
+ * The single definition of "this string may be used as one path segment".
+ *
+ * `source` is the whole path (or the origin, for a key that has not been
+ * joined into a path yet) and appears in the message so a regression names the
+ * offender.
+ *
+ * A key containing `.` is rejected rather than escaped: the grammar splits on
+ * `.` and has no escape syntax, so such a key would silently mean something
+ * else. Rejecting is the only honest option, and it is the reason this
+ * function is exported — the JSON Schema converter must call it on raw
+ * property names BEFORE joining them into a path, where the dot is still
+ * visible as its own key.
+ */
+export declare function assertDeclarableKey(key: string, source: string): void;

package/dist/path/reserved-segment.js

@@ -0,0 +1,88 @@
+"use strict";
+// ===========================================================================
+// L1  src/path/reserved-segment.ts
+// The prototype-pollution gate for the ONE path grammar, plus the error every
+// path-shaped rejection throws.
+//
+// PathSyntaxError lives here, not in parse-field-path.ts, because this module
+// is the first thing that throws it and parse-field-path.ts imports this one.
+// Putting the class the other way round would make the two files mutually
+// dependent for no gain.
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathSyntaxError = exports.RESERVED_SEGMENTS = void 0;
+exports.isReservedSegment = isReservedSegment;
+exports.assertDeclarableKey = assertDeclarableKey;
+/**
+ * `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",
+    "prototype",
+]);
+/** Thrown at BUILD time for every malformed or unsafe path. A declared rule
+ *  must either execute or fail loudly; the legacy silent `return () => null`
+ *  turned a typo into a rule that never ran. */
+class PathSyntaxError extends Error {
+    constructor(path, reason) {
+        super(`Invalid field path ${JSON.stringify(path)}: ${reason}`);
+        this.name = "PathSyntaxError";
+        this.path = path;
+    }
+}
+exports.PathSyntaxError = PathSyntaxError;
+function isReservedSegment(key) {
+    return exports.RESERVED_SEGMENTS.includes(key);
+}
+/**
+ * The single definition of "this string may be used as one path segment".
+ *
+ * `source` is the whole path (or the origin, for a key that has not been
+ * joined into a path yet) and appears in the message so a regression names the
+ * offender.
+ *
+ * A key containing `.` is rejected rather than escaped: the grammar splits on
+ * `.` and has no escape syntax, so such a key would silently mean something
+ * else. Rejecting is the only honest option, and it is the reason this
+ * function is exported — the JSON Schema converter must call it on raw
+ * property names BEFORE joining them into a path, where the dot is still
+ * visible as its own key.
+ */
+function assertDeclarableKey(key, source) {
+    if (key === "") {
+        throw new PathSyntaxError(source, "a path segment must not be empty");
+    }
+    if (key.includes(".")) {
+        throw new PathSyntaxError(source, `the key ${JSON.stringify(key)} contains "." and cannot be expressed; ` +
+            'the grammar splits on "." and defines no escape');
+    }
+    if (key.includes("[") || key.includes("]")) {
+        throw new PathSyntaxError(source, `the key ${JSON.stringify(key)} contains a bracket; "[*]" is the only ` +
+            "bracket form and it must trail a key");
+    }
+    // 予約セグメントの拒否はここから外した。理由は RESERVED_SEGMENTS の
+    // コメントに書いてある。要約すると、危険なのは書き込みだけで、その書き込みは
+    // create-value-writer.ts が defineProperty に移したので安全になった。
+    // 名前で拒否する必要が無くなり、JSON Schema が "__proto__" というキーを
+    // 持つオブジェクトを検証できるようになった。
+}

package/dist/path/reserved-segment.mjs

@@ -0,0 +1,82 @@
+// ===========================================================================
+// L1  src/path/reserved-segment.ts
+// The prototype-pollution gate for the ONE path grammar, plus the error every
+// path-shaped rejection throws.
+//
+// PathSyntaxError lives here, not in parse-field-path.ts, because this module
+// is the first thing that throws it and parse-field-path.ts imports this one.
+// Putting the class the other way round would make the two files mutually
+// dependent for no gain.
+// ===========================================================================
+/**
+ * `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",
+    "prototype",
+]);
+/** Thrown at BUILD time for every malformed or unsafe path. A declared rule
+ *  must either execute or fail loudly; the legacy silent `return () => null`
+ *  turned a typo into a rule that never ran. */
+export class PathSyntaxError extends Error {
+    constructor(path, reason) {
+        super(`Invalid field path ${JSON.stringify(path)}: ${reason}`);
+        this.name = "PathSyntaxError";
+        this.path = path;
+    }
+}
+export function isReservedSegment(key) {
+    return RESERVED_SEGMENTS.includes(key);
+}
+/**
+ * The single definition of "this string may be used as one path segment".
+ *
+ * `source` is the whole path (or the origin, for a key that has not been
+ * joined into a path yet) and appears in the message so a regression names the
+ * offender.
+ *
+ * A key containing `.` is rejected rather than escaped: the grammar splits on
+ * `.` and has no escape syntax, so such a key would silently mean something
+ * else. Rejecting is the only honest option, and it is the reason this
+ * function is exported — the JSON Schema converter must call it on raw
+ * property names BEFORE joining them into a path, where the dot is still
+ * visible as its own key.
+ */
+export function assertDeclarableKey(key, source) {
+    if (key === "") {
+        throw new PathSyntaxError(source, "a path segment must not be empty");
+    }
+    if (key.includes(".")) {
+        throw new PathSyntaxError(source, `the key ${JSON.stringify(key)} contains "." and cannot be expressed; ` +
+            'the grammar splits on "." and defines no escape');
+    }
+    if (key.includes("[") || key.includes("]")) {
+        throw new PathSyntaxError(source, `the key ${JSON.stringify(key)} contains a bracket; "[*]" is the only ` +
+            "bracket form and it must trail a key");
+    }
+    // 予約セグメントの拒否はここから外した。理由は RESERVED_SEGMENTS の
+    // コメントに書いてある。要約すると、危険なのは書き込みだけで、その書き込みは
+    // create-value-writer.ts が defineProperty に移したので安全になった。
+    // 名前で拒否する必要が無くなり、JSON Schema が "__proto__" というキーを
+    // 持つオブジェクトを検証できるようになった。
+}

package/dist/path/value-at-path.types.d.ts

@@ -0,0 +1,25 @@
+import type { ParsePath, Segment } from "./path-segment.types";
+import type { IsOpaqueObject } from "./opaque-object.types";
+import type { ElementOf } from "./element-of.types";
+/** `unknown extends T` is tested BEFORE NonNullable, because
+ *  `NonNullable<unknown>` is `{}` since TS 4.9 and would otherwise collapse
+ *  every Record<string, unknown> subtree to never on the second segment. */
+type ReadKey<T, K extends string> = unknown extends T ? unknown : NonNullable<T> extends infer U ? U extends readonly unknown[] ? never : IsOpaqueObject<U> extends true ? never : U extends object ? K extends keyof U ? U[K] : never : never : never;
+type WalkSegments<T, S extends readonly Segment[]> = S extends readonly [
+    infer H,
+    ...infer R extends readonly Segment[]
+] ? H extends {
+    readonly each: true;
+} ? WalkSegments<ElementOf<T>, R> : H extends {
+    readonly key: infer K extends string;
+} ? WalkSegments<ReadKey<T, K>, R> : never : T;
+/** The declared type at P. Optionality survives on the LAST segment only, so
+ *  the chain can observe presence type-state while intermediate steps stay
+ *  total: ValueAtPath<T,"opt"> is `Address | undefined`, ValueAtPath<T,
+ *  "opt.street"> is `string`. */
+export type ValueAtPath<T, P extends string> = WalkSegments<T, ParsePath<P>>;
+/** Maps a tuple of path literals to an object of their resolved value types. */
+export type PickPaths<T, P extends readonly string[]> = {
+    readonly [K in P[number]]: ValueAtPath<T, K>;
+};
+export {};

package/dist/path/value-at-path.types.js

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

package/dist/path/value-at-path.types.mjs

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

package/dist/plugin-kit/compiled-rule.d.ts

@@ -0,0 +1,112 @@
+import type { ArrayItemContext, CheckOutcome, IssueDetail, IssueSeverity, MessageContext, RuleContext } from "../types";
+export type RuleKind = "check" | "presence" | "conditionalPresence" | "gate" | "transform" | "composite" | "recursive";
+export interface CheckRule {
+    readonly kind: "check";
+    readonly code: string;
+    readonly severity: IssueSeverity;
+    run(value: unknown, ctx: RuleContext): CheckOutcome;
+    describe(detail: IssueDetail, ctx: MessageContext): string;
+}
+/**
+ * WHICH absences a rule permits, without the identity that reports a refusal.
+ * Split out because a conditional presence rule owns TWO of these — one per
+ * side of its predicate — while both sides share its code and its message.
+ */
+export interface PresenceAllowance {
+    readonly allowUndefined: boolean;
+    readonly allowNull: boolean;
+    readonly emptyStringIsMissing: boolean;
+    /**
+     * True when `null` is a VALUE this subject has to judge, rather than an
+     * absence presence may settle. Draft-07 sub-schemas need it: `false`,
+     * `{"not": {}}` and an `enum` without null all forbid null WITHOUT saying
+     * anything about `type`, and presence — which runs first — was answering
+     * for them. `[null]` passed `{"items":{"not":{}}}` because no check ever
+     * ran.
+     *
+     * Optional, and absent means false: a field the user declared keeps the
+     * builder's meaning, where `.nullable()` ENDS the field on null. Only
+     * src/json-schema/ turns it on.
+     */
+    readonly nullIsValue?: boolean;
+}
+export interface PresenceRule extends PresenceAllowance {
+    readonly kind: "presence";
+    readonly code: string;
+    readonly severity: IssueSeverity;
+    describe(ctx: MessageContext): string;
+}
+/**
+ * Presence only a value of the ROOT can settle: `.requiredIf(when)` and
+ * `.optionalIf(when)`.
+ *
+ * Plain PresenceRules merge into ONE policy at build time, which is why
+ * nothing before this could make a MISSING value depend on a sibling field.
+ * requiredIf had to be a check instead, and a check never sees undefined
+ * because the presence gate returns first — so `.requiredIf(cond)` alone was
+ * silent on the very absence it exists to forbid.
+ *
+ * The condition is therefore carried HERE, and compilation turns each side
+ * into a finished PresencePolicy. The run time evaluates one predicate and
+ * PICKS; it never assembles a policy and never asks what a rule is.
+ *
+ * `whenMet` / `whenUnmet` is null on the side that has no opinion, and the
+ * field then keeps the policy its unconditional rules already merged to. That
+ * is what leaves `.required().requiredIf(cond)` rejecting a missing value
+ * while the condition is false.
+ */
+export interface ConditionalPresenceRule {
+    readonly kind: "conditionalPresence";
+    readonly code: string;
+    readonly severity: IssueSeverity;
+    /** Evaluated once per field run, BEFORE the value is judged. */
+    when(root: unknown, arrayContext?: ArrayItemContext): boolean;
+    readonly whenMet: PresenceAllowance | null;
+    readonly whenUnmet: PresenceAllowance | null;
+    describe(ctx: MessageContext): string;
+}
+export interface GateRule {
+    readonly kind: "gate";
+    readonly code: string;
+    shouldRun(value: unknown, ctx: RuleContext): boolean;
+}
+export interface TransformRule {
+    readonly kind: "transform";
+    apply(value: unknown, ctx: RuleContext): unknown;
+}
+/** Rules bound to a path RELATIVE to the branch subject. */
+export interface BranchField {
+    readonly path: string;
+    readonly rules: readonly Rule[];
+}
+export interface CompositeBranch {
+    readonly label: string;
+    readonly rules: readonly Rule[];
+    readonly fields: readonly BranchField[];
+}
+/** A branch after compilation: the same call shape as a check. */
+export interface BranchRunner {
+    readonly label: string;
+    run(value: unknown, ctx: RuleContext): CheckOutcome;
+}
+export type CompositeExecute = (value: unknown, ctx: RuleContext) => CheckOutcome;
+export type CompositeCombine = (runners: readonly BranchRunner[]) => CompositeExecute;
+export interface CompositeRule {
+    readonly kind: "composite";
+    readonly code: string;
+    readonly severity: IssueSeverity;
+    readonly branches: readonly CompositeBranch[];
+    /** Called ONCE at build time; runners[i] corresponds to branches[i]. */
+    readonly combine: CompositeCombine;
+    describe(detail: IssueDetail, ctx: MessageContext): string;
+}
+export type RecursionTarget = "self" | "element";
+export interface RecursiveRule {
+    readonly kind: "recursive";
+    readonly code: string;
+    readonly severity: IssueSeverity;
+    readonly target: RecursionTarget;
+    readonly maxDepth: number;
+    describe(detail: IssueDetail, ctx: MessageContext): string;
+}
+export type Rule = CheckRule | PresenceRule | ConditionalPresenceRule | GateRule | TransformRule | CompositeRule | RecursiveRule;

package/dist/plugin-kit/compiled-rule.js

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

package/dist/plugin-kit/compiled-rule.mjs

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

package/dist/plugin-kit/create-conditional-presence.d.ts

@@ -0,0 +1,25 @@
+import type { IssueSeverity, MessageContext, MessageContextExtra, MessageFactory } from "../types";
+import type { ConditionalPresenceRule, PresenceAllowance } from "./compiled-rule";
+import type { RootPredicateFn } from "./runtime-args.types";
+/** Rejects undefined, null and "" — legacy's emptiness, verbatim. */
+export declare const REQUIRES_A_VALUE: PresenceAllowance;
+/**
+ * Permits undefined and null. "" stays PRESENT here, so a conditionally
+ * optional field still runs its own checks against an empty string, exactly
+ * as `.optional().min(3)` does.
+ */
+export declare const PERMITS_ABSENCE: PresenceAllowance;
+export interface ConditionalPresenceSpec<C extends MessageContextExtra> {
+    readonly code: string;
+    readonly messageFactory?: MessageFactory<C>;
+    readonly severity: IssueSeverity;
+    /** The user's predicate. Stored by identity, never re-wrapped. */
+    readonly when: RootPredicateFn;
+    /** In force while the predicate holds; null defers to the merged policy. */
+    readonly whenMet: PresenceAllowance | null;
+    /** In force while it does not; null defers to the merged policy. */
+    readonly whenUnmet: PresenceAllowance | null;
+    describe(ctx: MessageContext): string;
+    buildMessageContext(): C;
+}
+export declare function conditionalPresence<C extends MessageContextExtra>(spec: ConditionalPresenceSpec<C>): ConditionalPresenceRule;

package/dist/plugin-kit/create-conditional-presence.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PERMITS_ABSENCE = exports.REQUIRES_A_VALUE = void 0;
+exports.conditionalPresence = conditionalPresence;
+const rule_build_context_1 = require("./rule-build-context");
+/** Rejects undefined, null and "" — legacy's emptiness, verbatim. */
+exports.REQUIRES_A_VALUE = Object.freeze({
+    allowUndefined: false,
+    allowNull: false,
+    emptyStringIsMissing: true,
+});
+/**
+ * Permits undefined and null. "" stays PRESENT here, so a conditionally
+ * optional field still runs its own checks against an empty string, exactly
+ * as `.optional().min(3)` does.
+ */
+exports.PERMITS_ABSENCE = Object.freeze({
+    allowUndefined: true,
+    allowNull: true,
+    emptyStringIsMissing: false,
+});
+function conditionalPresence(spec) {
+    return {
+        kind: "conditionalPresence",
+        code: spec.code,
+        severity: spec.severity,
+        when: spec.when,
+        whenMet: spec.whenMet,
+        whenUnmet: spec.whenUnmet,
+        describe: (ctx) => (0, rule_build_context_1.renderMessage)(spec.messageFactory, ctx, spec.buildMessageContext(), spec.describe(ctx)),
+    };
+}

package/dist/plugin-kit/create-conditional-presence.mjs

@@ -0,0 +1,28 @@
+import { renderMessage } from "./rule-build-context.mjs";
+/** Rejects undefined, null and "" — legacy's emptiness, verbatim. */
+export const REQUIRES_A_VALUE = Object.freeze({
+    allowUndefined: false,
+    allowNull: false,
+    emptyStringIsMissing: true,
+});
+/**
+ * Permits undefined and null. "" stays PRESENT here, so a conditionally
+ * optional field still runs its own checks against an empty string, exactly
+ * as `.optional().min(3)` does.
+ */
+export const PERMITS_ABSENCE = Object.freeze({
+    allowUndefined: true,
+    allowNull: true,
+    emptyStringIsMissing: false,
+});
+export function conditionalPresence(spec) {
+    return {
+        kind: "conditionalPresence",
+        code: spec.code,
+        severity: spec.severity,
+        when: spec.when,
+        whenMet: spec.whenMet,
+        whenUnmet: spec.whenUnmet,
+        describe: (ctx) => renderMessage(spec.messageFactory, ctx, spec.buildMessageContext(), spec.describe(ctx)),
+    };
+}

package/dist/plugin-kit/create-rule.d.ts

@@ -0,0 +1,59 @@
+import type { CheckOutcome, IssueDetail, IssueSeverity, MessageContext, MessageContextExtra, MessageFactory, RuleContext } from "../types";
+import type { BranchField, CheckRule, CompositeBranch, CompositeCombine, CompositeRule, GateRule, PresenceRule, RecursionTarget, RecursiveRule, Rule, TransformRule } from "./compiled-rule";
+export interface CheckSpec<C extends MessageContextExtra> {
+    readonly code: string;
+    readonly messageFactory?: MessageFactory<C>;
+    readonly severity: IssueSeverity;
+    run(value: unknown, ctx: RuleContext): CheckOutcome;
+    describe(detail: IssueDetail, ctx: MessageContext): string;
+    buildMessageContext(detail: IssueDetail): C;
+}
+export declare function check<C extends MessageContextExtra>(spec: CheckSpec<C>): CheckRule;
+export interface PresenceSpec<C extends MessageContextExtra> {
+    readonly code: string;
+    readonly messageFactory?: MessageFactory<C>;
+    readonly severity: IssueSeverity;
+    readonly allowUndefined: boolean;
+    readonly allowNull: boolean;
+    readonly emptyStringIsMissing: boolean;
+    /**
+     * True when `null` must be JUDGED here rather than settled by presence.
+     *
+     * OPTIONAL, and false by default, because `presence()` is an API plugin
+     * AUTHORS use: making it required would break every plugin outside this
+     * repository to add a flag almost none of them want. The default is the
+     * behaviour that was always there — `.nullable()` ends the field on null.
+     * src/json-schema/ sets it, because a DOCUMENT decides whether null is
+     * allowed and `type` is not the only keyword that decides it.
+     */
+    readonly nullIsValue?: boolean;
+    describe(ctx: MessageContext): string;
+    buildMessageContext(): C;
+}
+export declare function presence<C extends MessageContextExtra>(spec: PresenceSpec<C>): PresenceRule;
+export declare function gate(code: string, shouldRun: (value: unknown, ctx: RuleContext) => boolean): GateRule;
+export declare function transform(apply: (value: unknown, ctx: RuleContext) => unknown): TransformRule;
+/** Declares a branch of a composite. */
+export declare function branch(label: string, rules: readonly Rule[], fields?: readonly BranchField[]): CompositeBranch;
+/** Declares a branch that only constrains sub-paths. */
+export declare function fieldsBranch(label: string, fields: readonly BranchField[]): CompositeBranch;
+export interface CompositeSpec<C extends MessageContextExtra> {
+    readonly code: string;
+    readonly messageFactory?: MessageFactory<C>;
+    readonly severity: IssueSeverity;
+    readonly branches: readonly CompositeBranch[];
+    readonly combine: CompositeCombine;
+    describe(detail: IssueDetail, ctx: MessageContext): string;
+    buildMessageContext(detail: IssueDetail): C;
+}
+export declare function composite<C extends MessageContextExtra>(spec: CompositeSpec<C>): CompositeRule;
+export interface RecursiveSpec<C extends MessageContextExtra> {
+    readonly code: string;
+    readonly messageFactory?: MessageFactory<C>;
+    readonly severity: IssueSeverity;
+    readonly target: RecursionTarget;
+    readonly maxDepth: number;
+    describe(detail: IssueDetail, ctx: MessageContext): string;
+    buildMessageContext(detail: IssueDetail): C;
+}
+export declare function recursive<C extends MessageContextExtra>(spec: RecursiveSpec<C>): RecursiveRule;

package/dist/plugin-kit/create-rule.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = check;
+exports.presence = presence;
+exports.gate = gate;
+exports.transform = transform;
+exports.branch = branch;
+exports.fieldsBranch = fieldsBranch;
+exports.composite = composite;
+exports.recursive = recursive;
+const rule_build_context_1 = require("./rule-build-context");
+const EMPTY_FIELDS = Object.freeze([]);
+const EMPTY_RULES = Object.freeze([]);
+function check(spec) {
+    return {
+        kind: "check",
+        code: spec.code,
+        severity: spec.severity,
+        run: (value, ctx) => spec.run(value, ctx),
+        describe: (detail, ctx) => (0, rule_build_context_1.renderMessage)(spec.messageFactory, ctx, spec.buildMessageContext(detail), spec.describe(detail, ctx)),
+    };
+}
+function presence(spec) {
+    return {
+        kind: "presence",
+        code: spec.code,
+        severity: spec.severity,
+        allowUndefined: spec.allowUndefined,
+        allowNull: spec.allowNull,
+        emptyStringIsMissing: spec.emptyStringIsMissing,
+        nullIsValue: spec.nullIsValue === true,
+        describe: (ctx) => (0, rule_build_context_1.renderMessage)(spec.messageFactory, ctx, spec.buildMessageContext(), spec.describe(ctx)),
+    };
+}
+function gate(code, shouldRun) {
+    return { kind: "gate", code, shouldRun };
+}
+function transform(apply) {
+    return { kind: "transform", apply };
+}
+/** Declares a branch of a composite. */
+function branch(label, rules, fields = EMPTY_FIELDS) {
+    return { label, rules, fields };
+}
+/** Declares a branch that only constrains sub-paths. */
+function fieldsBranch(label, fields) {
+    return { label, rules: EMPTY_RULES, fields };
+}
+function composite(spec) {
+    return {
+        kind: "composite",
+        code: spec.code,
+        severity: spec.severity,
+        branches: spec.branches,
+        combine: spec.combine,
+        describe: (detail, ctx) => (0, rule_build_context_1.renderMessage)(spec.messageFactory, ctx, spec.buildMessageContext(detail), spec.describe(detail, ctx)),
+    };
+}
+function recursive(spec) {
+    return {
+        kind: "recursive",
+        code: spec.code,
+        severity: spec.severity,
+        target: spec.target,
+        maxDepth: spec.maxDepth,
+        describe: (detail, ctx) => (0, rule_build_context_1.renderMessage)(spec.messageFactory, ctx, spec.buildMessageContext(detail), spec.describe(detail, ctx)),
+    };
+}

package/dist/plugin-kit/create-rule.mjs

@@ -0,0 +1,58 @@
+import { renderMessage } from "./rule-build-context.mjs";
+const EMPTY_FIELDS = Object.freeze([]);
+const EMPTY_RULES = Object.freeze([]);
+export function check(spec) {
+    return {
+        kind: "check",
+        code: spec.code,
+        severity: spec.severity,
+        run: (value, ctx) => spec.run(value, ctx),
+        describe: (detail, ctx) => renderMessage(spec.messageFactory, ctx, spec.buildMessageContext(detail), spec.describe(detail, ctx)),
+    };
+}
+export function presence(spec) {
+    return {
+        kind: "presence",
+        code: spec.code,
+        severity: spec.severity,
+        allowUndefined: spec.allowUndefined,
+        allowNull: spec.allowNull,
+        emptyStringIsMissing: spec.emptyStringIsMissing,
+        nullIsValue: spec.nullIsValue === true,
+        describe: (ctx) => renderMessage(spec.messageFactory, ctx, spec.buildMessageContext(), spec.describe(ctx)),
+    };
+}
+export function gate(code, shouldRun) {
+    return { kind: "gate", code, shouldRun };
+}
+export function transform(apply) {
+    return { kind: "transform", apply };
+}
+/** Declares a branch of a composite. */
+export function branch(label, rules, fields = EMPTY_FIELDS) {
+    return { label, rules, fields };
+}
+/** Declares a branch that only constrains sub-paths. */
+export function fieldsBranch(label, fields) {
+    return { label, rules: EMPTY_RULES, fields };
+}
+export function composite(spec) {
+    return {
+        kind: "composite",
+        code: spec.code,
+        severity: spec.severity,
+        branches: spec.branches,
+        combine: spec.combine,
+        describe: (detail, ctx) => renderMessage(spec.messageFactory, ctx, spec.buildMessageContext(detail), spec.describe(detail, ctx)),
+    };
+}
+export function recursive(spec) {
+    return {
+        kind: "recursive",
+        code: spec.code,
+        severity: spec.severity,
+        target: spec.target,
+        maxDepth: spec.maxDepth,
+        describe: (detail, ctx) => renderMessage(spec.messageFactory, ctx, spec.buildMessageContext(detail), spec.describe(detail, ctx)),
+    };
+}