@maroonedog/luq 2.4.2 → 2.4.3

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,7 +9,7 @@ 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";

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

package/dist/runtime/index.mjs

@@ -9,7 +9,7 @@ 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, createValidator, hasRejectingIssue, } from "./create-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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maroonedog/luq",
-  "version": "2.4.2",
+  "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",