@maroonedog/luq 2.1.0 → 2.3.0

package/dist/runtime/create-field-validator.mjs

@@ -53,15 +53,29 @@ function createSubjectComposer(template) {
         const write = createValueWriter(template);
         return (siblings, value) => write(siblings ?? {}, value);
     }
-    return (siblings, value) => mergeOntoSiblings(siblings, nestValue(template, 0, value));
+    const nest = compileNester(template);
+    return (siblings, value) => mergeOntoSiblings(siblings, nest(value));
 }
-function nestValue(template, from, value) {
-    const segment = template[from];
-    if (segment === undefined)
-        return value;
-    if (segment.kind === "each")
-        return [nestValue(template, from + 1, value)];
-    return { [segment.key]: nestValue(template, from + 1, value) };
+/**
+ * Walks the template **once** and folds it into a wrapping function.
+ *
+ * Walking it per validation re-read each segment's kind every time, which is
+ * exactly the thing validation time must not do: what something IS was settled
+ * at compile time. The non-wildcard route was always shaped this way.
+ */
+function compileNester(template) {
+    let nest = (value) => value;
+    for (let index = template.length - 1; index >= 0; index -= 1) {
+        const segment = template[index];
+        if (segment === undefined)
+            continue;
+        const inner = nest;
+        nest =
+            segment.kind === "each"
+                ? (value) => [inner(value)]
+                : ((key) => (value) => ({ [key]: inner(value) }))(segment.key);
+    }
+    return nest;
 }
 /** The wrapper wins on the key it names; every other sibling survives. */
 function mergeOntoSiblings(siblings, fragment) {

package/dist/runtime/create-validator.js

@@ -39,7 +39,34 @@ function rejectMissingRoot() {
 function hasRejectingIssue(issues) {
     return issues.some((issue) => issue.severity === "error");
 }
-function runRoot(plan, value, options, targets, shouldApplyTransforms) {
+/**
+ * The shared do-nothing runner for a plan that cannot recurse.
+ *
+ * Building a real runner allocates a WeakSet and several closures. Doing that
+ * on every validate() of a plan with no recursive rule in it was most of the
+ * fixed per-call cost. Whether a plan can recurse is known at build time and
+ * is not a question to re-ask at validation time.
+ *
+ * Never actually called: a field only reaches its runner when it declares
+ * recursion, and a plan containing one gets the real runner instead.
+ */
+const NO_RECURSION = () => { };
+/**
+ * Whether the root needs a real runner.
+ *
+ * Only the fields directly under the root and the elements of array nodes
+ * matter. A composite branch makes its own runner for the nested plan, so it
+ * never uses the one passed from here.
+ */
+function planCanRecurse(plan) {
+    return (plan.fields.some((field) => field.recursion !== null) ||
+        plan.arrays.some(nodeCanRecurse));
+}
+function nodeCanRecurse(node) {
+    return (node.elementFields.some((field) => field.recursion !== null) ||
+        node.nested.some(nodeCanRecurse));
+}
+function runRoot(plan, value, options, targets, shouldApplyTransforms, canRecurse) {
     if (value === null || value === undefined)
         return rejectMissingRoot();
     const sink = new issue_sink_1.IssueSink((0, issue_sink_1.resolveAbortPolicy)(options));
@@ -48,11 +75,13 @@ function runRoot(plan, value, options, targets, shouldApplyTransforms) {
         sink,
         indices: new index_stack_1.IndexStack(),
         shouldApplyTransforms,
-        runRecursion: (0, run_recursion_1.createRecursionRunner)({
-            root: value,
-            sink,
-            external: options?.external,
-        }),
+        runRecursion: canRecurse
+            ? (0, run_recursion_1.createRecursionRunner)({
+                root: value,
+                sink,
+                external: options?.external,
+            })
+            : NO_RECURSION,
         external: options?.external,
     }, targets);
     const issues = Object.freeze(sink.issues);
@@ -63,8 +92,9 @@ function runRoot(plan, value, options, targets, shouldApplyTransforms) {
 function createValidator(plan) {
     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),
-        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? output_writer_1.NO_WRITE_TARGETS, shouldWriteOutput),
+        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),
     };
 }

package/dist/runtime/create-validator.mjs

@@ -34,7 +34,34 @@ function rejectMissingRoot() {
 export function hasRejectingIssue(issues) {
     return issues.some((issue) => issue.severity === "error");
 }
-function runRoot(plan, value, options, targets, shouldApplyTransforms) {
+/**
+ * The shared do-nothing runner for a plan that cannot recurse.
+ *
+ * Building a real runner allocates a WeakSet and several closures. Doing that
+ * on every validate() of a plan with no recursive rule in it was most of the
+ * fixed per-call cost. Whether a plan can recurse is known at build time and
+ * is not a question to re-ask at validation time.
+ *
+ * Never actually called: a field only reaches its runner when it declares
+ * recursion, and a plan containing one gets the real runner instead.
+ */
+const NO_RECURSION = () => { };
+/**
+ * Whether the root needs a real runner.
+ *
+ * Only the fields directly under the root and the elements of array nodes
+ * matter. A composite branch makes its own runner for the nested plan, so it
+ * never uses the one passed from here.
+ */
+function planCanRecurse(plan) {
+    return (plan.fields.some((field) => field.recursion !== null) ||
+        plan.arrays.some(nodeCanRecurse));
+}
+function nodeCanRecurse(node) {
+    return (node.elementFields.some((field) => field.recursion !== null) ||
+        node.nested.some(nodeCanRecurse));
+}
+function runRoot(plan, value, options, targets, shouldApplyTransforms, canRecurse) {
     if (value === null || value === undefined)
         return rejectMissingRoot();
     const sink = new IssueSink(resolveAbortPolicy(options));
@@ -43,11 +70,13 @@ function runRoot(plan, value, options, targets, shouldApplyTransforms) {
         sink,
         indices: new IndexStack(),
         shouldApplyTransforms,
-        runRecursion: createRecursionRunner({
-            root: value,
-            sink,
-            external: options?.external,
-        }),
+        runRecursion: canRecurse
+            ? createRecursionRunner({
+                root: value,
+                sink,
+                external: options?.external,
+            })
+            : NO_RECURSION,
         external: options?.external,
     }, targets);
     const issues = Object.freeze(sink.issues);
@@ -58,8 +87,9 @@ function runRoot(plan, value, options, targets, shouldApplyTransforms) {
 export function createValidator(plan) {
     const parseTargets = createPlanWriteTargets(plan);
     const shouldWriteOutput = parseTargets !== null;
+    const canRecurse = planCanRecurse(plan);
     return {
-        validate: (value, options) => runRoot(plan, value, options, NO_WRITE_TARGETS, false),
-        parse: (value, options) => runRoot(plan, value, options, parseTargets ?? NO_WRITE_TARGETS, shouldWriteOutput),
+        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),
     };
 }

package/dist/runtime/field-rule-context.d.ts

@@ -0,0 +1,32 @@
+import type { ArrayItemContext, RuleContext } from "../types";
+import type { IndexStack } from "./index-stack";
+export declare class FieldRuleContext implements RuleContext {
+    readonly root: unknown;
+    private readonly indices;
+    /** Built at compile time, relative to the subject this field reads from. */
+    private readonly ownPath;
+    readonly item: ArrayItemContext | undefined;
+    readonly external: Readonly<Record<string, unknown>> | undefined;
+    /**
+     * The path once something has asked for it. `null` rather than `""` because
+     * the empty string is a real path — the root.
+     *
+     * It is remembered because the index stack underneath is MUTABLE and is
+     * popped when the element ends. A rule that kept its context and read `path`
+     * afterwards would otherwise see wherever the runner had moved on to.
+     * Reading it during the rule's own call — which is what every rule does —
+     * pins it.
+     */
+    private rendered;
+    constructor(root: unknown, indices: IndexStack, 
+    /** Built at compile time, relative to the subject this field reads from. */
+    ownPath: string, item: ArrayItemContext | undefined, external: Readonly<Record<string, unknown>> | undefined);
+    get path(): string;
+    /**
+     * Serialising a context is a thing people do when they log a failure, and a
+     * prototype getter would silently drop `path` from the output. This pins the
+     * JSON shape to the four DECLARED members and, as a side effect, stops the
+     * internals above from reaching a log line.
+     */
+    toJSON(): Record<string, unknown>;
+}

package/dist/runtime/field-rule-context.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldRuleContext = void 0;
+class FieldRuleContext {
+    constructor(root, indices, 
+    /** Built at compile time, relative to the subject this field reads from. */
+    ownPath, item, external) {
+        this.root = root;
+        this.indices = indices;
+        this.ownPath = ownPath;
+        this.item = item;
+        this.external = external;
+        /**
+         * The path once something has asked for it. `null` rather than `""` because
+         * the empty string is a real path — the root.
+         *
+         * It is remembered because the index stack underneath is MUTABLE and is
+         * popped when the element ends. A rule that kept its context and read `path`
+         * afterwards would otherwise see wherever the runner had moved on to.
+         * Reading it during the rule's own call — which is what every rule does —
+         * pins it.
+         */
+        this.rendered = null;
+    }
+    get path() {
+        const already = this.rendered;
+        if (already !== null)
+            return already;
+        const built = this.indices.renderFieldPath(this.ownPath);
+        this.rendered = built;
+        return built;
+    }
+    /**
+     * Serialising a context is a thing people do when they log a failure, and a
+     * prototype getter would silently drop `path` from the output. This pins the
+     * JSON shape to the four DECLARED members and, as a side effect, stops the
+     * internals above from reaching a log line.
+     */
+    toJSON() {
+        return {
+            root: this.root,
+            path: this.path,
+            item: this.item,
+            external: this.external,
+        };
+    }
+}
+exports.FieldRuleContext = FieldRuleContext;

package/dist/runtime/field-rule-context.mjs

@@ -0,0 +1,44 @@
+export class FieldRuleContext {
+    constructor(root, indices, 
+    /** Built at compile time, relative to the subject this field reads from. */
+    ownPath, item, external) {
+        this.root = root;
+        this.indices = indices;
+        this.ownPath = ownPath;
+        this.item = item;
+        this.external = external;
+        /**
+         * The path once something has asked for it. `null` rather than `""` because
+         * the empty string is a real path — the root.
+         *
+         * It is remembered because the index stack underneath is MUTABLE and is
+         * popped when the element ends. A rule that kept its context and read `path`
+         * afterwards would otherwise see wherever the runner had moved on to.
+         * Reading it during the rule's own call — which is what every rule does —
+         * pins it.
+         */
+        this.rendered = null;
+    }
+    get path() {
+        const already = this.rendered;
+        if (already !== null)
+            return already;
+        const built = this.indices.renderFieldPath(this.ownPath);
+        this.rendered = built;
+        return built;
+    }
+    /**
+     * Serialising a context is a thing people do when they log a failure, and a
+     * prototype getter would silently drop `path` from the output. This pins the
+     * JSON shape to the four DECLARED members and, as a side effect, stops the
+     * internals above from reaching a log line.
+     */
+    toJSON() {
+        return {
+            root: this.root,
+            path: this.path,
+            item: this.item,
+            external: this.external,
+        };
+    }
+}

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

@@ -1,11 +1,30 @@
-import type { PathSegment } from "../path/path-segment.types";
 export declare class IndexStack {
-    private readonly prefixes;
+    private readonly nodePaths;
     private readonly openIndices;
+    /**
+     * The rendered prefix, or `null` when it has not been asked for since the
+     * last push or pop. `null` and not `""` because the empty string is a real
+     * answer — the root.
+     *
+     * Invalidating rather than recomputing on push is the point: an element that
+     * raises no issue never renders its own prefix at all.
+     */
+    private currentPrefix;
     /** How many array levels are currently open. */
     get depth(): number;
     /** The open indices, outermost first: `[0, 2]` inside `grid[0][2]`. */
     get indices(): readonly number[];
+    /**
+     * The prefix for the currently open frames — `""` when none are open,
+     * `items[0]` inside one, `grid[0][2]` inside two.
+     *
+     * Indexed, never `nodePaths[nodePaths.length - 1]`. That expression at
+     * depth 0 is `nodePaths[-1]`, which is not an element read at all: -1 is
+     * outside the array, so V8 falls back to a named-property lookup and walks
+     * the prototype chain. The `prefix` getter used to be written that way and
+     * it took 12% of the array shape's self time.
+     */
+    private readTop;
     /** `""` at the root, `items[0]` inside the first element of `items`. */
     get prefix(): string;
     /**
@@ -21,8 +40,14 @@ export declare class IndexStack {
     push(nodePath: string, index: number): void;
     /** An unbalanced pop means a runner lost track of its own nesting. */
     pop(): void;
-    /** The issue path of a field read from the subject at the current level. */
-    renderFieldPath(template: readonly PathSegment[]): string;
+    /**
+     * The issue path of a field read from the subject at the current level.
+     *
+     * `renderedPath` was built once, at compile time. This used to walk the
+     * template on every call, which for an array meant rebuilding the same
+     * string once per element.
+     */
+    renderFieldPath(renderedPath: string): string;
 }
 /** `""` is the root path, so it never contributes a separator dot. */
 export declare function joinIssuePath(prefix: string, own: string): string;

package/dist/runtime/index-stack.js

@@ -1,19 +1,47 @@
 "use strict";
+// ===========================================================================
+// L5  src/runtime/index-stack.ts
+// Where the runtime currently is, expressed as a concrete issue path.
+//
+// An issue path must read `items[0].name`, never the declaration pattern
+// `items[*].name`. The legacy tree carried indices two different ways — the
+// nested-array processor threaded them through its own recursion while
+// validator-factory fell back to `error.path || elementPath` — which is how
+// the pattern string leaked into user-visible errors. There is one stack here
+// and every path a runner reports comes out of it.
+//
+// A CompiledField's template is RELATIVE to the subject it reads from, so an
+// element field of `items[*]` has the template `name` and could never render
+// `items[0].name` on its own. The array runner pushes the enclosing node and
+// the index; the stack renders the prefix.
+//
+// The prefix is rendered ON DEMAND and remembered until the next push or pop.
+// Entering used to build `items[0]` eagerly, which is one string per element
+// that nothing reads unless a rule fails — and now nothing reads it even then
+// until FieldRuleContext is asked for its path. Entering therefore costs two
+// pushes and one assignment, and the first field that asks pays the render.
+//
+// It is deliberately MUTABLE and pushed/popped around an element loop: one
+// 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.
+// ===========================================================================
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexStack = void 0;
 exports.joinIssuePath = joinIssuePath;
-const format_issue_path_1 = require("../path/format-issue-path");
-/**
- * A compiled template never contains a wildcard (createValueReader rejects
- * one), so rendering it needs no index. Passing none is what makes a stray
- * wildcard template throw here instead of silently rendering a second copy of
- * an index this stack has already written into the prefix.
- */
-const NO_INDICES = Object.freeze([]);
 class IndexStack {
     constructor() {
-        this.prefixes = [];
+        this.nodePaths = [];
         this.openIndices = [];
+        /**
+         * The rendered prefix, or `null` when it has not been asked for since the
+         * last push or pop. `null` and not `""` because the empty string is a real
+         * answer — the root.
+         *
+         * Invalidating rather than recomputing on push is the point: an element that
+         * raises no issue never renders its own prefix at all.
+         */
+        this.currentPrefix = null;
     }
     /** How many array levels are currently open. */
     get depth() {
@@ -23,9 +51,34 @@ class IndexStack {
     get indices() {
         return this.openIndices;
     }
+    /**
+     * The prefix for the currently open frames — `""` when none are open,
+     * `items[0]` inside one, `grid[0][2]` inside two.
+     *
+     * Indexed, never `nodePaths[nodePaths.length - 1]`. That expression at
+     * depth 0 is `nodePaths[-1]`, which is not an element read at all: -1 is
+     * outside the array, so V8 falls back to a named-property lookup and walks
+     * the prototype chain. The `prefix` getter used to be written that way and
+     * it took 12% of the array shape's self time.
+     */
+    readTop() {
+        const already = this.currentPrefix;
+        if (already !== null)
+            return already;
+        let built = "";
+        for (let i = 0; i < this.nodePaths.length; i += 1) {
+            const nodePath = this.nodePaths[i];
+            const index = this.openIndices[i];
+            if (nodePath === undefined || index === undefined)
+                continue;
+            built = `${joinIssuePath(built, nodePath)}[${index}]`;
+        }
+        this.currentPrefix = built;
+        return built;
+    }
     /** `""` at the root, `items[0]` inside the first element of `items`. */
     get prefix() {
-        return this.prefixes[this.prefixes.length - 1] ?? "";
+        return this.readTop();
     }
     /**
      * Enters element `index` of an array node. `nodePath` is the node's own path
@@ -41,20 +94,28 @@ class IndexStack {
         if (!Number.isInteger(index) || index < 0) {
             throw new RangeError(`an array index must be a non-negative integer, received ${String(index)}`);
         }
-        this.prefixes.push(`${joinIssuePath(this.prefix, nodePath)}[${index}]`);
+        this.nodePaths.push(nodePath);
         this.openIndices.push(index);
+        this.currentPrefix = null;
     }
     /** An unbalanced pop means a runner lost track of its own nesting. */
     pop() {
         if (this.openIndices.length === 0) {
             throw new RangeError("popped an array index that was never pushed");
         }
-        this.prefixes.pop();
+        this.nodePaths.pop();
         this.openIndices.pop();
+        this.currentPrefix = null;
     }
-    /** The issue path of a field read from the subject at the current level. */
-    renderFieldPath(template) {
-        return joinIssuePath(this.prefix, (0, format_issue_path_1.formatIssuePath)(template, NO_INDICES));
+    /**
+     * The issue path of a field read from the subject at the current level.
+     *
+     * `renderedPath` was built once, at compile time. This used to walk the
+     * template on every call, which for an array meant rebuilding the same
+     * string once per element.
+     */
+    renderFieldPath(renderedPath) {
+        return joinIssuePath(this.readTop(), renderedPath);
     }
 }
 exports.IndexStack = IndexStack;

package/dist/runtime/index-stack.mjs

@@ -1,15 +1,43 @@
-import { formatIssuePath } from "../path/format-issue-path.mjs";
-/**
- * A compiled template never contains a wildcard (createValueReader rejects
- * one), so rendering it needs no index. Passing none is what makes a stray
- * wildcard template throw here instead of silently rendering a second copy of
- * an index this stack has already written into the prefix.
- */
-const NO_INDICES = Object.freeze([]);
+// ===========================================================================
+// L5  src/runtime/index-stack.ts
+// Where the runtime currently is, expressed as a concrete issue path.
+//
+// An issue path must read `items[0].name`, never the declaration pattern
+// `items[*].name`. The legacy tree carried indices two different ways — the
+// nested-array processor threaded them through its own recursion while
+// validator-factory fell back to `error.path || elementPath` — which is how
+// the pattern string leaked into user-visible errors. There is one stack here
+// and every path a runner reports comes out of it.
+//
+// A CompiledField's template is RELATIVE to the subject it reads from, so an
+// element field of `items[*]` has the template `name` and could never render
+// `items[0].name` on its own. The array runner pushes the enclosing node and
+// the index; the stack renders the prefix.
+//
+// The prefix is rendered ON DEMAND and remembered until the next push or pop.
+// Entering used to build `items[0]` eagerly, which is one string per element
+// that nothing reads unless a rule fails — and now nothing reads it even then
+// until FieldRuleContext is asked for its path. Entering therefore costs two
+// pushes and one assignment, and the first field that asks pays the render.
+//
+// It is deliberately MUTABLE and pushed/popped around an element loop: one
+// 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.
+// ===========================================================================
 export class IndexStack {
     constructor() {
-        this.prefixes = [];
+        this.nodePaths = [];
         this.openIndices = [];
+        /**
+         * The rendered prefix, or `null` when it has not been asked for since the
+         * last push or pop. `null` and not `""` because the empty string is a real
+         * answer — the root.
+         *
+         * Invalidating rather than recomputing on push is the point: an element that
+         * raises no issue never renders its own prefix at all.
+         */
+        this.currentPrefix = null;
     }
     /** How many array levels are currently open. */
     get depth() {
@@ -19,9 +47,34 @@ export class IndexStack {
     get indices() {
         return this.openIndices;
     }
+    /**
+     * The prefix for the currently open frames — `""` when none are open,
+     * `items[0]` inside one, `grid[0][2]` inside two.
+     *
+     * Indexed, never `nodePaths[nodePaths.length - 1]`. That expression at
+     * depth 0 is `nodePaths[-1]`, which is not an element read at all: -1 is
+     * outside the array, so V8 falls back to a named-property lookup and walks
+     * the prototype chain. The `prefix` getter used to be written that way and
+     * it took 12% of the array shape's self time.
+     */
+    readTop() {
+        const already = this.currentPrefix;
+        if (already !== null)
+            return already;
+        let built = "";
+        for (let i = 0; i < this.nodePaths.length; i += 1) {
+            const nodePath = this.nodePaths[i];
+            const index = this.openIndices[i];
+            if (nodePath === undefined || index === undefined)
+                continue;
+            built = `${joinIssuePath(built, nodePath)}[${index}]`;
+        }
+        this.currentPrefix = built;
+        return built;
+    }
     /** `""` at the root, `items[0]` inside the first element of `items`. */
     get prefix() {
-        return this.prefixes[this.prefixes.length - 1] ?? "";
+        return this.readTop();
     }
     /**
      * Enters element `index` of an array node. `nodePath` is the node's own path
@@ -37,20 +90,28 @@ export class IndexStack {
         if (!Number.isInteger(index) || index < 0) {
             throw new RangeError(`an array index must be a non-negative integer, received ${String(index)}`);
         }
-        this.prefixes.push(`${joinIssuePath(this.prefix, nodePath)}[${index}]`);
+        this.nodePaths.push(nodePath);
         this.openIndices.push(index);
+        this.currentPrefix = null;
     }
     /** An unbalanced pop means a runner lost track of its own nesting. */
     pop() {
         if (this.openIndices.length === 0) {
             throw new RangeError("popped an array index that was never pushed");
         }
-        this.prefixes.pop();
+        this.nodePaths.pop();
         this.openIndices.pop();
+        this.currentPrefix = null;
     }
-    /** The issue path of a field read from the subject at the current level. */
-    renderFieldPath(template) {
-        return joinIssuePath(this.prefix, formatIssuePath(template, NO_INDICES));
+    /**
+     * The issue path of a field read from the subject at the current level.
+     *
+     * `renderedPath` was built once, at compile time. This used to walk the
+     * template on every call, which for an array meant rebuilding the same
+     * string once per element.
+     */
+    renderFieldPath(renderedPath) {
+        return joinIssuePath(this.readTop(), renderedPath);
     }
 }
 /** `""` is the root path, so it never contributes a separator dot. */

package/dist/runtime/output-writer.js

@@ -24,8 +24,12 @@ function createArrayWriteTargets(nodes) {
  * hands back the very object it was given.
  */
 function createPlanWriteTargets(plan) {
-    if (!plan.hasTransforms && !plan.hasDefaults)
+    // A field declaring only a normalizer is still written back by parse().
+    // Leave it out of this condition and no writer is made, so the value read
+    // comes back unchanged and in silence.
+    if (!plan.hasTransforms && !plan.hasDefaults && !plan.hasNormalizers) {
         return null;
+    }
     return createArrayWriteTargets(plan.arrays);
 }
 /**

package/dist/runtime/output-writer.mjs

@@ -17,8 +17,12 @@ export function createArrayWriteTargets(nodes) {
  * hands back the very object it was given.
  */
 export function createPlanWriteTargets(plan) {
-    if (!plan.hasTransforms && !plan.hasDefaults)
+    // A field declaring only a normalizer is still written back by parse().
+    // Leave it out of this condition and no writer is made, so the value read
+    // comes back unchanged and in silence.
+    if (!plan.hasTransforms && !plan.hasDefaults && !plan.hasNormalizers) {
         return null;
+    }
     return createArrayWriteTargets(plan.arrays);
 }
 /**