footprintjs 9.23.0 → 9.23.2

package/dist/esm/lib/reactive/arrayTraps.d.ts

@@ -38,9 +38,9 @@
  *
  * Now an indexed read of a wrappable element returns an ELEMENT PROXY that
  * accumulates the path inside the element and, on write, rebuilds the array
- * immutably ({@link setInPath}) and hands the whole new array to `commit` —
- * the same funnel `push` already used. One write path for the whole array,
- * whatever depth it is addressed at.
+ * immutably (`structuralWrite.setInPath`, behind `writeTraps.elementSink`)
+ * and hands the whole new array to `commit` — the same funnel `push` already
+ * used. One write path for the whole array, whatever depth it is addressed at.
  *
  * ── What is still NOT seen (by design) ───────────────────────────────────
  * Elements reached WITHOUT an index — `find()`, `filter()`, `for…of`,
@@ -50,10 +50,30 @@
  * not lost in silence either: `StageContext` compares what a stage READ with
  * what the value holds at commit and, in dev mode, warns with the exact path.
  * See src/lib/reactive/README.md.
+ *
+ * ── Shape (9.23.1) ───────────────────────────────────────────────────────
+ * `createArrayProxy` and `createElementProxy` are ORCHESTRATORS: they wire
+ * traps and hold the caches. Every trap body is a named leaf below — one
+ * concern each — and the element proxy's set/delete/get traps are the SAME
+ * leaves the nested and terminal object proxies use (`writeTraps.ts`,
+ * `liveView.ts`), over an {@link elementSink}. A fix lands in a leaf once.
+ */
+import { type WriteSink } from './writeTraps.js';
+/**
+ * WHY: an array anywhere below a sink's root is ONE write path — it reads
+ * through the sink and commits the WHOLE new array back through it, so
+ * `push` three levels down and `arr[i].x = v` at the top share a funnel.
  */
+export declare function arrayProxyAt(sink: WriteSink, path: readonly string[]): unknown[];
 /**
  * Creates a Proxy over an array that intercepts mutating operations.
  *
+ * The actual current array is the Proxy target: Node.js console.log inspects
+ * the target directly (bypasses Proxy traps), so the real array shows correct
+ * values. The target reference is fixed at creation time — after mutations,
+ * the proxy returns a new proxy (via cache invalidation) with the fresh array
+ * as target.
+ *
  * @param getCurrent - Returns the current array snapshot from state
  * @param commit - Called with the new array after a mutation (triggers setValue)
  * @returns Proxied array with copy-on-write semantics

package/dist/esm/lib/reactive/arrayTraps.js

@@ -38,9 +38,9 @@
  *
  * Now an indexed read of a wrappable element returns an ELEMENT PROXY that
  * accumulates the path inside the element and, on write, rebuilds the array
- * immutably ({@link setInPath}) and hands the whole new array to `commit` —
- * the same funnel `push` already used. One write path for the whole array,
- * whatever depth it is addressed at.
+ * immutably (`structuralWrite.setInPath`, behind `writeTraps.elementSink`)
+ * and hands the whole new array to `commit` — the same funnel `push` already
+ * used. One write path for the whole array, whatever depth it is addressed at.
  *
  * ── What is still NOT seen (by design) ───────────────────────────────────
  * Elements reached WITHOUT an index — `find()`, `filter()`, `for…of`,
@@ -50,12 +50,18 @@
  * not lost in silence either: `StageContext` compares what a stage READ with
  * what the value holds at commit and, in dev mode, warns with the exact path.
  * See src/lib/reactive/README.md.
+ *
+ * ── Shape (9.23.1) ───────────────────────────────────────────────────────
+ * `createArrayProxy` and `createElementProxy` are ORCHESTRATORS: they wire
+ * traps and hold the caches. Every trap body is a named leaf below — one
+ * concern each — and the element proxy's set/delete/get traps are the SAME
+ * leaves the nested and terminal object proxies use (`writeTraps.ts`,
+ * `liveView.ts`), over an {@link elementSink}. A fix lands in a leaf once.
  */
-import { nativeGet } from '../memory/pathOps.js';
 import { shouldWrapWithProxy } from './allowlist.js';
-import { toJSONView } from './jsonProjection.js';
-import { liveInspectionTraps, liveObject } from './liveView.js';
-import { deleteInPath, setInPath, unwrapProxy } from './structuralWrite.js';
+import { liveGetTrap, liveInspectionTraps, liveObject, MemberCache } from './liveView.js';
+import { unwrapProxy } from './structuralWrite.js';
+import { elementSink, sinkDeleteTrap, sinkSetTrap } from './writeTraps.js';
 /** Methods that mutate the array in-place. We intercept and copy-on-write. */
 const MUTATING_METHODS = new Set([
     'push',
@@ -68,6 +74,43 @@ const MUTATING_METHODS = new Set([
     'fill',
     'copyWithin',
 ]);
+// -- Leaves: reads ------------------------------------------------------------
+/** WHY `Number(prop)`: the historical reading of an index name — `'01'` and
+ *  `''` address slots 1 and 0, as they always have. In range only. */
+function indexIn(current, prop) {
+    if (typeof prop !== 'string')
+        return undefined;
+    const index = Number(prop);
+    return Number.isInteger(index) && index >= 0 && index < current.length ? index : undefined;
+}
+/** A non-negative integer index named by `prop` (any range — a write past the end grows the array). */
+function indexNamed(prop) {
+    if (typeof prop !== 'string')
+        return undefined;
+    const index = Number(prop);
+    return Number.isInteger(index) && index >= 0 ? index : undefined;
+}
+/** WHY: a non-mutating read answers from the CURRENT array, never the
+ *  creation-time target — a method is bound to it, anything else read off it. */
+function boundMember(current, prop) {
+    const val = current[prop];
+    return typeof val === 'function' ? val.bind(current) : val;
+}
+/** WHY the cache: reading `lines[i].qty` in a loop must not allocate a proxy
+ *  per read, and `lines[0] === lines[0]` must hold within a stage. Validated by
+ *  raw identity — a commit replaces the array, the ref check misses, and a
+ *  fresh proxy is built over the new element. A primitive is handed back raw. */
+function cachedElement(cache, element, index, read, write) {
+    if (!shouldWrapWithProxy(element))
+        return element;
+    const cached = cache.get(index);
+    if (cached && cached.ref === element)
+        return cached.proxy;
+    const wrapped = wrapElementMember(element, elementSink(read, write, index), [], new Set());
+    cache.set(index, { ref: element, proxy: wrapped });
+    return wrapped;
+}
+// -- Leaves: writes -----------------------------------------------------------
 /** Slots from the current end up to (not including) `upTo` become `null` —
  *  the JSON spelling of a hole, which is what the whole-array round-trip used
  *  to produce for them. No-op when `upTo` is within the array. */
@@ -75,84 +118,52 @@ function fillHoles(arr, upTo) {
     for (let i = arr.length; i < upTo; i++)
         arr[i] = null;
 }
-/** Reads that must never be answered with a state value (see createTypedScope's GUARD_PROPS). */
-function guardValue(prop) {
-    if (prop === 'then' || prop === 'asymmetricMatch')
-        return { hit: true, value: undefined };
-    if (prop === 'constructor')
-        return { hit: true, value: Object };
-    return { hit: false };
+/** WHY: a mutating method runs on a COPY, with its arguments unwrapped (they
+ *  are the assigned values; a number or a comparator passes through), and the
+ *  copy is committed whole. The array in state is never touched. */
+function mutatingMethod(read, write, name) {
+    return (...args) => {
+        const clone = [...read()];
+        const result = clone[name](...args.map(unwrapProxy));
+        write(clone);
+        return result;
+    };
 }
-/**
- * The three primitives every write inside an element goes through. All of them
- * rebuild the owning array immutably and hand the WHOLE new array to `commit`
- * — the array proxy's own copy-on-write contract, applied one or more levels
- * down. `path` is measured from the element: `[]` IS the element slot.
- */
-function replaceInElement(getCurrent, commit, index, path, value) {
-    const next = [...getCurrent()];
-    if (index >= next.length)
-        return; // the element is gone — nothing to write into
-    next[index] = path.length === 0 ? value : setInPath(next[index], path, value);
-    commit(next);
+/** `arr[i] = v`: copy, `null` the slots a write past the end skips, place the unwrapped value, commit. */
+function setIndex(read, write, index, value) {
+    const clone = [...read()];
+    fillHoles(clone, index);
+    clone[index] = unwrapProxy(value);
+    write(clone);
 }
-function removeInElement(getCurrent, commit, index, path) {
-    const next = [...getCurrent()];
-    if (index >= next.length)
-        return;
-    next[index] = deleteInPath(next[index], path);
-    commit(next);
+/** `arr.length = n`: copy, `null` the slots growth adds, truncate or extend, commit. */
+function setLength(read, write, length) {
+    const clone = [...read()];
+    fillHoles(clone, length);
+    clone.length = length;
+    write(clone);
 }
-/** The value at `path` inside element `index`, as it stands NOW (read-your-writes). */
-function readInElement(getCurrent, index, path) {
-    const element = getCurrent()[index];
-    return path.length === 0 ? element : nativeGet(element, path);
+/** WHY: without this trap `delete items[2]` reaches the RAW array captured
+ *  as the proxy target — committed state, no commit record. JS `delete` on an
+ *  index leaves the slot empty and the length unchanged, and so does this:
+ *  the emptied slot commits as `null`, JSON's only spelling for a hole. */
+function deleteSlot(read, write, prop) {
+    const clone = [...read()];
+    const index = typeof prop === 'string' ? Number(prop) : NaN;
+    if (Number.isInteger(index) && index >= 0 && index < clone.length)
+        clone[index] = null;
+    else
+        delete clone[prop];
+    write(clone);
 }
+// -- Leaves: the chain below an element --------------------------------------
 /**
- * Proxy over one OBJECT element (or an object nested inside one), carrying the
- * path from the element down to it. Reads recurse; writes go back out through
- * the owning array's commit callback.
- *
- * READS ARE LIVE. Every write rebuilds the array immutably, so the object the
- * proxy was created over is the PRE-write element for ever after; a held
- * handle that read from it saw its own writes vanish (`line.n += 1` twice
- * gave 2, `line.total = line.qty * 10` used the old `qty`, `'x' in line` was
- * false right after `line.x = 1`). Every trap therefore resolves the element
- * through {@link readInElement} first, and falls back to the captured object
- * only when the path no longer exists (the slot was emptied or the array
- * shrank) — the same read-your-writes the array proxy itself has always had,
- * and the same law the nested and terminal object proxies follow (liveView.ts).
+ * WHY: an array anywhere below a sink's root is ONE write path — it reads
+ * through the sink and commits the WHOLE new array back through it, so
+ * `push` three levels down and `arr[i].x = v` at the top share a funnel.
  */
-function createElementProxy(raw, getCurrent, commit, index, segments, visited) {
-    const live = () => liveObject(raw, readInElement(getCurrent, index, segments));
-    return new Proxy(raw, {
-        get(_target, prop) {
-            const current = live();
-            if (typeof prop === 'symbol')
-                return current[prop];
-            const guard = guardValue(prop);
-            if (guard.hit)
-                return guard.value;
-            // Law: serializing a proxied value equals serializing the raw value.
-            if (prop === 'toJSON')
-                return () => toJSONView(current);
-            const value = current[prop];
-            return wrapElementMember(value, getCurrent, commit, index, [...segments, prop], visited);
-        },
-        set(_target, prop, value) {
-            if (typeof prop !== 'string')
-                return true;
-            replaceInElement(getCurrent, commit, index, [...segments, prop], unwrapProxy(value));
-            return true;
-        },
-        deleteProperty(_target, prop) {
-            if (typeof prop !== 'string')
-                return true;
-            removeInElement(getCurrent, commit, index, [...segments, prop]);
-            return true;
-        },
-        ...liveInspectionTraps(live),
-    });
+export function arrayProxyAt(sink, path) {
+    return createArrayProxy(() => sink.readAt(path) ?? [], (next) => sink.put(path, next));
 }
 /**
  * Wrap a value read out of an element: arrays become array proxies whose
@@ -161,140 +172,90 @@ function createElementProxy(raw, getCurrent, commit, index, segments, visited) {
  * on the access chain (a cycle) is returned raw — the same back-edge the
  * nested-object terminal proxy takes.
  */
-function wrapElementMember(value, getCurrent, commit, index, path, visited) {
+function wrapElementMember(value, sink, path, visited) {
     if (!shouldWrapWithProxy(value))
         return value;
     if (visited.has(value))
         return value;
     const branch = new Set(visited);
     branch.add(value);
-    if (Array.isArray(value)) {
-        return createArrayProxy(() => readInElement(getCurrent, index, path) ?? [], (inner) => replaceInElement(getCurrent, commit, index, path, inner));
-    }
-    return createElementProxy(value, getCurrent, commit, index, path, branch);
+    if (Array.isArray(value))
+        return arrayProxyAt(sink, path);
+    return createElementProxy(value, sink, path, branch);
+}
+// -- Orchestrators ------------------------------------------------------------
+/**
+ * Proxy over one OBJECT element (or an object nested inside one), carrying the
+ * path from the element down to it. Reads recurse; writes go back out through
+ * the owning array's commit callback (the {@link elementSink}).
+ *
+ * READS ARE LIVE. Every write rebuilds the array immutably, so the object the
+ * proxy was created over is the PRE-write element for ever after; a held
+ * handle that read from it saw its own writes vanish (`line.n += 1` twice
+ * gave 2, `line.total = line.qty * 10` used the old `qty`, `'x' in line` was
+ * false right after `line.x = 1`). Every trap therefore resolves the element
+ * through the sink first, and falls back to the captured object only when
+ * the path no longer exists (the slot was emptied or the array shrank) — the
+ * same read-your-writes the array proxy itself has always had, and the same
+ * law the nested and terminal object proxies follow (liveView.ts).
+ */
+function createElementProxy(raw, sink, segments, visited) {
+    const members = new MemberCache();
+    const live = () => liveObject(raw, sink.readAt(segments));
+    return new Proxy(raw, {
+        get: liveGetTrap(live, segments, (value, path) => wrapElementMember(value, sink, path, visited), members),
+        set: sinkSetTrap(sink, segments),
+        deleteProperty: sinkDeleteTrap(sink, segments),
+        ...liveInspectionTraps(live),
+    });
 }
 /**
  * Creates a Proxy over an array that intercepts mutating operations.
  *
+ * The actual current array is the Proxy target: Node.js console.log inspects
+ * the target directly (bypasses Proxy traps), so the real array shows correct
+ * values. The target reference is fixed at creation time — after mutations,
+ * the proxy returns a new proxy (via cache invalidation) with the fresh array
+ * as target.
+ *
  * @param getCurrent - Returns the current array snapshot from state
  * @param commit - Called with the new array after a mutation (triggers setValue)
  * @returns Proxied array with copy-on-write semantics
  */
 export function createArrayProxy(getCurrent, commit) {
-    // Use the actual current array as the Proxy target. Node.js console.log
-    // inspects the target directly (bypasses Proxy traps). By using the real
-    // array, console.log shows correct values. The target reference is fixed
-    // at creation time — after mutations, the proxy returns a new proxy
-    // (via cache invalidation) with the fresh array as target.
     const target = getCurrent();
-    const readCurrent = getCurrent;
-    const writeCommit = commit;
-    // Element proxies are cached per index and validated by raw identity — the
-    // same bargain the top-level child cache makes. Without it, reading
-    // `lines[i].qty` in a loop would allocate one proxy per read; with it,
-    // repeated access to an UNCHANGED element is free and `lines[0] === lines[0]`
-    // holds within a stage. A commit replaces the array, so the ref check misses
-    // and a fresh proxy is built over the new element.
-    const elementCache = new Map();
+    const read = getCurrent;
+    const write = commit;
+    const elements = new Map();
     return new Proxy(target, {
-        get(_target, prop, receiver) {
-            // Intercept mutating methods
-            if (typeof prop === 'string' && MUTATING_METHODS.has(prop)) {
-                return (...args) => {
-                    const clone = [...getCurrent()];
-                    // The arguments are the assigned values — unwrap each one (a
-                    // number, a comparator or a primitive passes through untouched).
-                    const result = clone[prop](...args.map(unwrapProxy));
-                    commit(clone);
-                    return result;
-                };
-            }
-            // Non-mutating access: delegate to the current array snapshot
-            const current = getCurrent();
-            // 'length' and index access
+        get(_target, prop) {
+            if (typeof prop === 'string' && MUTATING_METHODS.has(prop))
+                return mutatingMethod(read, write, prop);
+            const current = read();
             if (prop === 'length')
                 return current.length;
-            // Numeric index access — the element joins the write chain (see header).
-            if (typeof prop === 'string') {
-                const index = Number(prop);
-                if (Number.isInteger(index) && index >= 0 && index < current.length) {
-                    const element = current[index];
-                    if (!shouldWrapWithProxy(element))
-                        return element;
-                    const cached = elementCache.get(index);
-                    if (cached && cached.ref === element)
-                        return cached.proxy;
-                    const wrapped = wrapElementMember(element, readCurrent, writeCommit, index, [], new Set());
-                    elementCache.set(index, { ref: element, proxy: wrapped });
-                    return wrapped;
-                }
-            }
-            // Node.js util.inspect custom formatting
-            if (prop === Symbol.for('nodejs.util.inspect.custom')) {
+            const index = indexIn(current, prop);
+            if (index !== undefined)
+                return cachedElement(elements, current[index], index, read, write);
+            if (prop === Symbol.for('nodejs.util.inspect.custom'))
                 return () => current;
-            }
-            // Symbol.iterator and other built-in symbols
-            if (typeof prop === 'symbol') {
-                const val = current[prop];
-                if (typeof val === 'function')
-                    return val.bind(current);
-                return val;
-            }
-            // All other methods (map, filter, forEach, find, etc.) -- bind to current
-            const val = current[prop];
-            if (typeof val === 'function')
-                return val.bind(current);
-            return val;
+            return boundMember(current, prop);
         },
         set(_target, prop, value) {
-            // Index assignment: scope.items[2] = 'updated'
-            if (typeof prop === 'string') {
-                const index = Number(prop);
-                if (Number.isInteger(index) && index >= 0) {
-                    const clone = [...getCurrent()];
-                    fillHoles(clone, index); // a write past the end: the skipped slots are `null`, not holes
-                    clone[index] = unwrapProxy(value);
-                    commit(clone);
-                    return true;
-                }
-            }
-            // Setting 'length' (e.g., arr.length = 0 to clear)
-            if (prop === 'length' && typeof value === 'number') {
-                const clone = [...getCurrent()];
-                fillHoles(clone, value); // growth: the new slots are `null`, not holes
-                clone.length = value;
-                commit(clone);
-                return true;
-            }
-            return true; // ignore other set operations
+            const index = indexNamed(prop);
+            if (index !== undefined)
+                setIndex(read, write, index, value);
+            else if (prop === 'length' && typeof value === 'number')
+                setLength(read, write, value);
+            return true; // any other set is ignored (an expando on an array is out of contract — README)
         },
-        // `delete items[2]` — without this trap the default reaches the RAW array
-        // captured as the proxy target, mutating committed state with no commit
-        // record. Copy-on-write like every other mutation; JS `delete` on an index
-        // leaves the slot empty and the length unchanged, and so does this — the
-        // emptied slot commits as `null`, JSON's only spelling for an array hole.
         deleteProperty(_target, prop) {
-            const clone = [...getCurrent()];
-            const index = typeof prop === 'string' ? Number(prop) : NaN;
-            if (Number.isInteger(index) && index >= 0 && index < clone.length)
-                clone[index] = null;
-            else
-                delete clone[prop];
-            commit(clone);
+            deleteSlot(read, write, prop);
             return true;
         },
-        has(_target, prop) {
-            const current = getCurrent();
-            return Reflect.has(current, prop);
-        },
-        ownKeys() {
-            const current = getCurrent();
-            return Reflect.ownKeys(current);
-        },
-        getOwnPropertyDescriptor(_target, prop) {
-            const current = getCurrent();
-            return Object.getOwnPropertyDescriptor(current, prop);
-        },
+        has: (_target, prop) => Reflect.has(read(), prop),
+        ownKeys: () => Reflect.ownKeys(read()),
+        getOwnPropertyDescriptor: (_target, prop) => Object.getOwnPropertyDescriptor(read(), prop),
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"arrayTraps.js","sourceRoot":"","sources":["../../../../src/lib/reactive/arrayTraps.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * reactive/arrayTraps -- Array mutation interception via Proxy.\n *\n * When scope.items is an array, we return a Proxy that intercepts mutating\n * methods (push, pop, splice, etc.) AND indexed access. Each mutation:\n * 1. Clones the current array\n * 2. Applies the mutation to the clone\n * 3. Commits the new array via the commit callback\n *\n * Non-mutating methods (map, filter, forEach, etc.) pass through to the\n * current array snapshot without interception.\n *\n * The original array in state is NEVER mutated directly -- all writes go\n * through the commit callback which calls setValue/updateValue.\n *\n * ── Only the ASSIGNED value is unwrapped (9.23.0) ────────────────────────\n * Landmine 1 says the set trap JSON-round-trips the value the caller handed\n * in. For an array that is the index-assigned element, a mutating method's\n * arguments (`push(x)`, `splice(i, n, ...items)`, `fill(x)`), or the leaf an\n * element proxy writes — and it is unwrapped HERE, at the trap that receives\n * it. The rebuilt array is handed to `commit` as it is: every sibling the\n * caller did not touch passes through by reference, `Date`s and `Map`s\n * intact. Until 9.23.0 the commit callbacks round-tripped the WHOLE rebuilt\n * array, which stringified untouched siblings and was O(N) per element write.\n * The one thing the round-trip used to do for the array's own shape — an\n * emptied or skipped slot became `null`, JSON's only spelling for a hole —\n * is now done explicitly by the traps that can create one (`delete arr[i]`,\n * `arr[i] = v` past the end, `arr.length = n` growth).\n *\n * ── Indexed access is part of the chain (9.22.0) ─────────────────────────\n * `arr[i]` used to hand back the RAW element, which broke the proxy chain at\n * exactly the point users write through it: `order.lines[0].qty = 4` was an\n * in-place mutation of a borrowed read — no trap, no trace row, no commit.\n * Before the stage's first staged write that borrowed value IS committed\n * shared memory, so the mutation moved state while the log stayed empty; after\n * it, the mutation landed in the private buffer clone and was dropped. Same\n * expression, two silent outcomes.\n *\n * Now an indexed read of a wrappable element returns an ELEMENT PROXY that\n * accumulates the path inside the element and, on write, rebuilds the array\n * immutably ({@link setInPath}) and hands the whole new array to `commit` —\n * the same funnel `push` already used. One write path for the whole array,\n * whatever depth it is addressed at.\n *\n * ── What is still NOT seen (by design) ───────────────────────────────────\n * Elements reached WITHOUT an index — `find()`, `filter()`, `for…of`,\n * `forEach`, destructuring — are handed back raw, because wrapping them would\n * mean returning proxies out of every read method (`map` would build an array\n * of proxies) for a cost the library should not pay. Mutating one of those is\n * not lost in silence either: `StageContext` compares what a stage READ with\n * what the value holds at commit and, in dev mode, warns with the exact path.\n * See src/lib/reactive/README.md.\n */\n\nimport { nativeGet } from '../memory/pathOps.js';\nimport { shouldWrapWithProxy } from './allowlist.js';\nimport { toJSONView } from './jsonProjection.js';\nimport { liveInspectionTraps, liveObject } from './liveView.js';\nimport { deleteInPath, setInPath, unwrapProxy } from './structuralWrite.js';\n\n/** Methods that mutate the array in-place. We intercept and copy-on-write. */\nconst MUTATING_METHODS = new Set([\n  'push',\n  'pop',\n  'shift',\n  'unshift',\n  'splice',\n  'sort',\n  'reverse',\n  'fill',\n  'copyWithin',\n]);\n\n/** Slots from the current end up to (not including) `upTo` become `null` —\n *  the JSON spelling of a hole, which is what the whole-array round-trip used\n *  to produce for them. No-op when `upTo` is within the array. */\nfunction fillHoles(arr: unknown[], upTo: number): void {\n  for (let i = arr.length; i < upTo; i++) arr[i] = null;\n}\n\n/** Reads that must never be answered with a state value (see createTypedScope's GUARD_PROPS). */\nfunction guardValue(prop: string): { hit: boolean; value?: unknown } {\n  if (prop === 'then' || prop === 'asymmetricMatch') return { hit: true, value: undefined };\n  if (prop === 'constructor') return { hit: true, value: Object };\n  return { hit: false };\n}\n\n/**\n * The three primitives every write inside an element goes through. All of them\n * rebuild the owning array immutably and hand the WHOLE new array to `commit`\n * — the array proxy's own copy-on-write contract, applied one or more levels\n * down. `path` is measured from the element: `[]` IS the element slot.\n */\nfunction replaceInElement(\n  getCurrent: () => unknown[],\n  commit: (next: any[]) => void,\n  index: number,\n  path: readonly string[],\n  value: unknown,\n): void {\n  const next = [...getCurrent()];\n  if (index >= next.length) return; // the element is gone — nothing to write into\n  next[index] = path.length === 0 ? value : setInPath(next[index], path, value);\n  commit(next);\n}\n\nfunction removeInElement(\n  getCurrent: () => unknown[],\n  commit: (next: any[]) => void,\n  index: number,\n  path: readonly string[],\n): void {\n  const next = [...getCurrent()];\n  if (index >= next.length) return;\n  next[index] = deleteInPath(next[index], path);\n  commit(next);\n}\n\n/** The value at `path` inside element `index`, as it stands NOW (read-your-writes). */\nfunction readInElement(getCurrent: () => unknown[], index: number, path: readonly string[]): unknown {\n  const element = getCurrent()[index];\n  return path.length === 0 ? element : nativeGet(element, path as string[]);\n}\n\n/**\n * Proxy over one OBJECT element (or an object nested inside one), carrying the\n * path from the element down to it. Reads recurse; writes go back out through\n * the owning array's commit callback.\n *\n * READS ARE LIVE. Every write rebuilds the array immutably, so the object the\n * proxy was created over is the PRE-write element for ever after; a held\n * handle that read from it saw its own writes vanish (`line.n += 1` twice\n * gave 2, `line.total = line.qty * 10` used the old `qty`, `'x' in line` was\n * false right after `line.x = 1`). Every trap therefore resolves the element\n * through {@link readInElement} first, and falls back to the captured object\n * only when the path no longer exists (the slot was emptied or the array\n * shrank) — the same read-your-writes the array proxy itself has always had,\n * and the same law the nested and terminal object proxies follow (liveView.ts).\n */\nfunction createElementProxy(\n  raw: Record<string, unknown>,\n  getCurrent: () => unknown[],\n  commit: (next: any[]) => void,\n  index: number,\n  segments: readonly string[],\n  visited: Set<object>,\n): unknown {\n  const live = () => liveObject(raw, readInElement(getCurrent, index, segments));\n\n  return new Proxy(raw, {\n    get(_target, prop) {\n      const current = live();\n      if (typeof prop === 'symbol') return (current as any)[prop];\n      const guard = guardValue(prop);\n      if (guard.hit) return guard.value;\n      // Law: serializing a proxied value equals serializing the raw value.\n      if (prop === 'toJSON') return () => toJSONView(current);\n\n      const value = (current as any)[prop];\n      return wrapElementMember(value, getCurrent, commit, index, [...segments, prop], visited);\n    },\n\n    set(_target, prop, value) {\n      if (typeof prop !== 'string') return true;\n      replaceInElement(getCurrent, commit, index, [...segments, prop], unwrapProxy(value));\n      return true;\n    },\n\n    deleteProperty(_target, prop) {\n      if (typeof prop !== 'string') return true;\n      removeInElement(getCurrent, commit, index, [...segments, prop]);\n      return true;\n    },\n\n    ...liveInspectionTraps(live),\n  });\n}\n\n/**\n * Wrap a value read out of an element: arrays become array proxies whose\n * commits route back through the owning array, plain objects become element\n * proxies one level deeper, everything else is returned as-is. A value already\n * on the access chain (a cycle) is returned raw — the same back-edge the\n * nested-object terminal proxy takes.\n */\nfunction wrapElementMember(\n  value: unknown,\n  getCurrent: () => unknown[],\n  commit: (next: any[]) => void,\n  index: number,\n  path: readonly string[],\n  visited: Set<object>,\n): unknown {\n  if (!shouldWrapWithProxy(value)) return value;\n  if (visited.has(value as object)) return value;\n  const branch = new Set(visited);\n  branch.add(value as object);\n\n  if (Array.isArray(value)) {\n    return createArrayProxy(\n      () => (readInElement(getCurrent, index, path) as unknown[]) ?? [],\n      (inner) => replaceInElement(getCurrent, commit, index, path, inner),\n    );\n  }\n  return createElementProxy(value as Record<string, unknown>, getCurrent, commit, index, path, branch);\n}\n\n/**\n * Creates a Proxy over an array that intercepts mutating operations.\n *\n * @param getCurrent - Returns the current array snapshot from state\n * @param commit - Called with the new array after a mutation (triggers setValue)\n * @returns Proxied array with copy-on-write semantics\n */\nexport function createArrayProxy<T>(getCurrent: () => T[], commit: (newArray: T[]) => void): T[] {\n  // Use the actual current array as the Proxy target. Node.js console.log\n  // inspects the target directly (bypasses Proxy traps). By using the real\n  // array, console.log shows correct values. The target reference is fixed\n  // at creation time — after mutations, the proxy returns a new proxy\n  // (via cache invalidation) with the fresh array as target.\n  const target = getCurrent() as T[];\n  const readCurrent = getCurrent as unknown as () => unknown[];\n  const writeCommit = commit as unknown as (next: any[]) => void;\n  // Element proxies are cached per index and validated by raw identity — the\n  // same bargain the top-level child cache makes. Without it, reading\n  // `lines[i].qty` in a loop would allocate one proxy per read; with it,\n  // repeated access to an UNCHANGED element is free and `lines[0] === lines[0]`\n  // holds within a stage. A commit replaces the array, so the ref check misses\n  // and a fresh proxy is built over the new element.\n  const elementCache = new Map<number, { ref: unknown; proxy: unknown }>();\n\n  return new Proxy(target, {\n    get(_target, prop, receiver) {\n      // Intercept mutating methods\n      if (typeof prop === 'string' && MUTATING_METHODS.has(prop)) {\n        return (...args: unknown[]) => {\n          const clone = [...getCurrent()];\n          // The arguments are the assigned values — unwrap each one (a\n          // number, a comparator or a primitive passes through untouched).\n          const result = (clone as any)[prop](...args.map(unwrapProxy));\n          commit(clone);\n          return result;\n        };\n      }\n\n      // Non-mutating access: delegate to the current array snapshot\n      const current = getCurrent();\n\n      // 'length' and index access\n      if (prop === 'length') return current.length;\n\n      // Numeric index access — the element joins the write chain (see header).\n      if (typeof prop === 'string') {\n        const index = Number(prop);\n        if (Number.isInteger(index) && index >= 0 && index < current.length) {\n          const element = current[index];\n          if (!shouldWrapWithProxy(element)) return element;\n          const cached = elementCache.get(index);\n          if (cached && cached.ref === element) return cached.proxy;\n          const wrapped = wrapElementMember(element, readCurrent, writeCommit, index, [], new Set<object>());\n          elementCache.set(index, { ref: element, proxy: wrapped });\n          return wrapped;\n        }\n      }\n\n      // Node.js util.inspect custom formatting\n      if (prop === Symbol.for('nodejs.util.inspect.custom')) {\n        return () => current;\n      }\n\n      // Symbol.iterator and other built-in symbols\n      if (typeof prop === 'symbol') {\n        const val = (current as any)[prop];\n        if (typeof val === 'function') return val.bind(current);\n        return val;\n      }\n\n      // All other methods (map, filter, forEach, find, etc.) -- bind to current\n      const val = (current as any)[prop];\n      if (typeof val === 'function') return val.bind(current);\n      return val;\n    },\n\n    set(_target, prop, value) {\n      // Index assignment: scope.items[2] = 'updated'\n      if (typeof prop === 'string') {\n        const index = Number(prop);\n        if (Number.isInteger(index) && index >= 0) {\n          const clone = [...getCurrent()];\n          fillHoles(clone, index); // a write past the end: the skipped slots are `null`, not holes\n          clone[index] = unwrapProxy(value) as T;\n          commit(clone);\n          return true;\n        }\n      }\n\n      // Setting 'length' (e.g., arr.length = 0 to clear)\n      if (prop === 'length' && typeof value === 'number') {\n        const clone = [...getCurrent()];\n        fillHoles(clone, value); // growth: the new slots are `null`, not holes\n        clone.length = value;\n        commit(clone);\n        return true;\n      }\n\n      return true; // ignore other set operations\n    },\n\n    // `delete items[2]` — without this trap the default reaches the RAW array\n    // captured as the proxy target, mutating committed state with no commit\n    // record. Copy-on-write like every other mutation; JS `delete` on an index\n    // leaves the slot empty and the length unchanged, and so does this — the\n    // emptied slot commits as `null`, JSON's only spelling for an array hole.\n    deleteProperty(_target, prop) {\n      const clone = [...getCurrent()];\n      const index = typeof prop === 'string' ? Number(prop) : NaN;\n      if (Number.isInteger(index) && index >= 0 && index < clone.length) (clone as unknown[])[index] = null;\n      else delete (clone as any)[prop];\n      commit(clone);\n      return true;\n    },\n\n    has(_target, prop) {\n      const current = getCurrent();\n      return Reflect.has(current, prop);\n    },\n\n    ownKeys() {\n      const current = getCurrent();\n      return Reflect.ownKeys(current);\n    },\n\n    getOwnPropertyDescriptor(_target, prop) {\n      const current = getCurrent();\n      return Object.getOwnPropertyDescriptor(current, prop);\n    },\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"arrayTraps.js","sourceRoot":"","sources":["../../../../src/lib/reactive/arrayTraps.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * reactive/arrayTraps -- Array mutation interception via Proxy.\n *\n * When scope.items is an array, we return a Proxy that intercepts mutating\n * methods (push, pop, splice, etc.) AND indexed access. Each mutation:\n * 1. Clones the current array\n * 2. Applies the mutation to the clone\n * 3. Commits the new array via the commit callback\n *\n * Non-mutating methods (map, filter, forEach, etc.) pass through to the\n * current array snapshot without interception.\n *\n * The original array in state is NEVER mutated directly -- all writes go\n * through the commit callback which calls setValue/updateValue.\n *\n * ── Only the ASSIGNED value is unwrapped (9.23.0) ────────────────────────\n * Landmine 1 says the set trap JSON-round-trips the value the caller handed\n * in. For an array that is the index-assigned element, a mutating method's\n * arguments (`push(x)`, `splice(i, n, ...items)`, `fill(x)`), or the leaf an\n * element proxy writes — and it is unwrapped HERE, at the trap that receives\n * it. The rebuilt array is handed to `commit` as it is: every sibling the\n * caller did not touch passes through by reference, `Date`s and `Map`s\n * intact. Until 9.23.0 the commit callbacks round-tripped the WHOLE rebuilt\n * array, which stringified untouched siblings and was O(N) per element write.\n * The one thing the round-trip used to do for the array's own shape — an\n * emptied or skipped slot became `null`, JSON's only spelling for a hole —\n * is now done explicitly by the traps that can create one (`delete arr[i]`,\n * `arr[i] = v` past the end, `arr.length = n` growth).\n *\n * ── Indexed access is part of the chain (9.22.0) ─────────────────────────\n * `arr[i]` used to hand back the RAW element, which broke the proxy chain at\n * exactly the point users write through it: `order.lines[0].qty = 4` was an\n * in-place mutation of a borrowed read — no trap, no trace row, no commit.\n * Before the stage's first staged write that borrowed value IS committed\n * shared memory, so the mutation moved state while the log stayed empty; after\n * it, the mutation landed in the private buffer clone and was dropped. Same\n * expression, two silent outcomes.\n *\n * Now an indexed read of a wrappable element returns an ELEMENT PROXY that\n * accumulates the path inside the element and, on write, rebuilds the array\n * immutably (`structuralWrite.setInPath`, behind `writeTraps.elementSink`)\n * and hands the whole new array to `commit` — the same funnel `push` already\n * used. One write path for the whole array, whatever depth it is addressed at.\n *\n * ── What is still NOT seen (by design) ───────────────────────────────────\n * Elements reached WITHOUT an index — `find()`, `filter()`, `for…of`,\n * `forEach`, destructuring — are handed back raw, because wrapping them would\n * mean returning proxies out of every read method (`map` would build an array\n * of proxies) for a cost the library should not pay. Mutating one of those is\n * not lost in silence either: `StageContext` compares what a stage READ with\n * what the value holds at commit and, in dev mode, warns with the exact path.\n * See src/lib/reactive/README.md.\n *\n * ── Shape (9.23.1) ───────────────────────────────────────────────────────\n * `createArrayProxy` and `createElementProxy` are ORCHESTRATORS: they wire\n * traps and hold the caches. Every trap body is a named leaf below — one\n * concern each — and the element proxy's set/delete/get traps are the SAME\n * leaves the nested and terminal object proxies use (`writeTraps.ts`,\n * `liveView.ts`), over an {@link elementSink}. A fix lands in a leaf once.\n */\n\nimport { shouldWrapWithProxy } from './allowlist.js';\nimport { liveGetTrap, liveInspectionTraps, liveObject, MemberCache } from './liveView.js';\nimport { unwrapProxy } from './structuralWrite.js';\nimport { type WriteSink, elementSink, sinkDeleteTrap, sinkSetTrap } from './writeTraps.js';\n\n/** Methods that mutate the array in-place. We intercept and copy-on-write. */\nconst MUTATING_METHODS = new Set([\n  'push',\n  'pop',\n  'shift',\n  'unshift',\n  'splice',\n  'sort',\n  'reverse',\n  'fill',\n  'copyWithin',\n]);\n\ntype Read = () => unknown[];\ntype Write = (next: unknown[]) => void;\n\n// -- Leaves: reads ------------------------------------------------------------\n\n/** WHY `Number(prop)`: the historical reading of an index name — `'01'` and\n *  `''` address slots 1 and 0, as they always have. In range only. */\nfunction indexIn(current: unknown[], prop: string | symbol): number | undefined {\n  if (typeof prop !== 'string') return undefined;\n  const index = Number(prop);\n  return Number.isInteger(index) && index >= 0 && index < current.length ? index : undefined;\n}\n\n/** A non-negative integer index named by `prop` (any range — a write past the end grows the array). */\nfunction indexNamed(prop: string | symbol): number | undefined {\n  if (typeof prop !== 'string') return undefined;\n  const index = Number(prop);\n  return Number.isInteger(index) && index >= 0 ? index : undefined;\n}\n\n/** WHY: a non-mutating read answers from the CURRENT array, never the\n *  creation-time target — a method is bound to it, anything else read off it. */\nfunction boundMember(current: unknown[], prop: string | symbol): unknown {\n  const val = (current as any)[prop];\n  return typeof val === 'function' ? val.bind(current) : val;\n}\n\ntype ElementCache = Map<number, { ref: unknown; proxy: unknown }>;\n\n/** WHY the cache: reading `lines[i].qty` in a loop must not allocate a proxy\n *  per read, and `lines[0] === lines[0]` must hold within a stage. Validated by\n *  raw identity — a commit replaces the array, the ref check misses, and a\n *  fresh proxy is built over the new element. A primitive is handed back raw. */\nfunction cachedElement(cache: ElementCache, element: unknown, index: number, read: Read, write: Write): unknown {\n  if (!shouldWrapWithProxy(element)) return element;\n  const cached = cache.get(index);\n  if (cached && cached.ref === element) return cached.proxy;\n  const wrapped = wrapElementMember(element, elementSink(read, write, index), [], new Set<object>());\n  cache.set(index, { ref: element, proxy: wrapped });\n  return wrapped;\n}\n\n// -- Leaves: writes -----------------------------------------------------------\n\n/** Slots from the current end up to (not including) `upTo` become `null` —\n *  the JSON spelling of a hole, which is what the whole-array round-trip used\n *  to produce for them. No-op when `upTo` is within the array. */\nfunction fillHoles(arr: unknown[], upTo: number): void {\n  for (let i = arr.length; i < upTo; i++) arr[i] = null;\n}\n\n/** WHY: a mutating method runs on a COPY, with its arguments unwrapped (they\n *  are the assigned values; a number or a comparator passes through), and the\n *  copy is committed whole. The array in state is never touched. */\nfunction mutatingMethod(read: Read, write: Write, name: string): (...args: unknown[]) => unknown {\n  return (...args) => {\n    const clone = [...read()];\n    const result = (clone as any)[name](...args.map(unwrapProxy));\n    write(clone);\n    return result;\n  };\n}\n\n/** `arr[i] = v`: copy, `null` the slots a write past the end skips, place the unwrapped value, commit. */\nfunction setIndex(read: Read, write: Write, index: number, value: unknown): void {\n  const clone = [...read()];\n  fillHoles(clone, index);\n  clone[index] = unwrapProxy(value);\n  write(clone);\n}\n\n/** `arr.length = n`: copy, `null` the slots growth adds, truncate or extend, commit. */\nfunction setLength(read: Read, write: Write, length: number): void {\n  const clone = [...read()];\n  fillHoles(clone, length);\n  clone.length = length;\n  write(clone);\n}\n\n/** WHY: without this trap `delete items[2]` reaches the RAW array captured\n *  as the proxy target — committed state, no commit record. JS `delete` on an\n *  index leaves the slot empty and the length unchanged, and so does this:\n *  the emptied slot commits as `null`, JSON's only spelling for a hole. */\nfunction deleteSlot(read: Read, write: Write, prop: string | symbol): void {\n  const clone = [...read()];\n  const index = typeof prop === 'string' ? Number(prop) : NaN;\n  if (Number.isInteger(index) && index >= 0 && index < clone.length) clone[index] = null;\n  else delete (clone as any)[prop];\n  write(clone);\n}\n\n// -- Leaves: the chain below an element --------------------------------------\n\n/**\n * WHY: an array anywhere below a sink's root is ONE write path — it reads\n * through the sink and commits the WHOLE new array back through it, so\n * `push` three levels down and `arr[i].x = v` at the top share a funnel.\n */\nexport function arrayProxyAt(sink: WriteSink, path: readonly string[]): unknown[] {\n  return createArrayProxy(\n    () => (sink.readAt(path) as unknown[]) ?? [],\n    (next) => sink.put(path, next),\n  );\n}\n\n/**\n * Wrap a value read out of an element: arrays become array proxies whose\n * commits route back through the owning array, plain objects become element\n * proxies one level deeper, everything else is returned as-is. A value already\n * on the access chain (a cycle) is returned raw — the same back-edge the\n * nested-object terminal proxy takes.\n */\nfunction wrapElementMember(value: unknown, sink: WriteSink, path: string[], visited: Set<object>): unknown {\n  if (!shouldWrapWithProxy(value)) return value;\n  if (visited.has(value as object)) return value;\n  const branch = new Set(visited);\n  branch.add(value as object);\n  if (Array.isArray(value)) return arrayProxyAt(sink, path);\n  return createElementProxy(value as Record<string, unknown>, sink, path, branch);\n}\n\n// -- Orchestrators ------------------------------------------------------------\n\n/**\n * Proxy over one OBJECT element (or an object nested inside one), carrying the\n * path from the element down to it. Reads recurse; writes go back out through\n * the owning array's commit callback (the {@link elementSink}).\n *\n * READS ARE LIVE. Every write rebuilds the array immutably, so the object the\n * proxy was created over is the PRE-write element for ever after; a held\n * handle that read from it saw its own writes vanish (`line.n += 1` twice\n * gave 2, `line.total = line.qty * 10` used the old `qty`, `'x' in line` was\n * false right after `line.x = 1`). Every trap therefore resolves the element\n * through the sink first, and falls back to the captured object only when\n * the path no longer exists (the slot was emptied or the array shrank) — the\n * same read-your-writes the array proxy itself has always had, and the same\n * law the nested and terminal object proxies follow (liveView.ts).\n */\nfunction createElementProxy(\n  raw: Record<string, unknown>,\n  sink: WriteSink,\n  segments: readonly string[],\n  visited: Set<object>,\n): unknown {\n  const members = new MemberCache();\n  const live = () => liveObject(raw, sink.readAt(segments));\n  return new Proxy(raw, {\n    get: liveGetTrap(live, segments, (value, path) => wrapElementMember(value, sink, path, visited), members),\n    set: sinkSetTrap(sink, segments),\n    deleteProperty: sinkDeleteTrap(sink, segments),\n    ...liveInspectionTraps(live),\n  });\n}\n\n/**\n * Creates a Proxy over an array that intercepts mutating operations.\n *\n * The actual current array is the Proxy target: Node.js console.log inspects\n * the target directly (bypasses Proxy traps), so the real array shows correct\n * values. The target reference is fixed at creation time — after mutations,\n * the proxy returns a new proxy (via cache invalidation) with the fresh array\n * as target.\n *\n * @param getCurrent - Returns the current array snapshot from state\n * @param commit - Called with the new array after a mutation (triggers setValue)\n * @returns Proxied array with copy-on-write semantics\n */\nexport function createArrayProxy<T>(getCurrent: () => T[], commit: (newArray: T[]) => void): T[] {\n  const target = getCurrent() as T[];\n  const read = getCurrent as unknown as Read;\n  const write = commit as unknown as Write;\n  const elements: ElementCache = new Map();\n\n  return new Proxy(target, {\n    get(_target, prop) {\n      if (typeof prop === 'string' && MUTATING_METHODS.has(prop)) return mutatingMethod(read, write, prop);\n      const current = read();\n      if (prop === 'length') return current.length;\n      const index = indexIn(current, prop);\n      if (index !== undefined) return cachedElement(elements, current[index], index, read, write);\n      if (prop === Symbol.for('nodejs.util.inspect.custom')) return () => current;\n      return boundMember(current, prop);\n    },\n    set(_target, prop, value) {\n      const index = indexNamed(prop);\n      if (index !== undefined) setIndex(read, write, index, value);\n      else if (prop === 'length' && typeof value === 'number') setLength(read, write, value);\n      return true; // any other set is ignored (an expando on an array is out of contract — README)\n    },\n    deleteProperty(_target, prop) {\n      deleteSlot(read, write, prop);\n      return true;\n    },\n    has: (_target, prop) => Reflect.has(read(), prop),\n    ownKeys: () => Reflect.ownKeys(read()),\n    getOwnPropertyDescriptor: (_target, prop) => Object.getOwnPropertyDescriptor(read(), prop),\n  });\n}\n"]}