@maroonedog/luq 0.1.2-alpha → 2.1.0

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;
+}

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);
+}