@maroonedog/luq 0.1.2-alpha → 2.0.0

package/dist/runtime/run-array-node.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayNode } from "../compile/validation-plan.types";
+import type { FieldRunContext } from "./run-field";
+import type { ArrayWriteTarget } from "./output-writer";
+/**
+ * `targets` mirrors `nodes` by position and is EMPTY on every run that produces
+ * no output. Zipping by index needs no lookup and no identity check, because
+ * output-writer derives one list from the other by the same recursion.
+ */
+export declare function runArrayNodes(nodes: readonly ArrayNode[], subject: unknown, context: FieldRunContext, targets: readonly ArrayWriteTarget[]): unknown;

package/dist/runtime/run-array-node.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runArrayNodes = runArrayNodes;
+// ===========================================================================
+// L5  src/runtime/run-array-node.ts
+// LOOP INTERCHANGE, executed. The array behind a node is read ONCE however
+// many element fields the node carries, and the elements are then walked once,
+// applying every field to each. compileArrayNode already grouped the
+// declarations, so this file contains no decision about which field belongs to
+// which array.
+//
+// The legacy tree walked the array once per declared element field and rebuilt
+// its batch validator inside validate(), giving back the optimisation it had
+// just made. Here the only per-element allocation is the ArrayItemContext the
+// plugin contract requires, plus the context object carrying it.
+//
+// Every index this loop opens is pushed on the ONE index stack and popped
+// again before the next element, so an issue raised three levels down renders
+// `grid[0][2].name` and never the declaration pattern.
+// ===========================================================================
+const types_1 = require("../types");
+const format_issue_path_1 = require("../path/format-issue-path");
+const run_field_1 = require("./run-field");
+const output_writer_1 = require("./output-writer");
+/** A node template never contains a wildcard: the grouping cut it off. */
+const NO_INDICES = Object.freeze([]);
+/**
+ * `targets` mirrors `nodes` by position and is EMPTY on every run that produces
+ * no output. Zipping by index needs no lookup and no identity check, because
+ * output-writer derives one list from the other by the same recursion.
+ */
+function runArrayNodes(nodes, subject, context, targets) {
+    let current = subject;
+    for (let i = 0; i < nodes.length; i += 1) {
+        const node = nodes[i];
+        if (node === undefined)
+            continue;
+        current = runArrayNode(node, current, context, targets[i]);
+        if (context.sink.shouldStopPlan())
+            return current;
+    }
+    return current;
+}
+/**
+ * A subject with no array at this path is not an error: createArrayReader
+ * decided that at the boundary, and asserting that the container IS an array is
+ * a separate declared rule on the container path. An empty array is an array,
+ * so the element loop simply runs zero times.
+ */
+function runArrayNode(node, subject, context, target) {
+    const array = node.read(subject);
+    if (!(0, types_1.isArray)(array))
+        return subject;
+    const rebuilt = runElements(node, array, context, target);
+    if (rebuilt === array || target === undefined)
+        return subject;
+    return target.write(subject, rebuilt);
+}
+function runElements(node, array, context, target) {
+    const nodePath = (0, format_issue_path_1.formatIssuePath)(node.template, NO_INDICES);
+    const elementSink = context.sink.forArrayElements();
+    const nested = target === undefined ? output_writer_1.NO_WRITE_TARGETS : target.nested;
+    let rebuilt = array;
+    for (let index = 0; index < array.length; index += 1) {
+        const elementContext = {
+            ...context,
+            sink: elementSink,
+            item: describeItem(array, index),
+        };
+        context.indices.push(nodePath, index);
+        const element = runNested(node, runElementFields(node, array[index], elementContext), elementContext, nested);
+        context.indices.pop();
+        rebuilt = (0, output_writer_1.replaceElement)(rebuilt, index, element);
+        if (context.sink.shouldStopPlan())
+            return rebuilt;
+    }
+    return rebuilt;
+}
+/** The stack frame for this element is still open, so `sub` pushes onto it. */
+function runNested(node, element, elementContext, nested) {
+    if (node.nested.length === 0)
+        return element;
+    return runArrayNodes(node.nested, element, elementContext, nested);
+}
+function runElementFields(node, element, elementContext) {
+    let current = element;
+    for (const field of node.elementFields) {
+        const outcome = (0, run_field_1.runField)(field, current, elementContext);
+        current = (0, output_writer_1.writeFieldValue)(field, current, outcome, elementContext.shouldApplyTransforms);
+        if (elementContext.sink.shouldStopPlan())
+            return current;
+    }
+    return current;
+}
+/** The ArrayItemContext a plugin reads on RuleContext.item. */
+function describeItem(array, index) {
+    return { index, item: array[index], array };
+}

package/dist/runtime/run-array-node.mjs

@@ -0,0 +1,95 @@
+// ===========================================================================
+// L5  src/runtime/run-array-node.ts
+// LOOP INTERCHANGE, executed. The array behind a node is read ONCE however
+// many element fields the node carries, and the elements are then walked once,
+// applying every field to each. compileArrayNode already grouped the
+// declarations, so this file contains no decision about which field belongs to
+// which array.
+//
+// The legacy tree walked the array once per declared element field and rebuilt
+// its batch validator inside validate(), giving back the optimisation it had
+// just made. Here the only per-element allocation is the ArrayItemContext the
+// plugin contract requires, plus the context object carrying it.
+//
+// Every index this loop opens is pushed on the ONE index stack and popped
+// again before the next element, so an issue raised three levels down renders
+// `grid[0][2].name` and never the declaration pattern.
+// ===========================================================================
+import { isArray } from "../types/index.mjs";
+import { formatIssuePath } from "../path/format-issue-path.mjs";
+import { runField } from "./run-field.mjs";
+import { NO_WRITE_TARGETS, replaceElement, writeFieldValue, } from "./output-writer.mjs";
+/** A node template never contains a wildcard: the grouping cut it off. */
+const NO_INDICES = Object.freeze([]);
+/**
+ * `targets` mirrors `nodes` by position and is EMPTY on every run that produces
+ * no output. Zipping by index needs no lookup and no identity check, because
+ * output-writer derives one list from the other by the same recursion.
+ */
+export function runArrayNodes(nodes, subject, context, targets) {
+    let current = subject;
+    for (let i = 0; i < nodes.length; i += 1) {
+        const node = nodes[i];
+        if (node === undefined)
+            continue;
+        current = runArrayNode(node, current, context, targets[i]);
+        if (context.sink.shouldStopPlan())
+            return current;
+    }
+    return current;
+}
+/**
+ * A subject with no array at this path is not an error: createArrayReader
+ * decided that at the boundary, and asserting that the container IS an array is
+ * a separate declared rule on the container path. An empty array is an array,
+ * so the element loop simply runs zero times.
+ */
+function runArrayNode(node, subject, context, target) {
+    const array = node.read(subject);
+    if (!isArray(array))
+        return subject;
+    const rebuilt = runElements(node, array, context, target);
+    if (rebuilt === array || target === undefined)
+        return subject;
+    return target.write(subject, rebuilt);
+}
+function runElements(node, array, context, target) {
+    const nodePath = formatIssuePath(node.template, NO_INDICES);
+    const elementSink = context.sink.forArrayElements();
+    const nested = target === undefined ? NO_WRITE_TARGETS : target.nested;
+    let rebuilt = array;
+    for (let index = 0; index < array.length; index += 1) {
+        const elementContext = {
+            ...context,
+            sink: elementSink,
+            item: describeItem(array, index),
+        };
+        context.indices.push(nodePath, index);
+        const element = runNested(node, runElementFields(node, array[index], elementContext), elementContext, nested);
+        context.indices.pop();
+        rebuilt = replaceElement(rebuilt, index, element);
+        if (context.sink.shouldStopPlan())
+            return rebuilt;
+    }
+    return rebuilt;
+}
+/** The stack frame for this element is still open, so `sub` pushes onto it. */
+function runNested(node, element, elementContext, nested) {
+    if (node.nested.length === 0)
+        return element;
+    return runArrayNodes(node.nested, element, elementContext, nested);
+}
+function runElementFields(node, element, elementContext) {
+    let current = element;
+    for (const field of node.elementFields) {
+        const outcome = runField(field, current, elementContext);
+        current = writeFieldValue(field, current, outcome, elementContext.shouldApplyTransforms);
+        if (elementContext.sink.shouldStopPlan())
+            return current;
+    }
+    return current;
+}
+/** The ArrayItemContext a plugin reads on RuleContext.item. */
+function describeItem(array, index) {
+    return { index, item: array[index], array };
+}

package/dist/runtime/run-branch.d.ts

@@ -0,0 +1,14 @@
+import type { BranchExecutor } from "../compile/branch-executor.port";
+import type { AbortPolicy } from "./issue-sink";
+/**
+ * A branch is a decision, not a report: the first failure already answers it,
+ * so both aborts stay on. Collecting every issue of every alternative of a
+ * `oneOf` would make the cost of the reduction the cost of validating the
+ * whole schema once per branch.
+ */
+export declare const BRANCH_ABORT_POLICY: AbortPolicy;
+/**
+ * Stateless and shareable: everything that varies lives in the call. L6 wires
+ * one of these into compileSchema, and the same object serves every plan.
+ */
+export declare function createBranchExecutor(): BranchExecutor;

package/dist/runtime/run-branch.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BRANCH_ABORT_POLICY = void 0;
+exports.createBranchExecutor = createBranchExecutor;
+// ===========================================================================
+// L5  src/runtime/run-branch.ts — THE ONE BranchExecutor.
+//
+// L4 declares the port and never implements it; this is the only implementation
+// in the library, and all it does is call runPlan. That is what makes "branch
+// execution is the engine" a fact rather than an intention: a composite cannot
+// reach a second traversal, because there is no second traversal to reach.
+//
+// A branch answers one question — did this plan hold for this value — and
+// reports WHY through `causes`. The issues are collected in a private sink, so
+// a branch that fails inside `oneOf` does not put its failure in the caller's
+// result; only the composite's own issue is reported, and the branch issues
+// hang off its detail.
+//
+// A branch with an EMPTY plan passes. That is not a special case: a composite
+// declared with `branches: []` (additionalProperties in its boolean form)
+// compiles to zero runners, and a branch with no fields and no rules compiles
+// to a plan with no fields and no arrays. runPlan walks both to completion and
+// the sink stays empty.
+// ===========================================================================
+const types_1 = require("../types");
+const index_stack_1 = require("./index-stack");
+const issue_sink_1 = require("./issue-sink");
+const run_recursion_1 = require("./run-recursion");
+const run_plan_1 = require("./run-plan");
+/**
+ * A branch is a decision, not a report: the first failure already answers it,
+ * so both aborts stay on. Collecting every issue of every alternative of a
+ * `oneOf` would make the cost of the reduction the cost of validating the
+ * whole schema once per branch.
+ */
+exports.BRANCH_ABORT_POLICY = Object.freeze({
+    abortEarly: true,
+    abortEarlyOnEachField: true,
+});
+/**
+ * Stateless and shareable: everything that varies lives in the call. L6 wires
+ * one of these into compileSchema, and the same object serves every plan.
+ */
+function createBranchExecutor() {
+    return {
+        runBranch(plan, value, ruleContext) {
+            const sink = new issue_sink_1.IssueSink(exports.BRANCH_ABORT_POLICY);
+            (0, run_plan_1.runPlan)(plan, value, {
+                root: ruleContext.root,
+                sink,
+                indices: new index_stack_1.IndexStack(),
+                shouldApplyTransforms: false,
+                runRecursion: (0, run_recursion_1.createRecursionRunner)({
+                    root: ruleContext.root,
+                    sink,
+                    external: ruleContext.external,
+                }),
+                item: ruleContext.item,
+                external: ruleContext.external,
+            });
+            if (sink.count === 0)
+                return types_1.PASS;
+            const causes = (0, run_plan_1.prefixIssuePaths)(ruleContext.path, sink.issues);
+            return (0, types_1.fail)({ causes: Object.freeze(causes) });
+        },
+    };
+}

package/dist/runtime/run-branch.mjs

@@ -0,0 +1,63 @@
+// ===========================================================================
+// L5  src/runtime/run-branch.ts — THE ONE BranchExecutor.
+//
+// L4 declares the port and never implements it; this is the only implementation
+// in the library, and all it does is call runPlan. That is what makes "branch
+// execution is the engine" a fact rather than an intention: a composite cannot
+// reach a second traversal, because there is no second traversal to reach.
+//
+// A branch answers one question — did this plan hold for this value — and
+// reports WHY through `causes`. The issues are collected in a private sink, so
+// a branch that fails inside `oneOf` does not put its failure in the caller's
+// result; only the composite's own issue is reported, and the branch issues
+// hang off its detail.
+//
+// A branch with an EMPTY plan passes. That is not a special case: a composite
+// declared with `branches: []` (additionalProperties in its boolean form)
+// compiles to zero runners, and a branch with no fields and no rules compiles
+// to a plan with no fields and no arrays. runPlan walks both to completion and
+// the sink stays empty.
+// ===========================================================================
+import { PASS, fail } from "../types/index.mjs";
+import { IndexStack } from "./index-stack.mjs";
+import { IssueSink } from "./issue-sink.mjs";
+import { createRecursionRunner } from "./run-recursion.mjs";
+import { prefixIssuePaths, runPlan } from "./run-plan.mjs";
+/**
+ * A branch is a decision, not a report: the first failure already answers it,
+ * so both aborts stay on. Collecting every issue of every alternative of a
+ * `oneOf` would make the cost of the reduction the cost of validating the
+ * whole schema once per branch.
+ */
+export const BRANCH_ABORT_POLICY = Object.freeze({
+    abortEarly: true,
+    abortEarlyOnEachField: true,
+});
+/**
+ * Stateless and shareable: everything that varies lives in the call. L6 wires
+ * one of these into compileSchema, and the same object serves every plan.
+ */
+export function createBranchExecutor() {
+    return {
+        runBranch(plan, value, ruleContext) {
+            const sink = new IssueSink(BRANCH_ABORT_POLICY);
+            runPlan(plan, value, {
+                root: ruleContext.root,
+                sink,
+                indices: new IndexStack(),
+                shouldApplyTransforms: false,
+                runRecursion: createRecursionRunner({
+                    root: ruleContext.root,
+                    sink,
+                    external: ruleContext.external,
+                }),
+                item: ruleContext.item,
+                external: ruleContext.external,
+            });
+            if (sink.count === 0)
+                return PASS;
+            const causes = prefixIssuePaths(ruleContext.path, sink.issues);
+            return fail({ causes: Object.freeze(causes) });
+        },
+    };
+}

package/dist/runtime/run-field.d.ts

@@ -0,0 +1,27 @@
+import type { ArrayItemContext, RuleContext } from "../types";
+import type { CompiledField, RecursionPolicy } from "../compile/validation-plan.types";
+import type { IndexStack } from "./index-stack";
+import type { IssueSink } from "./issue-sink";
+/** Re-enters a plan; run-recursion's job. Bound to the sink and the stack. */
+export type RecursionRunner = (policy: RecursionPolicy, value: unknown, ctx: RuleContext) => void;
+export interface FieldRunContext {
+    readonly root: unknown;
+    readonly sink: IssueSink;
+    readonly indices: IndexStack;
+    /** False for validate(), true for parse(). validate skips transforms whole. */
+    readonly shouldApplyTransforms: boolean;
+    readonly runRecursion: RecursionRunner;
+    readonly item?: ArrayItemContext;
+    readonly external?: Readonly<Record<string, unknown>>;
+}
+/** Discriminated so a written `undefined` stays distinguishable from "no
+ *  write at all", which a bare `unknown` return could not express. */
+export type FieldRunOutcome = {
+    readonly hasWriteBack: false;
+} | {
+    readonly hasWriteBack: true;
+    readonly value: unknown;
+};
+/** Shared, frozen, never re-assigned: the common answer allocates nothing. */
+export declare const FIELD_VALUE_UNCHANGED: FieldRunOutcome;
+export declare function runField(field: CompiledField, subject: unknown, context: FieldRunContext): FieldRunOutcome;

package/dist/runtime/run-field.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIELD_VALUE_UNCHANGED = void 0;
+exports.runField = runField;
+const create_issue_1 = require("./create-issue");
+const decide_presence_1 = require("./decide-presence");
+/** Shared, frozen, never re-assigned: the common answer allocates nothing. */
+exports.FIELD_VALUE_UNCHANGED = Object.freeze({
+    hasWriteBack: false,
+});
+function runField(field, subject, context) {
+    const path = context.indices.renderFieldPath(field.template);
+    const ruleContext = {
+        root: context.root,
+        path,
+        item: context.item,
+        external: context.external,
+    };
+    const read = field.read(subject);
+    const value = applyDefault(field, read, context.root);
+    if (!(0, decide_presence_1.decidePresence)(field, value, ruleContext, context.sink)) {
+        return exports.FIELD_VALUE_UNCHANGED;
+    }
+    if (!openGates(field, value, ruleContext))
+        return exports.FIELD_VALUE_UNCHANGED;
+    const mark = context.sink.count;
+    runChecks(field, value, ruleContext, context, mark);
+    const written = runTransforms(field, value, ruleContext, context, mark);
+    reenterPlan(field, written, ruleContext, context, mark);
+    if (written === read)
+        return exports.FIELD_VALUE_UNCHANGED;
+    return { hasWriteBack: true, value: written };
+}
+/**
+ * The default is substituted BEFORE anything else looks at the value, so
+ * validate() and parse() judge the same value. Only parse writes it back,
+ * which is the caller's decision and not this one's.
+ */
+function applyDefault(field, value, root) {
+    if (field.defaultOf === null)
+        return value;
+    if (value === undefined)
+        return field.defaultOf(root);
+    if (value === null && field.applyDefaultToNull)
+        return field.defaultOf(root);
+    return value;
+}
+/** A closed gate ends the field successfully: no check, no transform. */
+function openGates(field, value, ruleContext) {
+    for (const gate of field.gates) {
+        if (!gate.shouldRun(value, ruleContext))
+            return false;
+    }
+    return true;
+}
+function runChecks(field, value, ruleContext, context, mark) {
+    for (const check of field.checks) {
+        const outcome = check.run(value, ruleContext);
+        if (outcome.ok)
+            continue;
+        context.sink.add((0, create_issue_1.createIssue)({
+            path: ruleContext.path,
+            code: check.code,
+            severity: check.severity,
+            value,
+            render: (ctx) => check.describe(outcome.detail, ctx),
+        }));
+        if (context.sink.shouldStopField(mark))
+            return;
+    }
+}
+/** validate() never reaches a transform, and neither does a failed field. */
+function runTransforms(field, value, ruleContext, context, mark) {
+    if (!context.shouldApplyTransforms || context.sink.count !== mark) {
+        return value;
+    }
+    let current = value;
+    for (const transform of field.transforms) {
+        current = transform.apply(current, ruleContext);
+    }
+    return current;
+}
+/** Recursion is the field's last rule, so the field-level abort covers it. */
+function reenterPlan(field, value, ruleContext, context, mark) {
+    if (field.recursion === null || context.sink.shouldStopField(mark))
+        return;
+    context.runRecursion(field.recursion, value, ruleContext);
+}

package/dist/runtime/run-field.mjs

@@ -0,0 +1,84 @@
+import { createIssue } from "./create-issue.mjs";
+import { decidePresence } from "./decide-presence.mjs";
+/** Shared, frozen, never re-assigned: the common answer allocates nothing. */
+export const FIELD_VALUE_UNCHANGED = Object.freeze({
+    hasWriteBack: false,
+});
+export function runField(field, subject, context) {
+    const path = context.indices.renderFieldPath(field.template);
+    const ruleContext = {
+        root: context.root,
+        path,
+        item: context.item,
+        external: context.external,
+    };
+    const read = field.read(subject);
+    const value = applyDefault(field, read, context.root);
+    if (!decidePresence(field, value, ruleContext, context.sink)) {
+        return FIELD_VALUE_UNCHANGED;
+    }
+    if (!openGates(field, value, ruleContext))
+        return FIELD_VALUE_UNCHANGED;
+    const mark = context.sink.count;
+    runChecks(field, value, ruleContext, context, mark);
+    const written = runTransforms(field, value, ruleContext, context, mark);
+    reenterPlan(field, written, ruleContext, context, mark);
+    if (written === read)
+        return FIELD_VALUE_UNCHANGED;
+    return { hasWriteBack: true, value: written };
+}
+/**
+ * The default is substituted BEFORE anything else looks at the value, so
+ * validate() and parse() judge the same value. Only parse writes it back,
+ * which is the caller's decision and not this one's.
+ */
+function applyDefault(field, value, root) {
+    if (field.defaultOf === null)
+        return value;
+    if (value === undefined)
+        return field.defaultOf(root);
+    if (value === null && field.applyDefaultToNull)
+        return field.defaultOf(root);
+    return value;
+}
+/** A closed gate ends the field successfully: no check, no transform. */
+function openGates(field, value, ruleContext) {
+    for (const gate of field.gates) {
+        if (!gate.shouldRun(value, ruleContext))
+            return false;
+    }
+    return true;
+}
+function runChecks(field, value, ruleContext, context, mark) {
+    for (const check of field.checks) {
+        const outcome = check.run(value, ruleContext);
+        if (outcome.ok)
+            continue;
+        context.sink.add(createIssue({
+            path: ruleContext.path,
+            code: check.code,
+            severity: check.severity,
+            value,
+            render: (ctx) => check.describe(outcome.detail, ctx),
+        }));
+        if (context.sink.shouldStopField(mark))
+            return;
+    }
+}
+/** validate() never reaches a transform, and neither does a failed field. */
+function runTransforms(field, value, ruleContext, context, mark) {
+    if (!context.shouldApplyTransforms || context.sink.count !== mark) {
+        return value;
+    }
+    let current = value;
+    for (const transform of field.transforms) {
+        current = transform.apply(current, ruleContext);
+    }
+    return current;
+}
+/** Recursion is the field's last rule, so the field-level abort covers it. */
+function reenterPlan(field, value, ruleContext, context, mark) {
+    if (field.recursion === null || context.sink.shouldStopField(mark))
+        return;
+    context.runRecursion(field.recursion, value, ruleContext);
+}

package/dist/runtime/run-plan.d.ts

@@ -0,0 +1,28 @@
+import type { ValidationIssue } from "../types";
+import type { ValidationPlan } from "../compile/validation-plan.types";
+import type { FieldRunContext } from "./run-field";
+import type { ArrayWriteTarget } from "./output-writer";
+/**
+ * `targets` mirrors `plan.arrays` by position and defaults to empty, which is
+ * the honest description of every run that produces no output: a validate(),
+ * a branch, a recursive re-entry.
+ *
+ * Each field reads from `current`, the subject as earlier fields in this plan
+ * left it, so a rule on `a.b` sees a transform that rewrote `a`. `context.root`
+ * is NOT advanced: cross-field rules are written against the input the caller
+ * passed, and moving the root under them would make their answer depend on
+ * declaration order.
+ */
+export declare function runPlan(plan: ValidationPlan, subject: unknown, context: FieldRunContext, targets?: readonly ArrayWriteTarget[]): unknown;
+/**
+ * Re-bases the issues of a NESTED plan onto the path of the rule that entered
+ * it. A branch's fields and a recursive re-entry's fields are both declared
+ * relative to their own subject, so their issues come back as `name`; the
+ * enclosing rule knows the subject sits at `user`, and the consumer must read
+ * `user.name`.
+ *
+ * It lives here because both callers already depend on this module and neither
+ * may depend on the other — run-branch creates a recursion runner, so
+ * run-recursion could not own it without a cycle.
+ */
+export declare function prefixIssuePaths(prefix: string, issues: readonly ValidationIssue[]): readonly ValidationIssue[];

package/dist/runtime/run-plan.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPlan = runPlan;
+exports.prefixIssuePaths = prefixIssuePaths;
+const index_stack_1 = require("./index-stack");
+const run_array_node_1 = require("./run-array-node");
+const run_field_1 = require("./run-field");
+const output_writer_1 = require("./output-writer");
+/**
+ * `targets` mirrors `plan.arrays` by position and defaults to empty, which is
+ * the honest description of every run that produces no output: a validate(),
+ * a branch, a recursive re-entry.
+ *
+ * Each field reads from `current`, the subject as earlier fields in this plan
+ * left it, so a rule on `a.b` sees a transform that rewrote `a`. `context.root`
+ * is NOT advanced: cross-field rules are written against the input the caller
+ * passed, and moving the root under them would make their answer depend on
+ * declaration order.
+ */
+function runPlan(plan, subject, context, targets = output_writer_1.NO_WRITE_TARGETS) {
+    let current = subject;
+    for (const field of plan.fields) {
+        const outcome = (0, run_field_1.runField)(field, current, context);
+        current = (0, output_writer_1.writeFieldValue)(field, current, outcome, context.shouldApplyTransforms);
+        if (context.sink.shouldStopPlan())
+            return current;
+    }
+    return (0, run_array_node_1.runArrayNodes)(plan.arrays, current, context, targets);
+}
+/**
+ * Re-bases the issues of a NESTED plan onto the path of the rule that entered
+ * it. A branch's fields and a recursive re-entry's fields are both declared
+ * relative to their own subject, so their issues come back as `name`; the
+ * enclosing rule knows the subject sits at `user`, and the consumer must read
+ * `user.name`.
+ *
+ * It lives here because both callers already depend on this module and neither
+ * may depend on the other — run-branch creates a recursion runner, so
+ * run-recursion could not own it without a cycle.
+ */
+function prefixIssuePaths(prefix, issues) {
+    if (prefix === "")
+        return issues;
+    return issues.map((issue) => Object.freeze({
+        path: (0, index_stack_1.joinIssuePath)(prefix, issue.path),
+        code: issue.code,
+        message: issue.message,
+        severity: issue.severity,
+    }));
+}