@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/runtime/decide-presence.js

@@ -0,0 +1,47 @@
+"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 === "");
+    if (!isMissing && value !== null)
+        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,44 @@
+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 === "");
+    if (!isMissing && value !== null)
+        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;
+    }
+}

package/dist/runtime/output-writer.d.ts

@@ -0,0 +1,38 @@
+import type { ArrayNode, CompiledField, ValidationPlan } from "../compile/validation-plan.types";
+import type { ValueWriter } from "../path/create-value-writer";
+import type { FieldRunOutcome } from "./run-field";
+/** The write-back companion of one ArrayNode, plus those of its nested nodes. */
+export interface ArrayWriteTarget {
+    /** Puts a rebuilt array back at the node's own path in its subject. */
+    readonly write: ValueWriter;
+    readonly nested: readonly ArrayWriteTarget[];
+}
+/** Shared and frozen: a validate() run allocates no target at all. */
+export declare const NO_WRITE_TARGETS: readonly ArrayWriteTarget[];
+export declare function createArrayWriteTargets(nodes: readonly ArrayNode[]): readonly ArrayWriteTarget[];
+/**
+ * null when the plan writes nothing at all — no transform anywhere and no
+ * default anywhere. createValidator turns that null into "parse() runs exactly
+ * the validate() path", which is the whole of "hasTransforms === false skips
+ * the writer entirely": no target is built, no writer is called, and parse()
+ * hands back the very object it was given.
+ */
+export declare function createPlanWriteTargets(plan: ValidationPlan): readonly ArrayWriteTarget[] | null;
+/**
+ * `shouldWrite` is the parse/validate decision, taken by the caller and passed
+ * down rather than re-derived here. validate() must not write even though a
+ * default DID produce a new value for the rules to judge: legacy computed
+ * defaults into a copy and threw the copy away, and that is the behaviour the
+ * two entry points still share.
+ *
+ * `field.write` is null exactly when the field declared neither a transform
+ * nor a default, so the null test is not a rule-kind decision — it is the
+ * compiled answer to "does this field have an output at all".
+ */
+export declare function writeFieldValue(field: CompiledField, subject: unknown, outcome: FieldRunOutcome, shouldWrite: boolean): unknown;
+/**
+ * One element replaced, copy-on-write. An element that came back by identity
+ * costs nothing: a 10k-element array with no transform is never copied, which
+ * is why the identity test comes before the slice.
+ */
+export declare function replaceElement(array: readonly unknown[], index: number, element: unknown): readonly unknown[];

package/dist/runtime/output-writer.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_WRITE_TARGETS = void 0;
+exports.createArrayWriteTargets = createArrayWriteTargets;
+exports.createPlanWriteTargets = createPlanWriteTargets;
+exports.writeFieldValue = writeFieldValue;
+exports.replaceElement = replaceElement;
+const create_value_writer_1 = require("../path/create-value-writer");
+/** Shared and frozen: a validate() run allocates no target at all. */
+exports.NO_WRITE_TARGETS = Object.freeze([]);
+function createArrayWriteTargets(nodes) {
+    if (nodes.length === 0)
+        return exports.NO_WRITE_TARGETS;
+    return Object.freeze(nodes.map((node) => Object.freeze({
+        write: (0, create_value_writer_1.createValueWriter)(node.template),
+        nested: createArrayWriteTargets(node.nested),
+    })));
+}
+/**
+ * null when the plan writes nothing at all — no transform anywhere and no
+ * default anywhere. createValidator turns that null into "parse() runs exactly
+ * the validate() path", which is the whole of "hasTransforms === false skips
+ * the writer entirely": no target is built, no writer is called, and parse()
+ * hands back the very object it was given.
+ */
+function createPlanWriteTargets(plan) {
+    if (!plan.hasTransforms && !plan.hasDefaults)
+        return null;
+    return createArrayWriteTargets(plan.arrays);
+}
+/**
+ * `shouldWrite` is the parse/validate decision, taken by the caller and passed
+ * down rather than re-derived here. validate() must not write even though a
+ * default DID produce a new value for the rules to judge: legacy computed
+ * defaults into a copy and threw the copy away, and that is the behaviour the
+ * two entry points still share.
+ *
+ * `field.write` is null exactly when the field declared neither a transform
+ * nor a default, so the null test is not a rule-kind decision — it is the
+ * compiled answer to "does this field have an output at all".
+ */
+function writeFieldValue(field, subject, outcome, shouldWrite) {
+    if (!shouldWrite || !outcome.hasWriteBack || field.write === null) {
+        return subject;
+    }
+    return field.write(subject, outcome.value);
+}
+/**
+ * One element replaced, copy-on-write. An element that came back by identity
+ * costs nothing: a 10k-element array with no transform is never copied, which
+ * is why the identity test comes before the slice.
+ */
+function replaceElement(array, index, element) {
+    if (array[index] === element)
+        return array;
+    const copy = array.slice();
+    copy[index] = element;
+    return copy;
+}

package/dist/runtime/output-writer.mjs

@@ -0,0 +1,52 @@
+import { createValueWriter } from "../path/create-value-writer.mjs";
+/** Shared and frozen: a validate() run allocates no target at all. */
+export const NO_WRITE_TARGETS = Object.freeze([]);
+export function createArrayWriteTargets(nodes) {
+    if (nodes.length === 0)
+        return NO_WRITE_TARGETS;
+    return Object.freeze(nodes.map((node) => Object.freeze({
+        write: createValueWriter(node.template),
+        nested: createArrayWriteTargets(node.nested),
+    })));
+}
+/**
+ * null when the plan writes nothing at all — no transform anywhere and no
+ * default anywhere. createValidator turns that null into "parse() runs exactly
+ * the validate() path", which is the whole of "hasTransforms === false skips
+ * the writer entirely": no target is built, no writer is called, and parse()
+ * hands back the very object it was given.
+ */
+export function createPlanWriteTargets(plan) {
+    if (!plan.hasTransforms && !plan.hasDefaults)
+        return null;
+    return createArrayWriteTargets(plan.arrays);
+}
+/**
+ * `shouldWrite` is the parse/validate decision, taken by the caller and passed
+ * down rather than re-derived here. validate() must not write even though a
+ * default DID produce a new value for the rules to judge: legacy computed
+ * defaults into a copy and threw the copy away, and that is the behaviour the
+ * two entry points still share.
+ *
+ * `field.write` is null exactly when the field declared neither a transform
+ * nor a default, so the null test is not a rule-kind decision — it is the
+ * compiled answer to "does this field have an output at all".
+ */
+export function writeFieldValue(field, subject, outcome, shouldWrite) {
+    if (!shouldWrite || !outcome.hasWriteBack || field.write === null) {
+        return subject;
+    }
+    return field.write(subject, outcome.value);
+}
+/**
+ * One element replaced, copy-on-write. An element that came back by identity
+ * costs nothing: a 10k-element array with no transform is never copied, which
+ * is why the identity test comes before the slice.
+ */
+export function replaceElement(array, index, element) {
+    if (array[index] === element)
+        return array;
+    const copy = array.slice();
+    copy[index] = element;
+    return copy;
+}