footprintjs 9.23.0 → 9.23.2

package/dist/lib/reactive/liveView.js

@@ -10,9 +10,71 @@
  * found on element proxies, then the same root on nested and terminal ones).
  * So every read trap resolves through the CURRENT value and falls back to the
  * captured object only when the path is gone or no longer holds an object.
+ *
+ * The READ side of every object proxy lives here — {@link liveObject},
+ * {@link liveGetTrap}, {@link liveInspectionTraps}, and the ONE per-member
+ * proxy cache {@link cachedMember} (9.23.2); the WRITE side is
+ * `writeTraps.ts`. A factory only wires them (9.23.1).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.liveInspectionTraps = exports.liveObject = void 0;
+exports.liveInspectionTraps = exports.liveGetTrap = exports.liveObject = exports.cachedMember = exports.MemberCache = void 0;
+const jsonProjection_js_1 = require("./jsonProjection.js");
+/**
+ * A proxy per member NAME under one parent proxy, validated by the raw
+ * member's identity. The map is allocated on the FIRST insert: an element
+ * proxy over `{ id, n }` reads only primitives and must not pay for one
+ * (10,000 of them in the naive re-read loop — measured, `bench/nested-reads.ts`).
+ */
+class MemberCache {
+    entries;
+    /** The proxy cached under `prop`, if it was built over exactly this raw `value`. */
+    hit(prop, value) {
+        const cached = this.entries?.get(prop);
+        return cached !== undefined && cached.ref === value ? cached.proxy : undefined;
+    }
+    remember(prop, value, proxy) {
+        (this.entries ??= new Map()).set(prop, { ref: value, proxy });
+    }
+    /** Forget `prop` — a write replaced its value, so the next read must build over the new one. */
+    delete(prop) {
+        this.entries?.delete(prop);
+    }
+}
+exports.MemberCache = MemberCache;
+/**
+ * WHY the cache: `o.arr === o.arr` must hold within a stage, and
+ * `for (i < N) s.k.arr[i]` must build ONE array proxy — whose element cache
+ * then serves every index — not N (the 9.22.0 perf review, finding 4: the
+ * nested get trap built a fresh array proxy, with a fresh empty element
+ * cache, on every `.arr`). The top-level scope has cached its child proxies
+ * this way since before 9.22.0; this is that leaf, shared by all four.
+ *
+ * Validated by IDENTITY, invalidated by replacement: every write through a
+ * proxy rebuilds the containers on its path (`structuralWrite.setInPath`),
+ * so after `s.k.arr[0].n = 1` the raw `arr` is a new array, the ref check
+ * misses, and the next read builds a proxy over the NEW value. A hit can
+ * never be stale — every proxy reads live (`liveGetTrap`), so the cached one
+ * and a fresh one answer the same.
+ *
+ * Keyed by NAME under THIS parent, never by the raw value alone: a diamond
+ * (one array under `k.a` and `k.b`) needs two proxies, each bound to its own
+ * path and sink. Only what `build` actually WRAPPED is kept — a member handed
+ * back raw (a `Date`, a frozen object, a cycle edge) is not worth an entry.
+ * `build` is the caller's stable child step, not a closure made per read: a
+ * hit allocates nothing, and a primitive member skips the cache entirely.
+ */
+function cachedMember(cache, prop, value, build, segments) {
+    if (value === null || typeof value !== 'object')
+        return build(value, [...segments, prop]);
+    const hit = cache.hit(prop, value);
+    if (hit !== undefined)
+        return hit;
+    const proxy = build(value, [...segments, prop]);
+    if (proxy !== value)
+        cache.remember(prop, value, proxy);
+    return proxy;
+}
+exports.cachedMember = cachedMember;
 /** The object at `segments` under the current root, or `raw` when it is gone. */
 function liveObject(raw, current) {
     return current !== null && typeof current === 'object' && !Array.isArray(current)
@@ -20,6 +82,29 @@ function liveObject(raw, current) {
         : raw;
 }
 exports.liveObject = liveObject;
+/**
+ * WHY one get trap: the names a proxy answers ITSELF (promise/matcher guards,
+ * `constructor`, and the JSON law — serializing a proxied value equals
+ * serializing the raw one, `jsonProjection.ts`) must be the same three lines
+ * on every object proxy; any other member is handed to `child` with its full
+ * path — through the parent's {@link cachedMember} — and only THAT step
+ * differs per factory (the cycle policy).
+ */
+function liveGetTrap(live, segments, child, members) {
+    return (_target, prop) => {
+        const raw = live();
+        if (typeof prop === 'symbol')
+            return raw[prop];
+        if (prop === 'then' || prop === 'asymmetricMatch')
+            return undefined;
+        if (prop === 'constructor')
+            return Object;
+        if (prop === 'toJSON')
+            return () => (0, jsonProjection_js_1.toJSONView)(raw);
+        return cachedMember(members, prop, raw[prop], child, segments);
+    };
+}
+exports.liveGetTrap = liveGetTrap;
 /**
  * The three inspection traps (`in`, `Object.keys`, descriptors) answered from
  * the live object. The one Proxy invariant that could bite — a non-extensible
@@ -45,4 +130,4 @@ function liveInspectionTraps(live) {
     };
 }
 exports.liveInspectionTraps = liveInspectionTraps;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"liveView.js","sourceRoot":"","sources":["../../../src/lib/reactive/liveView.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * reactive/liveView — what a proxy stands for, AS IT STANDS NOW.\n *\n * Every write through the typed scope rebuilds the root immutably\n * (`structuralWrite.setInPath`, a fresh merge), so the object a proxy was\n * created over is the PRE-write value for ever after. A held proxy that read\n * from it saw its own writes vanish: `o.x += 1` twice gave 2, `o.b = o.a * 10`\n * used the old `a`, `'x' in o` was false right after `o.x = 1` (9.22.0 — first\n * found on element proxies, then the same root on nested and terminal ones).\n * So every read trap resolves through the CURRENT value and falls back to the\n * captured object only when the path is gone or no longer holds an object.\n *\n * The READ side of every object proxy lives here — {@link liveObject},\n * {@link liveGetTrap}, {@link liveInspectionTraps}, and the ONE per-member\n * proxy cache {@link cachedMember} (9.23.2); the WRITE side is\n * `writeTraps.ts`. A factory only wires them (9.23.1).\n */\n\nimport { toJSONView } from './jsonProjection.js';\n\n/**\n * A proxy per member NAME under one parent proxy, validated by the raw\n * member's identity. The map is allocated on the FIRST insert: an element\n * proxy over `{ id, n }` reads only primitives and must not pay for one\n * (10,000 of them in the naive re-read loop — measured, `bench/nested-reads.ts`).\n */\nexport class MemberCache {\n  private entries?: Map<string, { ref: object; proxy: unknown }>;\n\n  /** The proxy cached under `prop`, if it was built over exactly this raw `value`. */\n  hit(prop: string, value: object): unknown {\n    const cached = this.entries?.get(prop);\n    return cached !== undefined && cached.ref === value ? cached.proxy : undefined;\n  }\n\n  remember(prop: string, value: object, proxy: unknown): void {\n    (this.entries ??= new Map()).set(prop, { ref: value, proxy });\n  }\n\n  /** Forget `prop` — a write replaced its value, so the next read must build over the new one. */\n  delete(prop: string): void {\n    this.entries?.delete(prop);\n  }\n}\n\n/**\n * WHY the cache: `o.arr === o.arr` must hold within a stage, and\n * `for (i < N) s.k.arr[i]` must build ONE array proxy — whose element cache\n * then serves every index — not N (the 9.22.0 perf review, finding 4: the\n * nested get trap built a fresh array proxy, with a fresh empty element\n * cache, on every `.arr`). The top-level scope has cached its child proxies\n * this way since before 9.22.0; this is that leaf, shared by all four.\n *\n * Validated by IDENTITY, invalidated by replacement: every write through a\n * proxy rebuilds the containers on its path (`structuralWrite.setInPath`),\n * so after `s.k.arr[0].n = 1` the raw `arr` is a new array, the ref check\n * misses, and the next read builds a proxy over the NEW value. A hit can\n * never be stale — every proxy reads live (`liveGetTrap`), so the cached one\n * and a fresh one answer the same.\n *\n * Keyed by NAME under THIS parent, never by the raw value alone: a diamond\n * (one array under `k.a` and `k.b`) needs two proxies, each bound to its own\n * path and sink. Only what `build` actually WRAPPED is kept — a member handed\n * back raw (a `Date`, a frozen object, a cycle edge) is not worth an entry.\n * `build` is the caller's stable child step, not a closure made per read: a\n * hit allocates nothing, and a primitive member skips the cache entirely.\n */\nexport function cachedMember(\n  cache: MemberCache,\n  prop: string,\n  value: unknown,\n  build: (value: unknown, path: string[]) => unknown,\n  segments: readonly string[],\n): unknown {\n  if (value === null || typeof value !== 'object') return build(value, [...segments, prop]);\n  const hit = cache.hit(prop, value);\n  if (hit !== undefined) return hit;\n  const proxy = build(value, [...segments, prop]);\n  if (proxy !== value) cache.remember(prop, value, proxy);\n  return proxy;\n}\n\n/** The object at `segments` under the current root, or `raw` when it is gone. */\nexport function liveObject(raw: Record<string, unknown>, current: unknown): Record<string, unknown> {\n  return current !== null && typeof current === 'object' && !Array.isArray(current)\n    ? (current as Record<string, unknown>)\n    : raw;\n}\n\n/**\n * WHY one get trap: the names a proxy answers ITSELF (promise/matcher guards,\n * `constructor`, and the JSON law — serializing a proxied value equals\n * serializing the raw one, `jsonProjection.ts`) must be the same three lines\n * on every object proxy; any other member is handed to `child` with its full\n * path — through the parent's {@link cachedMember} — and only THAT step\n * differs per factory (the cycle policy).\n */\nexport function liveGetTrap(\n  live: () => Record<string, unknown>,\n  segments: readonly string[],\n  child: (value: unknown, path: string[]) => unknown,\n  members: MemberCache,\n): ProxyHandler<object>['get'] {\n  return (_target, prop) => {\n    const raw = live();\n    if (typeof prop === 'symbol') return (raw as any)[prop];\n    if (prop === 'then' || prop === 'asymmetricMatch') return undefined;\n    if (prop === 'constructor') return Object;\n    if (prop === 'toJSON') return () => toJSONView(raw);\n    return cachedMember(members, prop, raw[prop], child, segments);\n  };\n}\n\n/**\n * The three inspection traps (`in`, `Object.keys`, descriptors) answered from\n * the live object. The one Proxy invariant that could bite — a non-extensible\n * target must report exactly its own keys, and a property the target lacks\n * must be reported configurable — is honoured: the allowlist already refuses\n * frozen and sealed values, so the `preventExtensions`-only corner answers\n * from the target, and a live descriptor is always reported configurable.\n */\nexport function liveInspectionTraps(\n  live: () => object,\n): Pick<ProxyHandler<object>, 'has' | 'ownKeys' | 'getOwnPropertyDescriptor'> {\n  return {\n    has(target, prop) {\n      return Reflect.has(Object.isExtensible(target) ? live() : target, prop);\n    },\n    ownKeys(target) {\n      return Reflect.ownKeys(Object.isExtensible(target) ? live() : target);\n    },\n    getOwnPropertyDescriptor(target, prop) {\n      if (!Object.isExtensible(target)) return Object.getOwnPropertyDescriptor(target, prop);\n      const descriptor = Object.getOwnPropertyDescriptor(live(), prop);\n      return descriptor && !descriptor.configurable ? { ...descriptor, configurable: true } : descriptor;\n    },\n  };\n}\n"]}

package/dist/lib/reactive/writeTraps.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * reactive/writeTraps — where a proxy's writes LAND, and the two traps that
+ * send them there.
+ *
+ * Every object proxy in this folder (nested, terminal, element) intercepts
+ * the same three things — a property set, a property delete, and an array
+ * mutation somewhere below it — and differs only in where the write goes:
+ * a nested/terminal proxy commits under a TOP-LEVEL KEY (an object write as
+ * `merge` of a patch, an array write or a delete as `set` of the rebuilt
+ * root); an element proxy commits the WHOLE OWNING ARRAY back through the
+ * array proxy's own callback. That difference is a {@link WriteSink}; the
+ * traps are written once over it (9.23.1 — the 9.22.0 stale-read bug was
+ * fixed in one copy of these traps and then found again in the other two).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sinkDeleteTrap = exports.sinkSetTrap = exports.elementSink = exports.rootKeySink = void 0;
+const pathOps_js_1 = require("../memory/pathOps.js");
+const pathBuilder_js_1 = require("./pathBuilder.js");
+const structuralWrite_js_1 = require("./structuralWrite.js");
+/**
+ * WHY: a write below a top-level key has TWO verbs (reactive/README.md, law
+ * 3) — an object leaf is a `merge` of a nested patch, an array leaf or a
+ * delete rebuilds the root immutably and commits a `set` of the key. Only the
+ * sink knows that; the traps do not. Every write drops the key's cached child
+ * proxy (`cache`), so the next read is built over the new value.
+ */
+function rootKeySink(target, readSilent, rootKey, cache) {
+    return new RootKeySink(target, readSilent, rootKey, cache);
+}
+exports.rootKeySink = rootKeySink;
+/** One allocation per top-level read miss (the methods live on the prototype). */
+class RootKeySink {
+    target;
+    readSilent;
+    rootKey;
+    cache;
+    constructor(target, readSilent, rootKey, cache) {
+        this.target = target;
+        this.readSilent = readSilent;
+        this.rootKey = rootKey;
+        this.cache = cache;
+    }
+    /** An empty path is the key's own value — `nativeGet(v, [])` would return it unchanged, so the walk is skipped. */
+    readAt(path) {
+        const root = this.readSilent(this.rootKey);
+        return path.length === 0 ? root : (0, pathOps_js_1.nativeGet)(root, path);
+    }
+    put(path, value) {
+        if (!Array.isArray(value))
+            this.target.updateValue(this.rootKey, (0, pathBuilder_js_1.buildNestedPatch)(path, value));
+        else
+            this.target.setValue(this.rootKey, path.length === 0 ? value : (0, structuralWrite_js_1.setInPath)(this.readAt([]), path, value));
+        this.cache.delete(this.rootKey);
+    }
+    remove(path) {
+        this.target.setValue(this.rootKey, (0, structuralWrite_js_1.deleteInPath)(this.readAt([]), path));
+        this.cache.delete(this.rootKey);
+    }
+}
+/**
+ * WHY: a write inside an array element is an array write — it rebuilds the
+ * owning array immutably and hands the WHOLE new array to the array proxy's
+ * commit, the funnel `push` already uses. `path` is measured from the
+ * element; `[]` is the element slot itself.
+ */
+function elementSink(getCurrent, commit, index) {
+    return new ElementSink(getCurrent, commit, index);
+}
+exports.elementSink = elementSink;
+/** One allocation per element proxy (the methods live on the prototype) — a 10k-element loop builds 10k of these. */
+class ElementSink {
+    getCurrent;
+    commit;
+    index;
+    constructor(getCurrent, commit, index) {
+        this.getCurrent = getCurrent;
+        this.commit = commit;
+        this.index = index;
+    }
+    readAt(path) {
+        return readInElement(this.getCurrent, this.index, path);
+    }
+    put(path, value) {
+        replaceInElement(this.getCurrent, this.commit, this.index, path, value);
+    }
+    remove(path) {
+        removeInElement(this.getCurrent, this.commit, this.index, path);
+    }
+}
+/** 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 : (0, pathOps_js_1.nativeGet)(element, path);
+}
+/** A copy of the array with `value` at `path` inside element `index`; a gone element has nothing to write into. */
+function replaceInElement(getCurrent, commit, index, path, value) {
+    const next = [...getCurrent()];
+    if (index >= next.length)
+        return;
+    next[index] = path.length === 0 ? value : (0, structuralWrite_js_1.setInPath)(next[index], path, value);
+    commit(next);
+}
+/** A copy of the array with the key at `path` inside element `index` removed. */
+function removeInElement(getCurrent, commit, index, path) {
+    const next = [...getCurrent()];
+    if (index >= next.length)
+        return;
+    next[index] = (0, structuralWrite_js_1.deleteInPath)(next[index], path);
+    commit(next);
+}
+/**
+ * WHY one set trap: the assigned value is unwrapped HERE (landmine 1 — the
+ * JSON round-trip applies to what the caller handed in, never to the
+ * surrounding state) and handed to the sink at the proxy's path plus the key.
+ */
+function sinkSetTrap(sink, segments) {
+    return (_target, prop, value) => {
+        if (typeof prop !== 'string')
+            return true;
+        sink.put([...segments, prop], (0, structuralWrite_js_1.unwrapProxy)(value));
+        return true;
+    };
+}
+exports.sinkSetTrap = sinkSetTrap;
+/**
+ * WHY one delete trap: `merge` cannot express a removal (a patch of
+ * `undefined` reads as absent), so a delete always rebuilds through the sink.
+ */
+function sinkDeleteTrap(sink, segments) {
+    return (_target, prop) => {
+        if (typeof prop !== 'string')
+            return true;
+        sink.remove([...segments, prop]);
+        return true;
+    };
+}
+exports.sinkDeleteTrap = sinkDeleteTrap;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writeTraps.js","sourceRoot":"","sources":["../../../src/lib/reactive/writeTraps.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * reactive/writeTraps — where a proxy's writes LAND, and the two traps that\n * send them there.\n *\n * Every object proxy in this folder (nested, terminal, element) intercepts\n * the same three things — a property set, a property delete, and an array\n * mutation somewhere below it — and differs only in where the write goes:\n * a nested/terminal proxy commits under a TOP-LEVEL KEY (an object write as\n * `merge` of a patch, an array write or a delete as `set` of the rebuilt\n * root); an element proxy commits the WHOLE OWNING ARRAY back through the\n * array proxy's own callback. That difference is a {@link WriteSink}; the\n * traps are written once over it (9.23.1 — the 9.22.0 stale-read bug was\n * fixed in one copy of these traps and then found again in the other two).\n */\n\nimport { nativeGet } from '../memory/pathOps.js';\nimport type { MemberCache } from './liveView.js';\nimport { buildNestedPatch } from './pathBuilder.js';\nimport { deleteInPath, setInPath, unwrapProxy } from './structuralWrite.js';\n\n/**\n * The seam between a proxy and state. `path` is measured from the sink's\n * root — the key's value for {@link rootKeySink}, the element for\n * {@link elementSink}; `[]` is the root itself.\n */\nexport interface WriteSink {\n  /** The value at `path`, as it stands NOW (read-your-writes; never a tracked read). */\n  readAt(path: readonly string[]): unknown;\n  /** Put an already-unwrapped `value` at `path`. The sink chooses the verb. */\n  put(path: readonly string[], value: unknown): void;\n  /** Remove the key at `path`. */\n  remove(path: readonly string[]): void;\n}\n\n/** The two ways a value reaches a state key: what the sink writes through. */\nexport interface RootKeyTarget {\n  setValue(key: string, value: unknown): void;\n  updateValue(key: string, value: unknown): void;\n}\n\n/**\n * WHY: a write below a top-level key has TWO verbs (reactive/README.md, law\n * 3) — an object leaf is a `merge` of a nested patch, an array leaf or a\n * delete rebuilds the root immutably and commits a `set` of the key. Only the\n * sink knows that; the traps do not. Every write drops the key's cached child\n * proxy (`cache`), so the next read is built over the new value.\n */\nexport function rootKeySink(\n  target: RootKeyTarget,\n  readSilent: (key: string) => unknown,\n  rootKey: string,\n  cache: Pick<MemberCache, 'delete'>,\n): WriteSink {\n  return new RootKeySink(target, readSilent, rootKey, cache);\n}\n\n/** One allocation per top-level read miss (the methods live on the prototype). */\nclass RootKeySink implements WriteSink {\n  constructor(\n    private readonly target: RootKeyTarget,\n    private readonly readSilent: (key: string) => unknown,\n    private readonly rootKey: string,\n    private readonly cache: Pick<MemberCache, 'delete'>,\n  ) {}\n\n  /** An empty path is the key's own value — `nativeGet(v, [])` would return it unchanged, so the walk is skipped. */\n  readAt(path: readonly string[]): unknown {\n    const root = this.readSilent(this.rootKey);\n    return path.length === 0 ? root : nativeGet(root, path as string[]);\n  }\n\n  put(path: readonly string[], value: unknown): void {\n    if (!Array.isArray(value)) this.target.updateValue(this.rootKey, buildNestedPatch(path as string[], value));\n    else this.target.setValue(this.rootKey, path.length === 0 ? value : setInPath(this.readAt([]), path, value));\n    this.cache.delete(this.rootKey);\n  }\n\n  remove(path: readonly string[]): void {\n    this.target.setValue(this.rootKey, deleteInPath(this.readAt([]), path));\n    this.cache.delete(this.rootKey);\n  }\n}\n\n/**\n * WHY: a write inside an array element is an array write — it rebuilds the\n * owning array immutably and hands the WHOLE new array to the array proxy's\n * commit, the funnel `push` already uses. `path` is measured from the\n * element; `[]` is the element slot itself.\n */\nexport function elementSink(getCurrent: () => unknown[], commit: (next: unknown[]) => void, index: number): WriteSink {\n  return new ElementSink(getCurrent, commit, index);\n}\n\n/** One allocation per element proxy (the methods live on the prototype) — a 10k-element loop builds 10k of these. */\nclass ElementSink implements WriteSink {\n  constructor(\n    private readonly getCurrent: () => unknown[],\n    private readonly commit: (next: unknown[]) => void,\n    private readonly index: number,\n  ) {}\n\n  readAt(path: readonly string[]): unknown {\n    return readInElement(this.getCurrent, this.index, path);\n  }\n\n  put(path: readonly string[], value: unknown): void {\n    replaceInElement(this.getCurrent, this.commit, this.index, path, value);\n  }\n\n  remove(path: readonly string[]): void {\n    removeInElement(this.getCurrent, this.commit, this.index, path);\n  }\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/** A copy of the array with `value` at `path` inside element `index`; a gone element has nothing to write into. */\nfunction replaceInElement(\n  getCurrent: () => unknown[],\n  commit: (next: unknown[]) => void,\n  index: number,\n  path: readonly string[],\n  value: unknown,\n): void {\n  const next = [...getCurrent()];\n  if (index >= next.length) return;\n  next[index] = path.length === 0 ? value : setInPath(next[index], path, value);\n  commit(next);\n}\n\n/** A copy of the array with the key at `path` inside element `index` removed. */\nfunction removeInElement(\n  getCurrent: () => unknown[],\n  commit: (next: unknown[]) => 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/**\n * WHY one set trap: the assigned value is unwrapped HERE (landmine 1 — the\n * JSON round-trip applies to what the caller handed in, never to the\n * surrounding state) and handed to the sink at the proxy's path plus the key.\n */\nexport function sinkSetTrap(sink: WriteSink, segments: readonly string[]): ProxyHandler<object>['set'] {\n  return (_target, prop, value) => {\n    if (typeof prop !== 'string') return true;\n    sink.put([...segments, prop], unwrapProxy(value));\n    return true;\n  };\n}\n\n/**\n * WHY one delete trap: `merge` cannot express a removal (a patch of\n * `undefined` reads as absent), so a delete always rebuilds through the sink.\n */\nexport function sinkDeleteTrap(sink: WriteSink, segments: readonly string[]): ProxyHandler<object>['deleteProperty'] {\n  return (_target, prop) => {\n    if (typeof prop !== 'string') return true;\n    sink.remove([...segments, prop]);\n    return true;\n  };\n}\n"]}

package/dist/types/lib/memory/TransactionBuffer.d.ts

@@ -274,6 +274,24 @@ export declare class TransactionBuffer {
      * today's full-value `set`.
      */
     private toDeltaPayload;
+    /**
+     * Did the stage change the value at `segments`? Base and final value are
+     * fixed at commit, so this is the ONE net-change verdict both payload
+     * encodings apply (a no-op write and a write-then-revert both fail it).
+     */
+    private changedSinceBase;
+    /**
+     * Path → its op-verb sequence, ordered by LAST touch (delete + re-insert
+     * moves a re-touched path to the end of the Map's insertion order —
+     * preserving last-writer-wins for nested/overlapping paths). Per-write
+     * provenance (#P1): the LAST op's readKeys is kept — read prefixes only grow
+     * within a stage, so last == union across the path.
+     */
+    private opsByPath;
+    /** The net-change filter — identical to 'full' ({@link changedSinceBase}). Survivors keep last-touch order. */
+    private netChangeSurvivors;
+    /** Replay each overlapping family ONCE, lazily — most commits have none, and pay nothing. */
+    private memoisedFamilyValue;
     /**
      * Bucket the staged ops of every OVERLAPPING family by family root, in op
      * order — the input {@link replayFamilyVerbs} folds. Ops on paths the

package/dist/types/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/types/lib/reactive/liveView.d.ts

@@ -9,9 +9,60 @@
  * found on element proxies, then the same root on nested and terminal ones).
  * So every read trap resolves through the CURRENT value and falls back to the
  * captured object only when the path is gone or no longer holds an object.
+ *
+ * The READ side of every object proxy lives here — {@link liveObject},
+ * {@link liveGetTrap}, {@link liveInspectionTraps}, and the ONE per-member
+ * proxy cache {@link cachedMember} (9.23.2); the WRITE side is
+ * `writeTraps.ts`. A factory only wires them (9.23.1).
+ */
+/**
+ * A proxy per member NAME under one parent proxy, validated by the raw
+ * member's identity. The map is allocated on the FIRST insert: an element
+ * proxy over `{ id, n }` reads only primitives and must not pay for one
+ * (10,000 of them in the naive re-read loop — measured, `bench/nested-reads.ts`).
  */
+export declare class MemberCache {
+    private entries?;
+    /** The proxy cached under `prop`, if it was built over exactly this raw `value`. */
+    hit(prop: string, value: object): unknown;
+    remember(prop: string, value: object, proxy: unknown): void;
+    /** Forget `prop` — a write replaced its value, so the next read must build over the new one. */
+    delete(prop: string): void;
+}
+/**
+ * WHY the cache: `o.arr === o.arr` must hold within a stage, and
+ * `for (i < N) s.k.arr[i]` must build ONE array proxy — whose element cache
+ * then serves every index — not N (the 9.22.0 perf review, finding 4: the
+ * nested get trap built a fresh array proxy, with a fresh empty element
+ * cache, on every `.arr`). The top-level scope has cached its child proxies
+ * this way since before 9.22.0; this is that leaf, shared by all four.
+ *
+ * Validated by IDENTITY, invalidated by replacement: every write through a
+ * proxy rebuilds the containers on its path (`structuralWrite.setInPath`),
+ * so after `s.k.arr[0].n = 1` the raw `arr` is a new array, the ref check
+ * misses, and the next read builds a proxy over the NEW value. A hit can
+ * never be stale — every proxy reads live (`liveGetTrap`), so the cached one
+ * and a fresh one answer the same.
+ *
+ * Keyed by NAME under THIS parent, never by the raw value alone: a diamond
+ * (one array under `k.a` and `k.b`) needs two proxies, each bound to its own
+ * path and sink. Only what `build` actually WRAPPED is kept — a member handed
+ * back raw (a `Date`, a frozen object, a cycle edge) is not worth an entry.
+ * `build` is the caller's stable child step, not a closure made per read: a
+ * hit allocates nothing, and a primitive member skips the cache entirely.
+ */
+export declare function cachedMember(cache: MemberCache, prop: string, value: unknown, build: (value: unknown, path: string[]) => unknown, segments: readonly string[]): unknown;
 /** The object at `segments` under the current root, or `raw` when it is gone. */
 export declare function liveObject(raw: Record<string, unknown>, current: unknown): Record<string, unknown>;
+/**
+ * WHY one get trap: the names a proxy answers ITSELF (promise/matcher guards,
+ * `constructor`, and the JSON law — serializing a proxied value equals
+ * serializing the raw one, `jsonProjection.ts`) must be the same three lines
+ * on every object proxy; any other member is handed to `child` with its full
+ * path — through the parent's {@link cachedMember} — and only THAT step
+ * differs per factory (the cycle policy).
+ */
+export declare function liveGetTrap(live: () => Record<string, unknown>, segments: readonly string[], child: (value: unknown, path: string[]) => unknown, members: MemberCache): ProxyHandler<object>['get'];
 /**
  * The three inspection traps (`in`, `Object.keys`, descriptors) answered from
  * the live object. The one Proxy invariant that could bite — a non-extensible

package/dist/types/lib/reactive/writeTraps.d.ts

@@ -0,0 +1,59 @@
+/**
+ * reactive/writeTraps — where a proxy's writes LAND, and the two traps that
+ * send them there.
+ *
+ * Every object proxy in this folder (nested, terminal, element) intercepts
+ * the same three things — a property set, a property delete, and an array
+ * mutation somewhere below it — and differs only in where the write goes:
+ * a nested/terminal proxy commits under a TOP-LEVEL KEY (an object write as
+ * `merge` of a patch, an array write or a delete as `set` of the rebuilt
+ * root); an element proxy commits the WHOLE OWNING ARRAY back through the
+ * array proxy's own callback. That difference is a {@link WriteSink}; the
+ * traps are written once over it (9.23.1 — the 9.22.0 stale-read bug was
+ * fixed in one copy of these traps and then found again in the other two).
+ */
+import type { MemberCache } from './liveView.js';
+/**
+ * The seam between a proxy and state. `path` is measured from the sink's
+ * root — the key's value for {@link rootKeySink}, the element for
+ * {@link elementSink}; `[]` is the root itself.
+ */
+export interface WriteSink {
+    /** The value at `path`, as it stands NOW (read-your-writes; never a tracked read). */
+    readAt(path: readonly string[]): unknown;
+    /** Put an already-unwrapped `value` at `path`. The sink chooses the verb. */
+    put(path: readonly string[], value: unknown): void;
+    /** Remove the key at `path`. */
+    remove(path: readonly string[]): void;
+}
+/** The two ways a value reaches a state key: what the sink writes through. */
+export interface RootKeyTarget {
+    setValue(key: string, value: unknown): void;
+    updateValue(key: string, value: unknown): void;
+}
+/**
+ * WHY: a write below a top-level key has TWO verbs (reactive/README.md, law
+ * 3) — an object leaf is a `merge` of a nested patch, an array leaf or a
+ * delete rebuilds the root immutably and commits a `set` of the key. Only the
+ * sink knows that; the traps do not. Every write drops the key's cached child
+ * proxy (`cache`), so the next read is built over the new value.
+ */
+export declare function rootKeySink(target: RootKeyTarget, readSilent: (key: string) => unknown, rootKey: string, cache: Pick<MemberCache, 'delete'>): WriteSink;
+/**
+ * WHY: a write inside an array element is an array write — it rebuilds the
+ * owning array immutably and hands the WHOLE new array to the array proxy's
+ * commit, the funnel `push` already uses. `path` is measured from the
+ * element; `[]` is the element slot itself.
+ */
+export declare function elementSink(getCurrent: () => unknown[], commit: (next: unknown[]) => void, index: number): WriteSink;
+/**
+ * WHY one set trap: the assigned value is unwrapped HERE (landmine 1 — the
+ * JSON round-trip applies to what the caller handed in, never to the
+ * surrounding state) and handed to the sink at the proxy's path plus the key.
+ */
+export declare function sinkSetTrap(sink: WriteSink, segments: readonly string[]): ProxyHandler<object>['set'];
+/**
+ * WHY one delete trap: `merge` cannot express a removal (a patch of
+ * `undefined` reads as absent), so a delete always rebuilds through the sink.
+ */
+export declare function sinkDeleteTrap(sink: WriteSink, segments: readonly string[]): ProxyHandler<object>['deleteProperty'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "footprintjs",
-  "version": "9.23.0",
+  "version": "9.23.2",
   "description": "Explainable backend flows — automatic causal traces, decision evidence, and MCP tool generation for AI agents",
   "license": "MIT",
   "author": "Sanjay Krishna Anbalagan",