@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/compile/declared-child-keys.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROOT_PATH = void 0;
+exports.indexDeclaredChildKeys = indexDeclaredChildKeys;
+// ===========================================================================
+// L4  src/compile/declared-child-keys.ts
+// Fills RuleBuildContext.declaredSiblingKeys.
+//
+// The index is derived from the declared PATH STRINGS and from nothing else:
+// no value is inspected, no plugin is consulted, and no plugin is known by
+// name. objectAdditionalProperties defaults to this list, and an explicit
+// `allowedProperties` argument wins over it.
+//
+// Every array is FROZEN. `readonly` is erased at run time, and an unfrozen
+// shared array was in fact mutated by a plugin's build() in the proof, which
+// silently changed what a LATER field considered a declared key.
+// ===========================================================================
+const parse_field_path_1 = require("../path/parse-field-path");
+/** The parent path of a top-level declaration. Not a legal declared path. */
+exports.ROOT_PATH = "";
+const NO_KEYS = Object.freeze([]);
+/**
+ * Every path is parsed by the ONE parser, so a malformed declaration is
+ * rejected here at build time rather than producing an empty key list that a
+ * plugin would then read as "this object declares nothing".
+ *
+ * Ancestors count. `user.profile.name` alone declares `profile` under `user`
+ * and `name` under `user.profile`, because both facts are visible in the
+ * string. A wildcard contributes no key: the members of `items[*]` have an
+ * index, not a name, which is exactly what leafKeyOf's null means.
+ */
+function indexDeclaredChildKeys(paths) {
+    const keysByParent = new Map();
+    for (const path of paths)
+        recordDeclaredPath(path, keysByParent);
+    const frozen = new Map();
+    for (const [parentPath, keys] of keysByParent) {
+        frozen.set(parentPath, Object.freeze(keys.slice()));
+    }
+    return (parentPath) => frozen.get(parentPath) ?? NO_KEYS;
+}
+/**
+ * ROOT_PATH is the SUBJECT itself, not a child of anything, so it contributes
+ * no key — and it must not reach the parser, which refuses the empty string.
+ * Asking `childKeysOf(ROOT_PATH)` still answers the top-level declared keys,
+ * which is what a root-level `additionalProperties: false` needs.
+ */
+function recordDeclaredPath(path, into) {
+    if (path === exports.ROOT_PATH)
+        return;
+    let prefix = exports.ROOT_PATH;
+    for (const segment of (0, parse_field_path_1.parseFieldPath)(path)) {
+        if (segment.kind === "each") {
+            prefix += "[*]";
+            continue;
+        }
+        appendChildKey(into, prefix, segment.key);
+        prefix = prefix === exports.ROOT_PATH ? segment.key : `${prefix}.${segment.key}`;
+    }
+}
+/** First declaration wins on order; a repeated key is recorded once. */
+function appendChildKey(into, parentPath, key) {
+    const declared = into.get(parentPath);
+    if (declared === undefined) {
+        into.set(parentPath, [key]);
+        return;
+    }
+    if (!declared.includes(key))
+        declared.push(key);
+}

package/dist/compile/declared-child-keys.mjs

@@ -0,0 +1,66 @@
+// ===========================================================================
+// L4  src/compile/declared-child-keys.ts
+// Fills RuleBuildContext.declaredSiblingKeys.
+//
+// The index is derived from the declared PATH STRINGS and from nothing else:
+// no value is inspected, no plugin is consulted, and no plugin is known by
+// name. objectAdditionalProperties defaults to this list, and an explicit
+// `allowedProperties` argument wins over it.
+//
+// Every array is FROZEN. `readonly` is erased at run time, and an unfrozen
+// shared array was in fact mutated by a plugin's build() in the proof, which
+// silently changed what a LATER field considered a declared key.
+// ===========================================================================
+import { parseFieldPath } from "../path/parse-field-path.mjs";
+/** The parent path of a top-level declaration. Not a legal declared path. */
+export const ROOT_PATH = "";
+const NO_KEYS = Object.freeze([]);
+/**
+ * Every path is parsed by the ONE parser, so a malformed declaration is
+ * rejected here at build time rather than producing an empty key list that a
+ * plugin would then read as "this object declares nothing".
+ *
+ * Ancestors count. `user.profile.name` alone declares `profile` under `user`
+ * and `name` under `user.profile`, because both facts are visible in the
+ * string. A wildcard contributes no key: the members of `items[*]` have an
+ * index, not a name, which is exactly what leafKeyOf's null means.
+ */
+export function indexDeclaredChildKeys(paths) {
+    const keysByParent = new Map();
+    for (const path of paths)
+        recordDeclaredPath(path, keysByParent);
+    const frozen = new Map();
+    for (const [parentPath, keys] of keysByParent) {
+        frozen.set(parentPath, Object.freeze(keys.slice()));
+    }
+    return (parentPath) => frozen.get(parentPath) ?? NO_KEYS;
+}
+/**
+ * ROOT_PATH is the SUBJECT itself, not a child of anything, so it contributes
+ * no key — and it must not reach the parser, which refuses the empty string.
+ * Asking `childKeysOf(ROOT_PATH)` still answers the top-level declared keys,
+ * which is what a root-level `additionalProperties: false` needs.
+ */
+function recordDeclaredPath(path, into) {
+    if (path === ROOT_PATH)
+        return;
+    let prefix = ROOT_PATH;
+    for (const segment of parseFieldPath(path)) {
+        if (segment.kind === "each") {
+            prefix += "[*]";
+            continue;
+        }
+        appendChildKey(into, prefix, segment.key);
+        prefix = prefix === ROOT_PATH ? segment.key : `${prefix}.${segment.key}`;
+    }
+}
+/** First declaration wins on order; a repeated key is recorded once. */
+function appendChildKey(into, parentPath, key) {
+    const declared = into.get(parentPath);
+    if (declared === undefined) {
+        into.set(parentPath, [key]);
+        return;
+    }
+    if (!declared.includes(key))
+        declared.push(key);
+}

package/dist/compile/group-array-fields.d.ts

@@ -0,0 +1,39 @@
+import type { PathSegment } from "../path/path-segment.types";
+import type { Rule } from "../plugin-kit/compiled-rule";
+/**
+ * One declaration whose template is RELATIVE to the subject being compiled:
+ * the root for a top-level field, one array element inside an array node, the
+ * branch subject inside a composite.
+ *
+ * `fieldPath` is the path the user actually declared and is carried only so a
+ * build-time failure can name it. It is never re-parsed.
+ */
+export interface RelativeDeclaration {
+    readonly template: readonly PathSegment[];
+    readonly rules: readonly Rule[];
+    readonly fieldPath: string;
+    readonly defaultOf: ((root: unknown) => unknown) | null;
+    readonly applyDefaultToNull: boolean;
+}
+/** Every declaration that reaches through the same array, plus that array. */
+export interface ArrayFieldGroup {
+    /** The array's own template, relative to the enclosing subject. Empty when
+     *  the subject IS the array, which is how `matrix[*][*]` reaches two levels. */
+    readonly template: readonly PathSegment[];
+    /** Templates relative to ONE ELEMENT. May still contain wildcards. */
+    readonly members: readonly RelativeDeclaration[];
+}
+export interface GroupedFields {
+    /** Declarations with no wildcard left: these compile to CompiledFields. */
+    readonly direct: readonly RelativeDeclaration[];
+    /** In first-declaration order, so the plan does not depend on Map internals. */
+    readonly arrays: readonly ArrayFieldGroup[];
+}
+/**
+ * The array a declaration reaches through is its prefix up to the first `[*]`,
+ * and the element template is everything after it. Two declarations belong to
+ * the same array exactly when those prefixes render identically — which is why
+ * the key is built by the ONE formatter and never by string surgery on the
+ * declared path.
+ */
+export declare function groupArrayFields(declarations: readonly RelativeDeclaration[]): GroupedFields;

package/dist/compile/group-array-fields.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupArrayFields = groupArrayFields;
+const parse_field_path_1 = require("../path/parse-field-path");
+const NO_GROUPS = Object.freeze([]);
+/** -1 when the template addresses a single value. */
+function findFirstWildcard(template) {
+    return template.findIndex((segment) => segment.kind === "each");
+}
+/**
+ * The array a declaration reaches through is its prefix up to the first `[*]`,
+ * and the element template is everything after it. Two declarations belong to
+ * the same array exactly when those prefixes render identically — which is why
+ * the key is built by the ONE formatter and never by string surgery on the
+ * declared path.
+ */
+function groupArrayFields(declarations) {
+    const direct = [];
+    const drafts = new Map();
+    const groupOrder = [];
+    for (const declaration of declarations) {
+        const wildcardAt = findFirstWildcard(declaration.template);
+        if (wildcardAt < 0) {
+            direct.push(declaration);
+            continue;
+        }
+        const template = Object.freeze(declaration.template.slice(0, wildcardAt));
+        const key = (0, parse_field_path_1.formatFieldPath)(template);
+        const draft = drafts.get(key);
+        if (draft === undefined) {
+            drafts.set(key, {
+                template,
+                members: [toElementMember(declaration, wildcardAt)],
+            });
+            groupOrder.push(key);
+            continue;
+        }
+        draft.members.push(toElementMember(declaration, wildcardAt));
+    }
+    return Object.freeze({
+        direct: Object.freeze(direct),
+        arrays: freezeGroups(groupOrder, drafts),
+    });
+}
+/** The same declaration, re-based on one element of the array it named. */
+function toElementMember(declaration, wildcardAt) {
+    return Object.freeze({
+        ...declaration,
+        template: Object.freeze(declaration.template.slice(wildcardAt + 1)),
+    });
+}
+function freezeGroups(groupOrder, drafts) {
+    if (groupOrder.length === 0)
+        return NO_GROUPS;
+    const groups = [];
+    for (const key of groupOrder) {
+        const draft = drafts.get(key);
+        if (draft === undefined)
+            continue;
+        groups.push(Object.freeze({
+            template: draft.template,
+            members: Object.freeze(draft.members.slice()),
+        }));
+    }
+    return Object.freeze(groups);
+}

package/dist/compile/group-array-fields.mjs

@@ -0,0 +1,63 @@
+import { formatFieldPath } from "../path/parse-field-path.mjs";
+const NO_GROUPS = Object.freeze([]);
+/** -1 when the template addresses a single value. */
+function findFirstWildcard(template) {
+    return template.findIndex((segment) => segment.kind === "each");
+}
+/**
+ * The array a declaration reaches through is its prefix up to the first `[*]`,
+ * and the element template is everything after it. Two declarations belong to
+ * the same array exactly when those prefixes render identically — which is why
+ * the key is built by the ONE formatter and never by string surgery on the
+ * declared path.
+ */
+export function groupArrayFields(declarations) {
+    const direct = [];
+    const drafts = new Map();
+    const groupOrder = [];
+    for (const declaration of declarations) {
+        const wildcardAt = findFirstWildcard(declaration.template);
+        if (wildcardAt < 0) {
+            direct.push(declaration);
+            continue;
+        }
+        const template = Object.freeze(declaration.template.slice(0, wildcardAt));
+        const key = formatFieldPath(template);
+        const draft = drafts.get(key);
+        if (draft === undefined) {
+            drafts.set(key, {
+                template,
+                members: [toElementMember(declaration, wildcardAt)],
+            });
+            groupOrder.push(key);
+            continue;
+        }
+        draft.members.push(toElementMember(declaration, wildcardAt));
+    }
+    return Object.freeze({
+        direct: Object.freeze(direct),
+        arrays: freezeGroups(groupOrder, drafts),
+    });
+}
+/** The same declaration, re-based on one element of the array it named. */
+function toElementMember(declaration, wildcardAt) {
+    return Object.freeze({
+        ...declaration,
+        template: Object.freeze(declaration.template.slice(wildcardAt + 1)),
+    });
+}
+function freezeGroups(groupOrder, drafts) {
+    if (groupOrder.length === 0)
+        return NO_GROUPS;
+    const groups = [];
+    for (const key of groupOrder) {
+        const draft = drafts.get(key);
+        if (draft === undefined)
+            continue;
+        groups.push(Object.freeze({
+            template: draft.template,
+            members: Object.freeze(draft.members.slice()),
+        }));
+    }
+    return Object.freeze(groups);
+}

package/dist/compile/index.d.ts

@@ -0,0 +1,18 @@
+export type { ArrayNode, CompiledCheck, CompiledField, ConditionalPresence, FieldDeclaration, PlanRef, PresencePolicy, RecursionPolicy, ValidationPlan, } from "./validation-plan.types";
+export type { BranchExecutor } from "./branch-executor.port";
+export { ROOT_PATH, indexDeclaredChildKeys } from "./declared-child-keys";
+export type { DeclaredChildKeysReader } from "./declared-child-keys";
+export { OPEN_PRESENCE, OPEN_PRESENCE_CODE, resolvePresence, } from "./resolve-presence";
+export { NO_PRESENCE_OVERRIDES, resolveConditionalPresence, } from "./resolve-conditional-presence";
+export { UnknownRuleKindError, splitRulesByKind } from "./split-rules-by-kind";
+export type { RulesByKind } from "./split-rules-by-kind";
+export { ConflictingRecursionError, resolveRecursion, } from "./resolve-recursion";
+export { APPLIES_DEFAULT_TO_NULL_BY_DEFAULT, compileField, compileFieldDeclaration, } from "./compile-field";
+export type { CompositeEraser, FieldCompileRequest } from "./compile-field";
+export { groupArrayFields } from "./group-array-fields";
+export type { ArrayFieldGroup, GroupedFields, RelativeDeclaration, } from "./group-array-fields";
+export { compileArrayNode, compileRelativeDeclaration, } from "./compile-array-node";
+export type { NodeCompileContext } from "./compile-array-node";
+export { compileComposite } from "./compile-composite";
+export type { BranchPlanCompiler, CompositeCompileContext, } from "./compile-composite";
+export { UnresolvedPlanError, compileSchema } from "./compile-schema";

package/dist/compile/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileSchema = exports.UnresolvedPlanError = exports.compileComposite = exports.compileRelativeDeclaration = exports.compileArrayNode = exports.groupArrayFields = exports.compileFieldDeclaration = exports.compileField = exports.APPLIES_DEFAULT_TO_NULL_BY_DEFAULT = exports.resolveRecursion = exports.ConflictingRecursionError = exports.splitRulesByKind = exports.UnknownRuleKindError = exports.resolveConditionalPresence = exports.NO_PRESENCE_OVERRIDES = exports.resolvePresence = exports.OPEN_PRESENCE_CODE = exports.OPEN_PRESENCE = exports.indexDeclaredChildKeys = exports.ROOT_PATH = void 0;
+var declared_child_keys_1 = require("./declared-child-keys");
+Object.defineProperty(exports, "ROOT_PATH", { enumerable: true, get: function () { return declared_child_keys_1.ROOT_PATH; } });
+Object.defineProperty(exports, "indexDeclaredChildKeys", { enumerable: true, get: function () { return declared_child_keys_1.indexDeclaredChildKeys; } });
+var resolve_presence_1 = require("./resolve-presence");
+Object.defineProperty(exports, "OPEN_PRESENCE", { enumerable: true, get: function () { return resolve_presence_1.OPEN_PRESENCE; } });
+Object.defineProperty(exports, "OPEN_PRESENCE_CODE", { enumerable: true, get: function () { return resolve_presence_1.OPEN_PRESENCE_CODE; } });
+Object.defineProperty(exports, "resolvePresence", { enumerable: true, get: function () { return resolve_presence_1.resolvePresence; } });
+var resolve_conditional_presence_1 = require("./resolve-conditional-presence");
+Object.defineProperty(exports, "NO_PRESENCE_OVERRIDES", { enumerable: true, get: function () { return resolve_conditional_presence_1.NO_PRESENCE_OVERRIDES; } });
+Object.defineProperty(exports, "resolveConditionalPresence", { enumerable: true, get: function () { return resolve_conditional_presence_1.resolveConditionalPresence; } });
+var split_rules_by_kind_1 = require("./split-rules-by-kind");
+Object.defineProperty(exports, "UnknownRuleKindError", { enumerable: true, get: function () { return split_rules_by_kind_1.UnknownRuleKindError; } });
+Object.defineProperty(exports, "splitRulesByKind", { enumerable: true, get: function () { return split_rules_by_kind_1.splitRulesByKind; } });
+var resolve_recursion_1 = require("./resolve-recursion");
+Object.defineProperty(exports, "ConflictingRecursionError", { enumerable: true, get: function () { return resolve_recursion_1.ConflictingRecursionError; } });
+Object.defineProperty(exports, "resolveRecursion", { enumerable: true, get: function () { return resolve_recursion_1.resolveRecursion; } });
+var compile_field_1 = require("./compile-field");
+Object.defineProperty(exports, "APPLIES_DEFAULT_TO_NULL_BY_DEFAULT", { enumerable: true, get: function () { return compile_field_1.APPLIES_DEFAULT_TO_NULL_BY_DEFAULT; } });
+Object.defineProperty(exports, "compileField", { enumerable: true, get: function () { return compile_field_1.compileField; } });
+Object.defineProperty(exports, "compileFieldDeclaration", { enumerable: true, get: function () { return compile_field_1.compileFieldDeclaration; } });
+var group_array_fields_1 = require("./group-array-fields");
+Object.defineProperty(exports, "groupArrayFields", { enumerable: true, get: function () { return group_array_fields_1.groupArrayFields; } });
+var compile_array_node_1 = require("./compile-array-node");
+Object.defineProperty(exports, "compileArrayNode", { enumerable: true, get: function () { return compile_array_node_1.compileArrayNode; } });
+Object.defineProperty(exports, "compileRelativeDeclaration", { enumerable: true, get: function () { return compile_array_node_1.compileRelativeDeclaration; } });
+var compile_composite_1 = require("./compile-composite");
+Object.defineProperty(exports, "compileComposite", { enumerable: true, get: function () { return compile_composite_1.compileComposite; } });
+var compile_schema_1 = require("./compile-schema");
+Object.defineProperty(exports, "UnresolvedPlanError", { enumerable: true, get: function () { return compile_schema_1.UnresolvedPlanError; } });
+Object.defineProperty(exports, "compileSchema", { enumerable: true, get: function () { return compile_schema_1.compileSchema; } });

package/dist/compile/index.mjs

@@ -0,0 +1,10 @@
+export { ROOT_PATH, indexDeclaredChildKeys } from "./declared-child-keys.mjs";
+export { OPEN_PRESENCE, OPEN_PRESENCE_CODE, resolvePresence, } from "./resolve-presence.mjs";
+export { NO_PRESENCE_OVERRIDES, resolveConditionalPresence, } from "./resolve-conditional-presence.mjs";
+export { UnknownRuleKindError, splitRulesByKind } from "./split-rules-by-kind.mjs";
+export { ConflictingRecursionError, resolveRecursion, } from "./resolve-recursion.mjs";
+export { APPLIES_DEFAULT_TO_NULL_BY_DEFAULT, compileField, compileFieldDeclaration, } from "./compile-field.mjs";
+export { groupArrayFields } from "./group-array-fields.mjs";
+export { compileArrayNode, compileRelativeDeclaration, } from "./compile-array-node.mjs";
+export { compileComposite } from "./compile-composite.mjs";
+export { UnresolvedPlanError, compileSchema } from "./compile-schema.mjs";

package/dist/compile/resolve-conditional-presence.d.ts

@@ -0,0 +1,5 @@
+import type { ConditionalPresenceRule } from "../plugin-kit/compiled-rule";
+import type { ConditionalPresence } from "./validation-plan.types";
+/** Shared and frozen: a field with no conditional rule allocates nothing. */
+export declare const NO_PRESENCE_OVERRIDES: readonly ConditionalPresence[];
+export declare function resolveConditionalPresence(rules: readonly ConditionalPresenceRule[]): readonly ConditionalPresence[];

package/dist/compile/resolve-conditional-presence.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_PRESENCE_OVERRIDES = void 0;
+exports.resolveConditionalPresence = resolveConditionalPresence;
+/** Shared and frozen: a field with no conditional rule allocates nothing. */
+exports.NO_PRESENCE_OVERRIDES = Object.freeze([]);
+function resolveConditionalPresence(rules) {
+    if (rules.length === 0)
+        return exports.NO_PRESENCE_OVERRIDES;
+    return Object.freeze(rules.map(compileOneOverride));
+}
+function compileOneOverride(rule) {
+    const override = {
+        // Stored BY IDENTITY. Re-wrapping the user's predicate would put a layer
+        // between it and the RuleContext members the array runner fills in.
+        when: rule.when,
+        whenMet: toPolicy(rule, rule.whenMet),
+        whenUnmet: toPolicy(rule, rule.whenUnmet),
+    };
+    return Object.freeze(override);
+}
+/**
+ * Both sides report under the SAME code, severity and message: a conditional
+ * presence rule is one rule with one identity, and only one of its sides can
+ * ever refuse a value anyway.
+ */
+function toPolicy(rule, allowance) {
+    if (allowance === null)
+        return null;
+    const policy = {
+        code: rule.code,
+        severity: rule.severity,
+        allowUndefined: allowance.allowUndefined,
+        allowNull: allowance.allowNull,
+        emptyStringIsMissing: allowance.emptyStringIsMissing,
+        nullIsValue: allowance.nullIsValue === true,
+        // Wrapped rather than aliased, so a `describe` written as an object
+        // method keeps its receiver.
+        describe: (messageContext) => rule.describe(messageContext),
+    };
+    return Object.freeze(policy);
+}

package/dist/compile/resolve-conditional-presence.mjs

@@ -0,0 +1,38 @@
+/** Shared and frozen: a field with no conditional rule allocates nothing. */
+export const NO_PRESENCE_OVERRIDES = Object.freeze([]);
+export function resolveConditionalPresence(rules) {
+    if (rules.length === 0)
+        return NO_PRESENCE_OVERRIDES;
+    return Object.freeze(rules.map(compileOneOverride));
+}
+function compileOneOverride(rule) {
+    const override = {
+        // Stored BY IDENTITY. Re-wrapping the user's predicate would put a layer
+        // between it and the RuleContext members the array runner fills in.
+        when: rule.when,
+        whenMet: toPolicy(rule, rule.whenMet),
+        whenUnmet: toPolicy(rule, rule.whenUnmet),
+    };
+    return Object.freeze(override);
+}
+/**
+ * Both sides report under the SAME code, severity and message: a conditional
+ * presence rule is one rule with one identity, and only one of its sides can
+ * ever refuse a value anyway.
+ */
+function toPolicy(rule, allowance) {
+    if (allowance === null)
+        return null;
+    const policy = {
+        code: rule.code,
+        severity: rule.severity,
+        allowUndefined: allowance.allowUndefined,
+        allowNull: allowance.allowNull,
+        emptyStringIsMissing: allowance.emptyStringIsMissing,
+        nullIsValue: allowance.nullIsValue === true,
+        // Wrapped rather than aliased, so a `describe` written as an object
+        // method keeps its receiver.
+        describe: (messageContext) => rule.describe(messageContext),
+    };
+    return Object.freeze(policy);
+}

package/dist/compile/resolve-presence.d.ts

@@ -0,0 +1,6 @@
+import type { PresenceRule } from "../plugin-kit/compiled-rule";
+import type { PresencePolicy } from "./validation-plan.types";
+/** The code of a policy that can never fail, and so can never be emitted. */
+export declare const OPEN_PRESENCE_CODE = "presence";
+export declare const OPEN_PRESENCE: PresencePolicy;
+export declare function resolvePresence(rules: readonly PresenceRule[]): PresencePolicy;

package/dist/compile/resolve-presence.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPEN_PRESENCE = exports.OPEN_PRESENCE_CODE = void 0;
+exports.resolvePresence = resolvePresence;
+/** The code of a policy that can never fail, and so can never be emitted. */
+exports.OPEN_PRESENCE_CODE = "presence";
+const OPEN_SEVERITY = "error";
+const OPEN_POLICY = {
+    code: exports.OPEN_PRESENCE_CODE,
+    severity: OPEN_SEVERITY,
+    allowUndefined: true,
+    allowNull: true,
+    emptyStringIsMissing: false,
+    nullIsValue: false,
+    describe: () => "This field declares no presence rule",
+};
+exports.OPEN_PRESENCE = Object.freeze(OPEN_POLICY);
+function resolvePresence(rules) {
+    const strictest = selectStrictestPresence(rules);
+    if (strictest === undefined)
+        return exports.OPEN_PRESENCE;
+    const policy = {
+        code: strictest.code,
+        severity: strictest.severity,
+        allowUndefined: rules.some((rule) => rule.allowUndefined),
+        allowNull: rules.some((rule) => rule.allowNull),
+        emptyStringIsMissing: rules.some((rule) => rule.emptyStringIsMissing),
+        // One rule saying "null is a value here" is enough: the checks then run
+        // and decide, which is strictly more judgement, never less.
+        nullIsValue: rules.some((rule) => rule.nullIsValue === true),
+        describe: (ctx) => strictest.describe(ctx),
+    };
+    return Object.freeze(policy);
+}
+/** How much this one rule forbids. Order-free, so the maximum is too. */
+function countRestrictions(rule) {
+    return ((rule.allowUndefined ? 0 : 1) +
+        (rule.allowNull ? 0 : 1) +
+        (rule.emptyStringIsMissing ? 1 : 0));
+}
+/**
+ * The identity a failure is reported under: the rule that forbids the most,
+ * ties broken by the lexicographically smaller code.
+ *
+ * Tie-breaking on the CODE rather than on declaration order is what keeps the
+ * whole policy — not merely its three flags — independent of the order the
+ * rules arrived in. `.optional().nullable()` and `.nullable().optional()` are
+ * deep-equal, which is the property the tests assert.
+ */
+function selectStrictestPresence(rules) {
+    let strictest;
+    for (const rule of rules) {
+        if (strictest === undefined) {
+            strictest = rule;
+            continue;
+        }
+        const difference = countRestrictions(rule) - countRestrictions(strictest);
+        if (difference > 0 || (difference === 0 && rule.code < strictest.code)) {
+            strictest = rule;
+        }
+    }
+    return strictest;
+}

package/dist/compile/resolve-presence.mjs

@@ -0,0 +1,59 @@
+/** The code of a policy that can never fail, and so can never be emitted. */
+export const OPEN_PRESENCE_CODE = "presence";
+const OPEN_SEVERITY = "error";
+const OPEN_POLICY = {
+    code: OPEN_PRESENCE_CODE,
+    severity: OPEN_SEVERITY,
+    allowUndefined: true,
+    allowNull: true,
+    emptyStringIsMissing: false,
+    nullIsValue: false,
+    describe: () => "This field declares no presence rule",
+};
+export const OPEN_PRESENCE = Object.freeze(OPEN_POLICY);
+export function resolvePresence(rules) {
+    const strictest = selectStrictestPresence(rules);
+    if (strictest === undefined)
+        return OPEN_PRESENCE;
+    const policy = {
+        code: strictest.code,
+        severity: strictest.severity,
+        allowUndefined: rules.some((rule) => rule.allowUndefined),
+        allowNull: rules.some((rule) => rule.allowNull),
+        emptyStringIsMissing: rules.some((rule) => rule.emptyStringIsMissing),
+        // One rule saying "null is a value here" is enough: the checks then run
+        // and decide, which is strictly more judgement, never less.
+        nullIsValue: rules.some((rule) => rule.nullIsValue === true),
+        describe: (ctx) => strictest.describe(ctx),
+    };
+    return Object.freeze(policy);
+}
+/** How much this one rule forbids. Order-free, so the maximum is too. */
+function countRestrictions(rule) {
+    return ((rule.allowUndefined ? 0 : 1) +
+        (rule.allowNull ? 0 : 1) +
+        (rule.emptyStringIsMissing ? 1 : 0));
+}
+/**
+ * The identity a failure is reported under: the rule that forbids the most,
+ * ties broken by the lexicographically smaller code.
+ *
+ * Tie-breaking on the CODE rather than on declaration order is what keeps the
+ * whole policy — not merely its three flags — independent of the order the
+ * rules arrived in. `.optional().nullable()` and `.nullable().optional()` are
+ * deep-equal, which is the property the tests assert.
+ */
+function selectStrictestPresence(rules) {
+    let strictest;
+    for (const rule of rules) {
+        if (strictest === undefined) {
+            strictest = rule;
+            continue;
+        }
+        const difference = countRestrictions(rule) - countRestrictions(strictest);
+        if (difference > 0 || (difference === 0 && rule.code < strictest.code)) {
+            strictest = rule;
+        }
+    }
+    return strictest;
+}

package/dist/compile/resolve-recursion.d.ts

@@ -0,0 +1,10 @@
+import type { RecursiveRule } from "../plugin-kit/compiled-rule";
+import type { PlanRef, RecursionPolicy } from "./validation-plan.types";
+/** Two recursive rules on one field cannot both describe the re-entry. */
+export declare class ConflictingRecursionError extends Error {
+    readonly fieldPath: string;
+    readonly codes: readonly string[];
+    constructor(fieldPath: string, codes: readonly string[]);
+}
+/** null for every field that declared no RecursiveRule, i.e. almost all. */
+export declare function resolveRecursion(rules: readonly RecursiveRule[], plan: PlanRef, fieldPath: string): RecursionPolicy | null;

package/dist/compile/resolve-recursion.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictingRecursionError = void 0;
+exports.resolveRecursion = resolveRecursion;
+/** Two recursive rules on one field cannot both describe the re-entry. */
+class ConflictingRecursionError extends Error {
+    constructor(fieldPath, codes) {
+        super(`The field "${fieldPath}" declares ${codes.length} recursive rules ` +
+            `(${codes.join(", ")}); a field re-enters a plan at most once.`);
+        this.fieldPath = fieldPath;
+        this.codes = codes;
+        this.name = "ConflictingRecursionError";
+    }
+}
+exports.ConflictingRecursionError = ConflictingRecursionError;
+/** null for every field that declared no RecursiveRule, i.e. almost all. */
+function resolveRecursion(rules, plan, fieldPath) {
+    const only = rules[0];
+    if (only === undefined)
+        return null;
+    if (rules.length > 1) {
+        throw new ConflictingRecursionError(fieldPath, rules.map((rule) => rule.code));
+    }
+    const policy = {
+        code: only.code,
+        severity: only.severity,
+        target: only.target,
+        maxDepth: only.maxDepth,
+        plan,
+        describe: (detail, ctx) => only.describe(detail, ctx),
+    };
+    return Object.freeze(policy);
+}