@maroonedog/luq 2.4.1 → 2.4.3

package/dist/builder/compile-declarations.d.ts

@@ -1,10 +1,16 @@
 import type { ValidationPlan } from "../compile/validation-plan.types";
-import type { GlobalConfig } from "../types/global-config";
+import type { GlobalConfig, ResolvedGlobalConfig } from "../types/global-config";
 import type { FieldEntry } from "./field-entry.types";
 import type { FieldDeclaredCalls } from "./field-declared-calls.types";
 /** What build() makes in one pass: the plan to run, and what was declared. */
 export interface CompiledDeclarations {
     readonly plan: ValidationPlan;
     readonly declaredCalls: readonly FieldDeclaredCalls[];
+    /**
+     * Resolved once here, and carried out because the root short-circuit needs
+     * it too. That rejection happens before any rule, so it cannot read the
+     * config the way a plugin does — through RuleBuildContext.
+     */
+    readonly config: ResolvedGlobalConfig;
 }
 export declare function compileDeclarations(entries: readonly FieldEntry[], configOverride: GlobalConfig | undefined): CompiledDeclarations;

package/dist/builder/compile-declarations.js

@@ -46,5 +46,6 @@ function compileDeclarations(entries, configOverride) {
     return {
         plan: (0, compile_schema_1.compileSchema)(declarations, (0, run_branch_1.createBranchExecutor)()),
         declaredCalls,
+        config,
     };
 }

package/dist/builder/compile-declarations.mjs

@@ -43,5 +43,6 @@ export function compileDeclarations(entries, configOverride) {
     return {
         plan: compileSchema(declarations, createBranchExecutor()),
         declaredCalls,
+        config,
     };
 }

package/dist/builder/create-field-builder.js

@@ -27,7 +27,7 @@ const NO_ENTRIES = Object.freeze([]);
  */
 function buildValidator(entries, configOverride) {
     const compiled = (0, compile_declarations_1.compileDeclarations)(entries, configOverride);
-    const validator = (0, create_plan_validator_1.createPlanBackedValidator)(compiled.plan);
+    const validator = (0, create_plan_validator_1.createPlanBackedValidator)(compiled.plan, compiled.config);
     (0, declared_calls_store_1.rememberDeclaredCalls)(validator, compiled.declaredCalls);
     return validator;
 }

package/dist/builder/create-field-builder.mjs

@@ -24,7 +24,7 @@ const NO_ENTRIES = Object.freeze([]);
  */
 function buildValidator(entries, configOverride) {
     const compiled = compileDeclarations(entries, configOverride);
-    const validator = createPlanBackedValidator(compiled.plan);
+    const validator = createPlanBackedValidator(compiled.plan, compiled.config);
     rememberDeclaredCalls(validator, compiled.declaredCalls);
     return validator;
 }

package/dist/builder/create-plan-validator.d.ts

@@ -1,3 +1,4 @@
 import type { ValidationPlan } from "../compile/validation-plan.types";
+import type { ResolvedGlobalConfig } from "../types/global-config";
 import type { PlanBackedValidator } from "./builder-surface.types";
-export declare function createPlanBackedValidator(plan: ValidationPlan): PlanBackedValidator;
+export declare function createPlanBackedValidator(plan: ValidationPlan, config: ResolvedGlobalConfig): PlanBackedValidator;

package/dist/builder/create-plan-validator.js

@@ -4,8 +4,8 @@ exports.createPlanBackedValidator = createPlanBackedValidator;
 const create_field_validator_1 = require("../runtime/create-field-validator");
 const create_validator_1 = require("../runtime/create-validator");
 const create_subset_validator_1 = require("./create-subset-validator");
-function createPlanBackedValidator(plan) {
-    const validator = (0, create_validator_1.createValidator)(plan);
+function createPlanBackedValidator(plan, config) {
+    const validator = (0, create_validator_1.createValidator)(plan, config);
     return Object.freeze({
         validate: validator.validate,
         parse: validator.parse,

package/dist/builder/create-plan-validator.mjs

@@ -1,8 +1,8 @@
 import { createFieldValidator } from "../runtime/create-field-validator.mjs";
 import { createValidator } from "../runtime/create-validator.mjs";
 import { createSubsetValidator } from "./create-subset-validator.mjs";
-export function createPlanBackedValidator(plan) {
-    const validator = createValidator(plan);
+export function createPlanBackedValidator(plan, config) {
+    const validator = createValidator(plan, config);
     return Object.freeze({
         validate: validator.validate,
         parse: validator.parse,

package/dist/runtime/create-validator.d.ts

@@ -1,14 +1,22 @@
 import type { ValidationIssue } from "../types";
 import type { ValidateOptions, ValidationResult } from "../types/validation-result.types";
 import type { ValidationPlan } from "../compile/validation-plan.types";
+import { type ResolvedGlobalConfig } from "../types/global-config";
 /** The untyped pair. L6 puts the declared type back on top of it. */
 export interface PlanValidator {
     validate(value: unknown, options?: ValidateOptions): ValidationResult<unknown>;
     parse(value: unknown, options?: ValidateOptions): ValidationResult<unknown>;
 }
-/** The legacy root short-circuit, wording included (validator-factory.ts:498). */
-export declare const ROOT_MISSING_CODE = "REQUIRED";
-export declare const ROOT_MISSING_MESSAGE = "Value is required";
+/**
+ * The code an absent SUBJECT reports.
+ *
+ * The same spelling a missing FIELD reports, deliberately. It was "REQUIRED"
+ * — 1.x's SCREAMING_SNAKE, carried over with the wording — which meant a
+ * caller switching on issue.code handled `required` for a missing field and
+ * missed the root, where the only difference is how much of the value was
+ * absent.
+ */
+export declare const ROOT_MISSING_CODE = "required";
 /**
  * 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
@@ -16,4 +24,4 @@ export declare const ROOT_MISSING_MESSAGE = "Value is required";
  * an `issues` list at all.
  */
 export declare function hasRejectingIssue(issues: readonly ValidationIssue[]): boolean;
-export declare function createValidator(plan: ValidationPlan): PlanValidator;
+export declare function createValidator(plan: ValidationPlan, config?: ResolvedGlobalConfig): PlanValidator;

package/dist/runtime/create-validator.js

@@ -1,30 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ROOT_MISSING_MESSAGE = exports.ROOT_MISSING_CODE = void 0;
+exports.ROOT_MISSING_CODE = void 0;
 exports.hasRejectingIssue = hasRejectingIssue;
 exports.createValidator = createValidator;
+const global_config_1 = require("../types/global-config");
 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";
+/**
+ * The code an absent SUBJECT reports.
+ *
+ * The same spelling a missing FIELD reports, deliberately. It was "REQUIRED"
+ * — 1.x's SCREAMING_SNAKE, carried over with the wording — which meant a
+ * caller switching on issue.code handled `required` for a missing field and
+ * missed the root, where the only difference is how much of the value was
+ * absent.
+ */
+exports.ROOT_MISSING_CODE = "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() {
+function rejectMissingRoot(config) {
     return {
         valid: false,
         issues: Object.freeze([
             Object.freeze({
                 path: "",
                 code: exports.ROOT_MISSING_CODE,
-                message: exports.ROOT_MISSING_MESSAGE,
+                message: config.rootMissingMessage,
+                // Not config.defaultSeverity. A warning here would let validate(null)
+                // report success for a schema that declares nothing required, which is
+                // the outcome this rejection exists to prevent.
                 severity: "error",
             }),
         ]),
@@ -66,9 +77,9 @@ function nodeCanRecurse(node) {
     return (node.elementFields.some((field) => field.recursion !== null) ||
         node.nested.some(nodeCanRecurse));
 }
-function runRoot(plan, value, options, targets, shouldApplyTransforms, canRecurse) {
+function runRoot(plan, config, value, options, targets, shouldApplyTransforms, canRecurse) {
     if (value === null || value === undefined)
-        return rejectMissingRoot();
+        return rejectMissingRoot(config);
     const sink = new issue_sink_1.IssueSink((0, issue_sink_1.resolveAbortPolicy)(options));
     const output = (0, run_plan_1.runPlan)(plan, value, {
         root: value,
@@ -89,12 +100,12 @@ function runRoot(plan, value, options, targets, shouldApplyTransforms, canRecurs
         return { valid: false, issues };
     return { valid: true, data: output, issues };
 }
-function createValidator(plan) {
+function createValidator(plan, config = global_config_1.DEFAULT_GLOBAL_CONFIG) {
     const parseTargets = (0, output_writer_1.createPlanWriteTargets)(plan);
     const shouldWriteOutput = parseTargets !== null;
     const canRecurse = planCanRecurse(plan);
     return {
-        validate: (value, options) => runRoot(plan, value, options, output_writer_1.NO_WRITE_TARGETS, false, canRecurse),
-        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? output_writer_1.NO_WRITE_TARGETS, shouldWriteOutput, canRecurse),
+        validate: (value, options) => runRoot(plan, config, value, options, output_writer_1.NO_WRITE_TARGETS, false, canRecurse),
+        parse: (value, options) => runRoot(plan, config, value, options, parseTargets ?? output_writer_1.NO_WRITE_TARGETS, shouldWriteOutput, canRecurse),
     };
 }

package/dist/runtime/create-validator.mjs

@@ -1,25 +1,36 @@
+import { DEFAULT_GLOBAL_CONFIG, } from "../types/global-config.mjs";
 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";
+/**
+ * The code an absent SUBJECT reports.
+ *
+ * The same spelling a missing FIELD reports, deliberately. It was "REQUIRED"
+ * — 1.x's SCREAMING_SNAKE, carried over with the wording — which meant a
+ * caller switching on issue.code handled `required` for a missing field and
+ * missed the root, where the only difference is how much of the value was
+ * absent.
+ */
+export const ROOT_MISSING_CODE = "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() {
+function rejectMissingRoot(config) {
     return {
         valid: false,
         issues: Object.freeze([
             Object.freeze({
                 path: "",
                 code: ROOT_MISSING_CODE,
-                message: ROOT_MISSING_MESSAGE,
+                message: config.rootMissingMessage,
+                // Not config.defaultSeverity. A warning here would let validate(null)
+                // report success for a schema that declares nothing required, which is
+                // the outcome this rejection exists to prevent.
                 severity: "error",
             }),
         ]),
@@ -61,9 +72,9 @@ function nodeCanRecurse(node) {
     return (node.elementFields.some((field) => field.recursion !== null) ||
         node.nested.some(nodeCanRecurse));
 }
-function runRoot(plan, value, options, targets, shouldApplyTransforms, canRecurse) {
+function runRoot(plan, config, value, options, targets, shouldApplyTransforms, canRecurse) {
     if (value === null || value === undefined)
-        return rejectMissingRoot();
+        return rejectMissingRoot(config);
     const sink = new IssueSink(resolveAbortPolicy(options));
     const output = runPlan(plan, value, {
         root: value,
@@ -84,12 +95,12 @@ function runRoot(plan, value, options, targets, shouldApplyTransforms, canRecurs
         return { valid: false, issues };
     return { valid: true, data: output, issues };
 }
-export function createValidator(plan) {
+export function createValidator(plan, config = DEFAULT_GLOBAL_CONFIG) {
     const parseTargets = createPlanWriteTargets(plan);
     const shouldWriteOutput = parseTargets !== null;
     const canRecurse = planCanRecurse(plan);
     return {
-        validate: (value, options) => runRoot(plan, value, options, NO_WRITE_TARGETS, false, canRecurse),
-        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? NO_WRITE_TARGETS, shouldWriteOutput, canRecurse),
+        validate: (value, options) => runRoot(plan, config, value, options, NO_WRITE_TARGETS, false, canRecurse),
+        parse: (value, options) => runRoot(plan, config, value, options, parseTargets ?? NO_WRITE_TARGETS, shouldWriteOutput, canRecurse),
     };
 }

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

@@ -1,4 +1,5 @@
 export declare class IndexStack {
+    private readonly basePath;
     private readonly nodePaths;
     private readonly openIndices;
     /**
@@ -10,6 +11,11 @@ export declare class IndexStack {
      * raises no issue never renders its own prefix at all.
      */
     private currentPrefix;
+    /**
+     * Where this run sits inside the whole value: `""` for the run the caller
+     * started, and the entering rule's path for a branch or a recursive re-entry.
+     */
+    constructor(basePath?: string);
     /** How many array levels are currently open. */
     get depth(): number;
     /** The open indices, outermost first: `[0, 2]` inside `grid[0][2]`. */
@@ -25,7 +31,10 @@ export declare class IndexStack {
      * it took 12% of the array shape's self time.
      */
     private readTop;
-    /** `""` at the root, `items[0]` inside the first element of `items`. */
+    /**
+     * `""` at the root of the run the caller started, `items[0]` inside the first
+     * element of `items`, and the base path when a nested run has no array open.
+     */
     get prefix(): string;
     /**
      * Enters element `index` of an array node. `nodePath` is the node's own path

package/dist/runtime/index-stack.js

@@ -25,12 +25,25 @@
 // stack lives for one validate() call, and 10k elements must not allocate 10k
 // index arrays. It is also why FieldRuleContext remembers the path it built —
 // this stack has moved on by the time a retained context could read it.
+//
+// A NESTED run starts from a BASE PATH rather than from the root. A branch plan
+// and a recursive re-entry each declare their fields against their own subject,
+// so a field renders `name` where the consumer must read `user.name`. The base
+// is handed to the stack, so the path is right the first time it is built — and
+// the message, which is rendered from that same path, names the field the issue
+// reports. Rewriting the path afterwards cannot do that: by then the message has
+// already been rendered against the short one.
 // ===========================================================================
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexStack = void 0;
 exports.joinIssuePath = joinIssuePath;
 class IndexStack {
-    constructor() {
+    /**
+     * Where this run sits inside the whole value: `""` for the run the caller
+     * started, and the entering rule's path for a branch or a recursive re-entry.
+     */
+    constructor(basePath = "") {
+        this.basePath = basePath;
         this.nodePaths = [];
         this.openIndices = [];
         /**
@@ -65,7 +78,7 @@ class IndexStack {
         const already = this.currentPrefix;
         if (already !== null)
             return already;
-        let built = "";
+        let built = this.basePath;
         for (let i = 0; i < this.nodePaths.length; i += 1) {
             const nodePath = this.nodePaths[i];
             const index = this.openIndices[i];
@@ -76,7 +89,10 @@ class IndexStack {
         this.currentPrefix = built;
         return built;
     }
-    /** `""` at the root, `items[0]` inside the first element of `items`. */
+    /**
+     * `""` at the root of the run the caller started, `items[0]` inside the first
+     * element of `items`, and the base path when a nested run has no array open.
+     */
     get prefix() {
         return this.readTop();
     }

package/dist/runtime/index-stack.mjs

@@ -24,9 +24,22 @@
 // stack lives for one validate() call, and 10k elements must not allocate 10k
 // index arrays. It is also why FieldRuleContext remembers the path it built —
 // this stack has moved on by the time a retained context could read it.
+//
+// A NESTED run starts from a BASE PATH rather than from the root. A branch plan
+// and a recursive re-entry each declare their fields against their own subject,
+// so a field renders `name` where the consumer must read `user.name`. The base
+// is handed to the stack, so the path is right the first time it is built — and
+// the message, which is rendered from that same path, names the field the issue
+// reports. Rewriting the path afterwards cannot do that: by then the message has
+// already been rendered against the short one.
 // ===========================================================================
 export class IndexStack {
-    constructor() {
+    /**
+     * Where this run sits inside the whole value: `""` for the run the caller
+     * started, and the entering rule's path for a branch or a recursive re-entry.
+     */
+    constructor(basePath = "") {
+        this.basePath = basePath;
         this.nodePaths = [];
         this.openIndices = [];
         /**
@@ -61,7 +74,7 @@ export class IndexStack {
         const already = this.currentPrefix;
         if (already !== null)
             return already;
-        let built = "";
+        let built = this.basePath;
         for (let i = 0; i < this.nodePaths.length; i += 1) {
             const nodePath = this.nodePaths[i];
             const index = this.openIndices[i];
@@ -72,7 +85,10 @@ export class IndexStack {
         this.currentPrefix = built;
         return built;
     }
-    /** `""` at the root, `items[0]` inside the first element of `items`. */
+    /**
+     * `""` at the root of the run the caller started, `items[0]` inside the first
+     * element of `items`, and the base path when a nested run has no array open.
+     */
     get prefix() {
         return this.readTop();
     }

package/dist/runtime/index.d.ts

@@ -9,11 +9,11 @@ export type { FieldRunContext, FieldRunOutcome, RecursionRunner, } from "./run-f
 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 { 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 { ROOT_MISSING_CODE, 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

@@ -1,6 +1,6 @@
 "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;
+exports.createFieldValidator = exports.hasRejectingIssue = exports.createValidator = exports.ROOT_MISSING_CODE = exports.createBranchExecutor = exports.BRANCH_ABORT_POLICY = exports.createRecursionRunner = exports.RECURSION_ABORT_POLICY = exports.runPlan = 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.
@@ -31,7 +31,6 @@ Object.defineProperty(exports, "writeFieldValue", { enumerable: true, get: funct
 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; } });
@@ -41,7 +40,6 @@ Object.defineProperty(exports, "BRANCH_ABORT_POLICY", { enumerable: true, get: f
 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");

package/dist/runtime/index.mjs

@@ -9,8 +9,8 @@ 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 { 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 { ROOT_MISSING_CODE, createValidator, hasRejectingIssue, } from "./create-validator.mjs";
 export { createFieldValidator } from "./create-field-validator.mjs";

package/dist/runtime/run-branch.js

@@ -48,7 +48,13 @@ function createBranchExecutor() {
             (0, run_plan_1.runPlan)(plan, value, {
                 root: ruleContext.root,
                 sink,
-                indices: new index_stack_1.IndexStack(),
+                // The branch plan's fields are declared against the branch's own
+                // subject, so a field of it renders `name` while the consumer must read
+                // `user.name`. Starting the stack at the composite's path is what makes
+                // the cause's message agree with the cause's path: both come from here,
+                // and a message rendered against the short path could not be corrected
+                // afterwards.
+                indices: new index_stack_1.IndexStack(ruleContext.path),
                 shouldApplyTransforms: false,
                 runRecursion: (0, run_recursion_1.createRecursionRunner)({
                     root: ruleContext.root,
@@ -60,8 +66,7 @@ function createBranchExecutor() {
             });
             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) });
+            return (0, types_1.fail)({ causes: Object.freeze(sink.issues) });
         },
     };
 }

package/dist/runtime/run-branch.mjs

@@ -22,7 +22,7 @@ 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";
+import { 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
@@ -44,7 +44,13 @@ export function createBranchExecutor() {
             runPlan(plan, value, {
                 root: ruleContext.root,
                 sink,
-                indices: new IndexStack(),
+                // The branch plan's fields are declared against the branch's own
+                // subject, so a field of it renders `name` while the consumer must read
+                // `user.name`. Starting the stack at the composite's path is what makes
+                // the cause's message agree with the cause's path: both come from here,
+                // and a message rendered against the short path could not be corrected
+                // afterwards.
+                indices: new IndexStack(ruleContext.path),
                 shouldApplyTransforms: false,
                 runRecursion: createRecursionRunner({
                     root: ruleContext.root,
@@ -56,8 +62,7 @@ export function createBranchExecutor() {
             });
             if (sink.count === 0)
                 return PASS;
-            const causes = prefixIssuePaths(ruleContext.path, sink.issues);
-            return fail({ causes: Object.freeze(causes) });
+            return fail({ causes: Object.freeze(sink.issues) });
         },
     };
 }

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

@@ -1,4 +1,3 @@
-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";
@@ -15,14 +14,9 @@ import type { ArrayWriteTarget } from "./output-writer";
  */
 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.
+ * A nested plan does NOT come back to have its issue paths corrected. A branch
+ * and a recursive re-entry each start their IndexStack at the entering rule's
+ * path, so every issue is built at its full path and its message is rendered
+ * from that same path. Rewriting the path afterwards used to leave the message
+ * naming the field's short name, so one issue reported two different fields.
  */
-export declare function prefixIssuePaths(prefix: string, issues: readonly ValidationIssue[]): readonly ValidationIssue[];

package/dist/runtime/run-plan.js

@@ -1,8 +1,6 @@
 "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");
@@ -32,23 +30,9 @@ function runPlan(plan, subject, context, targets = output_writer_1.NO_WRITE_TARG
     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.
+ * A nested plan does NOT come back to have its issue paths corrected. A branch
+ * and a recursive re-entry each start their IndexStack at the entering rule's
+ * path, so every issue is built at its full path and its message is rendered
+ * from that same path. Rewriting the path afterwards used to leave the message
+ * naming the field's short name, so one issue reported two different fields.
  */
-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,
-    }));
-}

package/dist/runtime/run-plan.mjs

@@ -1,4 +1,3 @@
-import { joinIssuePath } from "./index-stack.mjs";
 import { runArrayNodes } from "./run-array-node.mjs";
 import { runField } from "./run-field.mjs";
 import { NO_WRITE_TARGETS, writeFieldValue } from "./output-writer.mjs";
@@ -28,23 +27,9 @@ export function runPlan(plan, subject, context, targets = NO_WRITE_TARGETS) {
     return 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.
+ * A nested plan does NOT come back to have its issue paths corrected. A branch
+ * and a recursive re-entry each start their IndexStack at the entering rule's
+ * path, so every issue is built at its full path and its message is rendered
+ * from that same path. Rewriting the path afterwards used to leave the message
+ * naming the field's short name, so one issue reported two different fields.
  */
-export function prefixIssuePaths(prefix, issues) {
-    if (prefix === "")
-        return issues;
-    return issues.map((issue) => Object.freeze({
-        path: joinIssuePath(prefix, issue.path),
-        code: issue.code,
-        message: issue.message,
-        severity: issue.severity,
-    }));
-}

package/dist/runtime/run-recursion.js

@@ -15,11 +15,13 @@ exports.createRecursionRunner = createRecursionRunner;
 //     Legacy truncated at maxDepth as a SUCCESS, which meant a structure deeper
 //     than the limit silently skipped every rule below it.
 //
-// The nested plan runs into its OWN sink and its OWN index stack, and its
-// issues are re-based onto the entering field's path afterwards. That is what
-// makes `node.child.name` come out right: the plan's fields are declared
-// relative to the plan's subject and know nothing about where they were
-// re-entered from.
+// The nested plan runs into its OWN sink, and its OWN index stack STARTED AT
+// the entering field's path. That is what makes `node.child.name` come out
+// right: the plan's fields are declared relative to the plan's subject and know
+// nothing about where they were re-entered from, so the stack is what carries
+// the descent. Giving it the path up front rather than rewriting the issues
+// afterwards is also what makes a message agree with the path beside it — a
+// message is rendered once, from that path, at the moment the issue is built.
 //
 // A re-entry never writes. RecursionRunner returns void by contract, so there
 // is nowhere for a transformed subtree to go; recursion is validation, and
@@ -88,12 +90,12 @@ function bindRecursionRunner(host, progress) {
         (0, run_plan_1.runPlan)(policy.plan.resolve(), value, {
             root: host.root,
             sink: nested,
-            indices: new index_stack_1.IndexStack(),
+            indices: new index_stack_1.IndexStack(path),
             shouldApplyTransforms: false,
             runRecursion: bindRecursionRunner({ ...host, sink: nested }, progress),
             external: host.external,
         });
-        for (const issue of (0, run_plan_1.prefixIssuePaths)(path, nested.issues)) {
+        for (const issue of nested.issues) {
             host.sink.add(issue);
         }
     }

package/dist/runtime/run-recursion.mjs

@@ -11,11 +11,13 @@
 //     Legacy truncated at maxDepth as a SUCCESS, which meant a structure deeper
 //     than the limit silently skipped every rule below it.
 //
-// The nested plan runs into its OWN sink and its OWN index stack, and its
-// issues are re-based onto the entering field's path afterwards. That is what
-// makes `node.child.name` come out right: the plan's fields are declared
-// relative to the plan's subject and know nothing about where they were
-// re-entered from.
+// The nested plan runs into its OWN sink, and its OWN index stack STARTED AT
+// the entering field's path. That is what makes `node.child.name` come out
+// right: the plan's fields are declared relative to the plan's subject and know
+// nothing about where they were re-entered from, so the stack is what carries
+// the descent. Giving it the path up front rather than rewriting the issues
+// afterwards is also what makes a message agree with the path beside it — a
+// message is rendered once, from that path, at the moment the issue is built.
 //
 // A re-entry never writes. RecursionRunner returns void by contract, so there
 // is nowhere for a transformed subtree to go; recursion is validation, and
@@ -25,7 +27,7 @@ import { isArray } from "../types/index.mjs";
 import { createIssue } from "./create-issue.mjs";
 import { IndexStack } from "./index-stack.mjs";
 import { IssueSink } from "./issue-sink.mjs";
-import { prefixIssuePaths, runPlan } from "./run-plan.mjs";
+import { runPlan } from "./run-plan.mjs";
 /**
  * Legacy contract, kept: fields do not abort each other inside a recursive
  * re-entry. A descent that stopped at its first issue would report one leaf of
@@ -84,12 +86,12 @@ function bindRecursionRunner(host, progress) {
         runPlan(policy.plan.resolve(), value, {
             root: host.root,
             sink: nested,
-            indices: new IndexStack(),
+            indices: new IndexStack(path),
             shouldApplyTransforms: false,
             runRecursion: bindRecursionRunner({ ...host, sink: nested }, progress),
             external: host.external,
         });
-        for (const issue of prefixIssuePaths(path, nested.issues)) {
+        for (const issue of nested.issues) {
             host.sink.add(issue);
         }
     }

package/dist/types/global-config.d.ts

@@ -15,6 +15,17 @@ export interface GlobalConfig {
     readonly customTransforms?: Readonly<Record<string, ValueTransform>>;
     /** Severity a rule emits when neither the rule nor the call names one. */
     readonly defaultSeverity?: IssueSeverity;
+    /**
+     * What `validate(null)` and `validate(undefined)` say.
+     *
+     * A subject that is absent fails before the plan runs, so there is no rule
+     * to carry a messageFactory and no call site to name one. This is where it
+     * is said instead. The severity is NOT settable with it: a warning here
+     * would let `validate(null)` report success for a schema that declares
+     * nothing required, which is the outcome the short-circuit exists to
+     * prevent.
+     */
+    readonly rootMissingMessage?: string;
 }
 /** Every member present: this is what a plugin reads. */
 export interface ResolvedGlobalConfig {
@@ -26,6 +37,7 @@ export interface ResolvedGlobalConfig {
     readonly caseSensitive: boolean;
     readonly customTransforms: Readonly<Record<string, ValueTransform>>;
     readonly defaultSeverity: IssueSeverity;
+    readonly rootMissingMessage: string;
 }
 export declare const DEFAULT_GLOBAL_CONFIG: ResolvedGlobalConfig;
 export declare function resolveGlobalConfig(overrides: GlobalConfig | undefined, base?: ResolvedGlobalConfig): ResolvedGlobalConfig;

package/dist/types/global-config.js

@@ -14,6 +14,7 @@ exports.DEFAULT_GLOBAL_CONFIG = Object.freeze({
     caseSensitive: true,
     customTransforms: Object.freeze({}),
     defaultSeverity: "error",
+    rootMissingMessage: "Value is required",
 });
 function resolveGlobalConfig(overrides, base = exports.DEFAULT_GLOBAL_CONFIG) {
     if (overrides === undefined)
@@ -32,5 +33,6 @@ function resolveGlobalConfig(overrides, base = exports.DEFAULT_GLOBAL_CONFIG) {
         caseSensitive: overrides.caseSensitive ?? base.caseSensitive,
         customTransforms: overrides.customTransforms ?? base.customTransforms,
         defaultSeverity: overrides.defaultSeverity ?? base.defaultSeverity,
+        rootMissingMessage: overrides.rootMissingMessage ?? base.rootMissingMessage,
     });
 }

package/dist/types/global-config.mjs

@@ -10,6 +10,7 @@ export const DEFAULT_GLOBAL_CONFIG = Object.freeze({
     caseSensitive: true,
     customTransforms: Object.freeze({}),
     defaultSeverity: "error",
+    rootMissingMessage: "Value is required",
 });
 export function resolveGlobalConfig(overrides, base = DEFAULT_GLOBAL_CONFIG) {
     if (overrides === undefined)
@@ -28,5 +29,6 @@ export function resolveGlobalConfig(overrides, base = DEFAULT_GLOBAL_CONFIG) {
         caseSensitive: overrides.caseSensitive ?? base.caseSensitive,
         customTransforms: overrides.customTransforms ?? base.customTransforms,
         defaultSeverity: overrides.defaultSeverity ?? base.defaultSeverity,
+        rootMissingMessage: overrides.rootMissingMessage ?? base.rootMissingMessage,
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maroonedog/luq",
-  "version": "2.4.1",
+  "version": "2.4.3",
   "description": "Universal Model & API Definition Platform - TypeScript validation library evolving into cross-language code generation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",