@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/runtime/create-validator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROOT_MISSING_MESSAGE = exports.ROOT_MISSING_CODE = void 0;
+exports.hasRejectingIssue = hasRejectingIssue;
+exports.createValidator = createValidator;
+const index_stack_1 = require("./index-stack");
+const issue_sink_1 = require("./issue-sink");
+const output_writer_1 = require("./output-writer");
+const run_recursion_1 = require("./run-recursion");
+const run_plan_1 = require("./run-plan");
+/** The legacy root short-circuit, wording included (validator-factory.ts:498). */
+exports.ROOT_MISSING_CODE = "REQUIRED";
+exports.ROOT_MISSING_MESSAGE = "Value is required";
+/**
+ * A null or undefined subject fails before the plan runs. Without it every
+ * reader would answer `undefined`, OPEN_PRESENCE would permit every absence,
+ * and `validate(null)` would report success for a schema that declares nothing
+ * required.
+ */
+function rejectMissingRoot() {
+    return {
+        valid: false,
+        issues: Object.freeze([
+            Object.freeze({
+                path: "",
+                code: exports.ROOT_MISSING_CODE,
+                message: exports.ROOT_MISSING_MESSAGE,
+                severity: "error",
+            }),
+        ]),
+    };
+}
+/**
+ * Severity decides validity, and nothing else does. An `info` or `warning`
+ * issue is still an issue — the sink counted it and abortEarly saw it — but it
+ * does not reject the value, which is the only reason ValidationSuccess carries
+ * an `issues` list at all.
+ */
+function hasRejectingIssue(issues) {
+    return issues.some((issue) => issue.severity === "error");
+}
+function runRoot(plan, value, options, targets, shouldApplyTransforms) {
+    if (value === null || value === undefined)
+        return rejectMissingRoot();
+    const sink = new issue_sink_1.IssueSink((0, issue_sink_1.resolveAbortPolicy)(options));
+    const output = (0, run_plan_1.runPlan)(plan, value, {
+        root: value,
+        sink,
+        indices: new index_stack_1.IndexStack(),
+        shouldApplyTransforms,
+        runRecursion: (0, run_recursion_1.createRecursionRunner)({
+            root: value,
+            sink,
+            external: options?.external,
+        }),
+        external: options?.external,
+    }, targets);
+    const issues = Object.freeze(sink.issues);
+    if (hasRejectingIssue(issues))
+        return { valid: false, issues };
+    return { valid: true, data: output, issues };
+}
+function createValidator(plan) {
+    const parseTargets = (0, output_writer_1.createPlanWriteTargets)(plan);
+    const shouldWriteOutput = parseTargets !== null;
+    return {
+        validate: (value, options) => runRoot(plan, value, options, output_writer_1.NO_WRITE_TARGETS, false),
+        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? output_writer_1.NO_WRITE_TARGETS, shouldWriteOutput),
+    };
+}

package/dist/runtime/create-validator.mjs

@@ -0,0 +1,65 @@
+import { IndexStack } from "./index-stack.mjs";
+import { IssueSink, resolveAbortPolicy } from "./issue-sink.mjs";
+import { NO_WRITE_TARGETS, createPlanWriteTargets } from "./output-writer.mjs";
+import { createRecursionRunner } from "./run-recursion.mjs";
+import { runPlan } from "./run-plan.mjs";
+/** The legacy root short-circuit, wording included (validator-factory.ts:498). */
+export const ROOT_MISSING_CODE = "REQUIRED";
+export const ROOT_MISSING_MESSAGE = "Value is required";
+/**
+ * A null or undefined subject fails before the plan runs. Without it every
+ * reader would answer `undefined`, OPEN_PRESENCE would permit every absence,
+ * and `validate(null)` would report success for a schema that declares nothing
+ * required.
+ */
+function rejectMissingRoot() {
+    return {
+        valid: false,
+        issues: Object.freeze([
+            Object.freeze({
+                path: "",
+                code: ROOT_MISSING_CODE,
+                message: ROOT_MISSING_MESSAGE,
+                severity: "error",
+            }),
+        ]),
+    };
+}
+/**
+ * Severity decides validity, and nothing else does. An `info` or `warning`
+ * issue is still an issue — the sink counted it and abortEarly saw it — but it
+ * does not reject the value, which is the only reason ValidationSuccess carries
+ * an `issues` list at all.
+ */
+export function hasRejectingIssue(issues) {
+    return issues.some((issue) => issue.severity === "error");
+}
+function runRoot(plan, value, options, targets, shouldApplyTransforms) {
+    if (value === null || value === undefined)
+        return rejectMissingRoot();
+    const sink = new IssueSink(resolveAbortPolicy(options));
+    const output = runPlan(plan, value, {
+        root: value,
+        sink,
+        indices: new IndexStack(),
+        shouldApplyTransforms,
+        runRecursion: createRecursionRunner({
+            root: value,
+            sink,
+            external: options?.external,
+        }),
+        external: options?.external,
+    }, targets);
+    const issues = Object.freeze(sink.issues);
+    if (hasRejectingIssue(issues))
+        return { valid: false, issues };
+    return { valid: true, data: output, issues };
+}
+export function createValidator(plan) {
+    const parseTargets = createPlanWriteTargets(plan);
+    const shouldWriteOutput = parseTargets !== null;
+    return {
+        validate: (value, options) => runRoot(plan, value, options, NO_WRITE_TARGETS, false),
+        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? NO_WRITE_TARGETS, shouldWriteOutput),
+    };
+}

package/dist/runtime/decide-presence.d.ts

@@ -0,0 +1,5 @@
+import type { RuleContext } from "../types";
+import type { CompiledField } from "../compile/validation-plan.types";
+import type { IssueSink } from "./issue-sink";
+/** True when the field should go on to its gates, checks and transforms. */
+export declare function decidePresence(field: CompiledField, value: unknown, ruleContext: RuleContext, sink: IssueSink): boolean;

package/dist/runtime/decide-presence.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decidePresence = decidePresence;
+const create_issue_1 = require("./create-issue");
+/** True when the field should go on to its gates, checks and transforms. */
+function decidePresence(field, value, ruleContext, sink) {
+    const policy = selectPolicy(field, ruleContext);
+    const isMissing = value === undefined || (policy.emptyStringIsMissing && value === "");
+    // null continues to the checks when the subject says null is a value.
+    if (!isMissing && (value !== null || policy.nullIsValue))
+        return true;
+    const isAllowed = isMissing ? policy.allowUndefined : policy.allowNull;
+    return reportUnlessAllowed(policy, isAllowed, value, ruleContext.path, sink);
+}
+/**
+ * The merged static policy, then every conditional override that applies, in
+ * declaration order — so a later `.optionalIf(...)` wins over an earlier
+ * `.requiredIf(...)` on the same field, the way a later assignment wins.
+ *
+ * The empty case costs one length test and returns the policy the compiler
+ * already built. Nothing here inspects a rule or builds a policy.
+ */
+function selectPolicy(field, ruleContext) {
+    const overrides = field.presenceOverrides;
+    if (overrides.length === 0)
+        return field.presence;
+    let policy = field.presence;
+    for (const override of overrides) {
+        const side = override.when(ruleContext.root, ruleContext.item)
+            ? override.whenMet
+            : override.whenUnmet;
+        if (side !== null)
+            policy = side;
+    }
+    return policy;
+}
+function reportUnlessAllowed(policy, isAllowed, value, path, sink) {
+    if (!isAllowed) {
+        sink.add((0, create_issue_1.createIssue)({
+            path,
+            code: policy.code,
+            severity: policy.severity,
+            value,
+            render: (ctx) => policy.describe(ctx),
+        }));
+    }
+    return false;
+}

package/dist/runtime/decide-presence.mjs

@@ -0,0 +1,45 @@
+import { createIssue } from "./create-issue.mjs";
+/** True when the field should go on to its gates, checks and transforms. */
+export function decidePresence(field, value, ruleContext, sink) {
+    const policy = selectPolicy(field, ruleContext);
+    const isMissing = value === undefined || (policy.emptyStringIsMissing && value === "");
+    // null continues to the checks when the subject says null is a value.
+    if (!isMissing && (value !== null || policy.nullIsValue))
+        return true;
+    const isAllowed = isMissing ? policy.allowUndefined : policy.allowNull;
+    return reportUnlessAllowed(policy, isAllowed, value, ruleContext.path, sink);
+}
+/**
+ * The merged static policy, then every conditional override that applies, in
+ * declaration order — so a later `.optionalIf(...)` wins over an earlier
+ * `.requiredIf(...)` on the same field, the way a later assignment wins.
+ *
+ * The empty case costs one length test and returns the policy the compiler
+ * already built. Nothing here inspects a rule or builds a policy.
+ */
+function selectPolicy(field, ruleContext) {
+    const overrides = field.presenceOverrides;
+    if (overrides.length === 0)
+        return field.presence;
+    let policy = field.presence;
+    for (const override of overrides) {
+        const side = override.when(ruleContext.root, ruleContext.item)
+            ? override.whenMet
+            : override.whenUnmet;
+        if (side !== null)
+            policy = side;
+    }
+    return policy;
+}
+function reportUnlessAllowed(policy, isAllowed, value, path, sink) {
+    if (!isAllowed) {
+        sink.add(createIssue({
+            path,
+            code: policy.code,
+            severity: policy.severity,
+            value,
+            render: (ctx) => policy.describe(ctx),
+        }));
+    }
+    return false;
+}

package/dist/runtime/index-stack.d.ts

@@ -0,0 +1,28 @@
+import type { PathSegment } from "../path/path-segment.types";
+export declare class IndexStack {
+    private readonly prefixes;
+    private readonly openIndices;
+    /** How many array levels are currently open. */
+    get depth(): number;
+    /** The open indices, outermost first: `[0, 2]` inside `grid[0][2]`. */
+    get indices(): readonly number[];
+    /** `""` at the root, `items[0]` inside the first element of `items`. */
+    get prefix(): string;
+    /**
+     * Enters element `index` of an array node. `nodePath` is the node's own path
+     * relative to the subject it was read from, already rendered — the runner
+     * renders it once per NODE, never once per element.
+     *
+     * A non-integer or negative index is a bug in the runner, not a data
+     * condition: it would render `items[-1]`, a path no declaration can produce
+     * and no consumer can match. It throws where the caller is still on the
+     * stack rather than surfacing as a wrong path much later.
+     */
+    push(nodePath: string, index: number): void;
+    /** An unbalanced pop means a runner lost track of its own nesting. */
+    pop(): void;
+    /** The issue path of a field read from the subject at the current level. */
+    renderFieldPath(template: readonly PathSegment[]): string;
+}
+/** `""` is the root path, so it never contributes a separator dot. */
+export declare function joinIssuePath(prefix: string, own: string): string;

package/dist/runtime/index-stack.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexStack = void 0;
+exports.joinIssuePath = joinIssuePath;
+const format_issue_path_1 = require("../path/format-issue-path");
+/**
+ * A compiled template never contains a wildcard (createValueReader rejects
+ * one), so rendering it needs no index. Passing none is what makes a stray
+ * wildcard template throw here instead of silently rendering a second copy of
+ * an index this stack has already written into the prefix.
+ */
+const NO_INDICES = Object.freeze([]);
+class IndexStack {
+    constructor() {
+        this.prefixes = [];
+        this.openIndices = [];
+    }
+    /** How many array levels are currently open. */
+    get depth() {
+        return this.openIndices.length;
+    }
+    /** The open indices, outermost first: `[0, 2]` inside `grid[0][2]`. */
+    get indices() {
+        return this.openIndices;
+    }
+    /** `""` at the root, `items[0]` inside the first element of `items`. */
+    get prefix() {
+        return this.prefixes[this.prefixes.length - 1] ?? "";
+    }
+    /**
+     * Enters element `index` of an array node. `nodePath` is the node's own path
+     * relative to the subject it was read from, already rendered — the runner
+     * renders it once per NODE, never once per element.
+     *
+     * A non-integer or negative index is a bug in the runner, not a data
+     * condition: it would render `items[-1]`, a path no declaration can produce
+     * and no consumer can match. It throws where the caller is still on the
+     * stack rather than surfacing as a wrong path much later.
+     */
+    push(nodePath, index) {
+        if (!Number.isInteger(index) || index < 0) {
+            throw new RangeError(`an array index must be a non-negative integer, received ${String(index)}`);
+        }
+        this.prefixes.push(`${joinIssuePath(this.prefix, nodePath)}[${index}]`);
+        this.openIndices.push(index);
+    }
+    /** An unbalanced pop means a runner lost track of its own nesting. */
+    pop() {
+        if (this.openIndices.length === 0) {
+            throw new RangeError("popped an array index that was never pushed");
+        }
+        this.prefixes.pop();
+        this.openIndices.pop();
+    }
+    /** The issue path of a field read from the subject at the current level. */
+    renderFieldPath(template) {
+        return joinIssuePath(this.prefix, (0, format_issue_path_1.formatIssuePath)(template, NO_INDICES));
+    }
+}
+exports.IndexStack = IndexStack;
+/** `""` is the root path, so it never contributes a separator dot. */
+function joinIssuePath(prefix, own) {
+    if (prefix === "")
+        return own;
+    if (own === "")
+        return prefix;
+    return `${prefix}.${own}`;
+}

package/dist/runtime/index-stack.mjs

@@ -0,0 +1,63 @@
+import { formatIssuePath } from "../path/format-issue-path.mjs";
+/**
+ * A compiled template never contains a wildcard (createValueReader rejects
+ * one), so rendering it needs no index. Passing none is what makes a stray
+ * wildcard template throw here instead of silently rendering a second copy of
+ * an index this stack has already written into the prefix.
+ */
+const NO_INDICES = Object.freeze([]);
+export class IndexStack {
+    constructor() {
+        this.prefixes = [];
+        this.openIndices = [];
+    }
+    /** How many array levels are currently open. */
+    get depth() {
+        return this.openIndices.length;
+    }
+    /** The open indices, outermost first: `[0, 2]` inside `grid[0][2]`. */
+    get indices() {
+        return this.openIndices;
+    }
+    /** `""` at the root, `items[0]` inside the first element of `items`. */
+    get prefix() {
+        return this.prefixes[this.prefixes.length - 1] ?? "";
+    }
+    /**
+     * Enters element `index` of an array node. `nodePath` is the node's own path
+     * relative to the subject it was read from, already rendered — the runner
+     * renders it once per NODE, never once per element.
+     *
+     * A non-integer or negative index is a bug in the runner, not a data
+     * condition: it would render `items[-1]`, a path no declaration can produce
+     * and no consumer can match. It throws where the caller is still on the
+     * stack rather than surfacing as a wrong path much later.
+     */
+    push(nodePath, index) {
+        if (!Number.isInteger(index) || index < 0) {
+            throw new RangeError(`an array index must be a non-negative integer, received ${String(index)}`);
+        }
+        this.prefixes.push(`${joinIssuePath(this.prefix, nodePath)}[${index}]`);
+        this.openIndices.push(index);
+    }
+    /** An unbalanced pop means a runner lost track of its own nesting. */
+    pop() {
+        if (this.openIndices.length === 0) {
+            throw new RangeError("popped an array index that was never pushed");
+        }
+        this.prefixes.pop();
+        this.openIndices.pop();
+    }
+    /** The issue path of a field read from the subject at the current level. */
+    renderFieldPath(template) {
+        return joinIssuePath(this.prefix, formatIssuePath(template, NO_INDICES));
+    }
+}
+/** `""` is the root path, so it never contributes a separator dot. */
+export function joinIssuePath(prefix, own) {
+    if (prefix === "")
+        return own;
+    if (own === "")
+        return prefix;
+    return `${prefix}.${own}`;
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,19 @@
+export { ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD, DEFAULT_ABORT_EARLY, DEFAULT_ABORT_EARLY_ON_EACH_FIELD, IssueSink, resolveAbortPolicy, } from "./issue-sink";
+export type { AbortPolicy } from "./issue-sink";
+export { IndexStack, joinIssuePath } from "./index-stack";
+export { createIssue, renderFallbackMessage } from "./create-issue";
+export type { IssueRequest } from "./create-issue";
+export { decidePresence } from "./decide-presence";
+export { FIELD_VALUE_UNCHANGED, runField } from "./run-field";
+export type { FieldRunContext, FieldRunOutcome, RecursionRunner, } from "./run-field";
+export { NO_WRITE_TARGETS, createArrayWriteTargets, createPlanWriteTargets, replaceElement, writeFieldValue, } from "./output-writer";
+export type { ArrayWriteTarget } from "./output-writer";
+export { runArrayNodes } from "./run-array-node";
+export { prefixIssuePaths, runPlan } from "./run-plan";
+export { RECURSION_ABORT_POLICY, createRecursionRunner } from "./run-recursion";
+export type { RecursionHost } from "./run-recursion";
+export { BRANCH_ABORT_POLICY, createBranchExecutor } from "./run-branch";
+export { ROOT_MISSING_CODE, ROOT_MISSING_MESSAGE, createValidator, hasRejectingIssue, } from "./create-validator";
+export type { PlanValidator } from "./create-validator";
+export { createFieldValidator } from "./create-field-validator";
+export type { PlanFieldValidator } from "./create-field-validator";

package/dist/runtime/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFieldValidator = exports.hasRejectingIssue = exports.createValidator = exports.ROOT_MISSING_MESSAGE = exports.ROOT_MISSING_CODE = exports.createBranchExecutor = exports.BRANCH_ABORT_POLICY = exports.createRecursionRunner = exports.RECURSION_ABORT_POLICY = exports.runPlan = exports.prefixIssuePaths = exports.runArrayNodes = exports.writeFieldValue = exports.replaceElement = exports.createPlanWriteTargets = exports.createArrayWriteTargets = exports.NO_WRITE_TARGETS = exports.runField = exports.FIELD_VALUE_UNCHANGED = exports.decidePresence = exports.renderFallbackMessage = exports.createIssue = exports.joinIssuePath = exports.IndexStack = exports.resolveAbortPolicy = exports.IssueSink = exports.DEFAULT_ABORT_EARLY_ON_EACH_FIELD = exports.DEFAULT_ABORT_EARLY = exports.ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD = void 0;
+// ===========================================================================
+// L5  src/runtime/index.ts — re-exports only. The engine: one plan in, issues
+// and (for parse) a copy-on-write output out. Nothing is defined in this file.
+// ===========================================================================
+var issue_sink_1 = require("./issue-sink");
+Object.defineProperty(exports, "ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD", { enumerable: true, get: function () { return issue_sink_1.ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD; } });
+Object.defineProperty(exports, "DEFAULT_ABORT_EARLY", { enumerable: true, get: function () { return issue_sink_1.DEFAULT_ABORT_EARLY; } });
+Object.defineProperty(exports, "DEFAULT_ABORT_EARLY_ON_EACH_FIELD", { enumerable: true, get: function () { return issue_sink_1.DEFAULT_ABORT_EARLY_ON_EACH_FIELD; } });
+Object.defineProperty(exports, "IssueSink", { enumerable: true, get: function () { return issue_sink_1.IssueSink; } });
+Object.defineProperty(exports, "resolveAbortPolicy", { enumerable: true, get: function () { return issue_sink_1.resolveAbortPolicy; } });
+var index_stack_1 = require("./index-stack");
+Object.defineProperty(exports, "IndexStack", { enumerable: true, get: function () { return index_stack_1.IndexStack; } });
+Object.defineProperty(exports, "joinIssuePath", { enumerable: true, get: function () { return index_stack_1.joinIssuePath; } });
+var create_issue_1 = require("./create-issue");
+Object.defineProperty(exports, "createIssue", { enumerable: true, get: function () { return create_issue_1.createIssue; } });
+Object.defineProperty(exports, "renderFallbackMessage", { enumerable: true, get: function () { return create_issue_1.renderFallbackMessage; } });
+var decide_presence_1 = require("./decide-presence");
+Object.defineProperty(exports, "decidePresence", { enumerable: true, get: function () { return decide_presence_1.decidePresence; } });
+var run_field_1 = require("./run-field");
+Object.defineProperty(exports, "FIELD_VALUE_UNCHANGED", { enumerable: true, get: function () { return run_field_1.FIELD_VALUE_UNCHANGED; } });
+Object.defineProperty(exports, "runField", { enumerable: true, get: function () { return run_field_1.runField; } });
+var output_writer_1 = require("./output-writer");
+Object.defineProperty(exports, "NO_WRITE_TARGETS", { enumerable: true, get: function () { return output_writer_1.NO_WRITE_TARGETS; } });
+Object.defineProperty(exports, "createArrayWriteTargets", { enumerable: true, get: function () { return output_writer_1.createArrayWriteTargets; } });
+Object.defineProperty(exports, "createPlanWriteTargets", { enumerable: true, get: function () { return output_writer_1.createPlanWriteTargets; } });
+Object.defineProperty(exports, "replaceElement", { enumerable: true, get: function () { return output_writer_1.replaceElement; } });
+Object.defineProperty(exports, "writeFieldValue", { enumerable: true, get: function () { return output_writer_1.writeFieldValue; } });
+var run_array_node_1 = require("./run-array-node");
+Object.defineProperty(exports, "runArrayNodes", { enumerable: true, get: function () { return run_array_node_1.runArrayNodes; } });
+var run_plan_1 = require("./run-plan");
+Object.defineProperty(exports, "prefixIssuePaths", { enumerable: true, get: function () { return run_plan_1.prefixIssuePaths; } });
+Object.defineProperty(exports, "runPlan", { enumerable: true, get: function () { return run_plan_1.runPlan; } });
+var run_recursion_1 = require("./run-recursion");
+Object.defineProperty(exports, "RECURSION_ABORT_POLICY", { enumerable: true, get: function () { return run_recursion_1.RECURSION_ABORT_POLICY; } });
+Object.defineProperty(exports, "createRecursionRunner", { enumerable: true, get: function () { return run_recursion_1.createRecursionRunner; } });
+var run_branch_1 = require("./run-branch");
+Object.defineProperty(exports, "BRANCH_ABORT_POLICY", { enumerable: true, get: function () { return run_branch_1.BRANCH_ABORT_POLICY; } });
+Object.defineProperty(exports, "createBranchExecutor", { enumerable: true, get: function () { return run_branch_1.createBranchExecutor; } });
+var create_validator_1 = require("./create-validator");
+Object.defineProperty(exports, "ROOT_MISSING_CODE", { enumerable: true, get: function () { return create_validator_1.ROOT_MISSING_CODE; } });
+Object.defineProperty(exports, "ROOT_MISSING_MESSAGE", { enumerable: true, get: function () { return create_validator_1.ROOT_MISSING_MESSAGE; } });
+Object.defineProperty(exports, "createValidator", { enumerable: true, get: function () { return create_validator_1.createValidator; } });
+Object.defineProperty(exports, "hasRejectingIssue", { enumerable: true, get: function () { return create_validator_1.hasRejectingIssue; } });
+var create_field_validator_1 = require("./create-field-validator");
+Object.defineProperty(exports, "createFieldValidator", { enumerable: true, get: function () { return create_field_validator_1.createFieldValidator; } });

package/dist/runtime/index.mjs

@@ -0,0 +1,16 @@
+// ===========================================================================
+// L5  src/runtime/index.ts — re-exports only. The engine: one plan in, issues
+// and (for parse) a copy-on-write output out. Nothing is defined in this file.
+// ===========================================================================
+export { ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD, DEFAULT_ABORT_EARLY, DEFAULT_ABORT_EARLY_ON_EACH_FIELD, IssueSink, resolveAbortPolicy, } from "./issue-sink.mjs";
+export { IndexStack, joinIssuePath } from "./index-stack.mjs";
+export { createIssue, renderFallbackMessage } from "./create-issue.mjs";
+export { decidePresence } from "./decide-presence.mjs";
+export { FIELD_VALUE_UNCHANGED, runField } from "./run-field.mjs";
+export { NO_WRITE_TARGETS, createArrayWriteTargets, createPlanWriteTargets, replaceElement, writeFieldValue, } from "./output-writer.mjs";
+export { runArrayNodes } from "./run-array-node.mjs";
+export { prefixIssuePaths, runPlan } from "./run-plan.mjs";
+export { RECURSION_ABORT_POLICY, createRecursionRunner } from "./run-recursion.mjs";
+export { BRANCH_ABORT_POLICY, createBranchExecutor } from "./run-branch.mjs";
+export { ROOT_MISSING_CODE, ROOT_MISSING_MESSAGE, createValidator, hasRejectingIssue, } from "./create-validator.mjs";
+export { createFieldValidator } from "./create-field-validator.mjs";

package/dist/runtime/issue-sink.d.ts

@@ -0,0 +1,39 @@
+import type { ValidationIssue } from "../types";
+import type { ValidateOptions } from "../types/validation-result.types";
+export interface AbortPolicy {
+    readonly abortEarly: boolean;
+    readonly abortEarlyOnEachField: boolean;
+}
+export declare const DEFAULT_ABORT_EARLY = true;
+export declare const DEFAULT_ABORT_EARLY_ON_EACH_FIELD = true;
+/**
+ * Inside an array element every field is validated to completion whatever the
+ * caller asked for. Legacy hard-coded `effectiveAbortEarlyOnEachField = false`
+ * in two places and forgot it in a third; here it is one named constant that
+ * `forArrayElements()` is the only consumer of.
+ */
+export declare const ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD = false;
+export declare function resolveAbortPolicy(options?: ValidateOptions): AbortPolicy;
+export declare class IssueSink {
+    private readonly policy;
+    private collected;
+    constructor(policy: AbortPolicy);
+    /** The mark a field captures before it runs its own rules. */
+    get count(): number;
+    /** The live buffer. runPlan freezes it once, at the end of the call. */
+    get issues(): readonly ValidationIssue[];
+    add(issue: ValidationIssue): void;
+    /**
+     * Any issue counts, whatever its severity. Severity labels an issue for the
+     * consumer; it does not make the issue conditional, and a sink that skipped
+     * warnings here would make abortEarly mean something different depending on
+     * which plugin happened to fail first.
+     */
+    shouldStopPlan(): boolean;
+    shouldStopField(mark: number): boolean;
+    /**
+     * A sink for the fields of one array element: the same issue buffer, so
+     * abortEarly still sees everything, with the field-level abort disabled.
+     */
+    forArrayElements(): IssueSink;
+}

package/dist/runtime/issue-sink.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueSink = exports.ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD = exports.DEFAULT_ABORT_EARLY_ON_EACH_FIELD = exports.DEFAULT_ABORT_EARLY = void 0;
+exports.resolveAbortPolicy = resolveAbortPolicy;
+exports.DEFAULT_ABORT_EARLY = true;
+exports.DEFAULT_ABORT_EARLY_ON_EACH_FIELD = true;
+/**
+ * Inside an array element every field is validated to completion whatever the
+ * caller asked for. Legacy hard-coded `effectiveAbortEarlyOnEachField = false`
+ * in two places and forgot it in a third; here it is one named constant that
+ * `forArrayElements()` is the only consumer of.
+ */
+exports.ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD = false;
+function resolveAbortPolicy(options) {
+    return {
+        abortEarly: options?.abortEarly ?? exports.DEFAULT_ABORT_EARLY,
+        abortEarlyOnEachField: options?.abortEarlyOnEachField ?? exports.DEFAULT_ABORT_EARLY_ON_EACH_FIELD,
+    };
+}
+class IssueSink {
+    constructor(policy) {
+        this.policy = policy;
+        this.collected = [];
+    }
+    /** The mark a field captures before it runs its own rules. */
+    get count() {
+        return this.collected.length;
+    }
+    /** The live buffer. runPlan freezes it once, at the end of the call. */
+    get issues() {
+        return this.collected;
+    }
+    add(issue) {
+        this.collected.push(issue);
+    }
+    /**
+     * Any issue counts, whatever its severity. Severity labels an issue for the
+     * consumer; it does not make the issue conditional, and a sink that skipped
+     * warnings here would make abortEarly mean something different depending on
+     * which plugin happened to fail first.
+     */
+    shouldStopPlan() {
+        return this.policy.abortEarly && this.collected.length > 0;
+    }
+    shouldStopField(mark) {
+        return this.policy.abortEarlyOnEachField && this.collected.length > mark;
+    }
+    /**
+     * A sink for the fields of one array element: the same issue buffer, so
+     * abortEarly still sees everything, with the field-level abort disabled.
+     */
+    forArrayElements() {
+        const derived = new IssueSink({
+            abortEarly: this.policy.abortEarly,
+            abortEarlyOnEachField: exports.ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD,
+        });
+        derived.collected = this.collected;
+        return derived;
+    }
+}
+exports.IssueSink = IssueSink;

package/dist/runtime/issue-sink.mjs

@@ -0,0 +1,56 @@
+export const DEFAULT_ABORT_EARLY = true;
+export const DEFAULT_ABORT_EARLY_ON_EACH_FIELD = true;
+/**
+ * Inside an array element every field is validated to completion whatever the
+ * caller asked for. Legacy hard-coded `effectiveAbortEarlyOnEachField = false`
+ * in two places and forgot it in a third; here it is one named constant that
+ * `forArrayElements()` is the only consumer of.
+ */
+export const ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD = false;
+export function resolveAbortPolicy(options) {
+    return {
+        abortEarly: options?.abortEarly ?? DEFAULT_ABORT_EARLY,
+        abortEarlyOnEachField: options?.abortEarlyOnEachField ?? DEFAULT_ABORT_EARLY_ON_EACH_FIELD,
+    };
+}
+export class IssueSink {
+    constructor(policy) {
+        this.policy = policy;
+        this.collected = [];
+    }
+    /** The mark a field captures before it runs its own rules. */
+    get count() {
+        return this.collected.length;
+    }
+    /** The live buffer. runPlan freezes it once, at the end of the call. */
+    get issues() {
+        return this.collected;
+    }
+    add(issue) {
+        this.collected.push(issue);
+    }
+    /**
+     * Any issue counts, whatever its severity. Severity labels an issue for the
+     * consumer; it does not make the issue conditional, and a sink that skipped
+     * warnings here would make abortEarly mean something different depending on
+     * which plugin happened to fail first.
+     */
+    shouldStopPlan() {
+        return this.policy.abortEarly && this.collected.length > 0;
+    }
+    shouldStopField(mark) {
+        return this.policy.abortEarlyOnEachField && this.collected.length > mark;
+    }
+    /**
+     * A sink for the fields of one array element: the same issue buffer, so
+     * abortEarly still sees everything, with the field-level abort disabled.
+     */
+    forArrayElements() {
+        const derived = new IssueSink({
+            abortEarly: this.policy.abortEarly,
+            abortEarlyOnEachField: ARRAY_ELEMENTS_ABORT_ON_EACH_FIELD,
+        });
+        derived.collected = this.collected;
+        return derived;
+    }
+}