footprintjs 9.23.0 → 9.23.2

package/dist/esm/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/esm/lib/reactive/liveView.js

@@ -9,13 +9,95 @@
  * 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).
+ */
+import { toJSONView } from './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`).
  */
+export 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);
+    }
+}
+/**
+ * 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 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;
+}
 /** The object at `segments` under the current root, or `raw` when it is gone. */
 export function liveObject(raw, current) {
     return current !== null && typeof current === 'object' && !Array.isArray(current)
         ? current
         : raw;
 }
+/**
+ * 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 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 () => toJSONView(raw);
+        return cachedMember(members, prop, raw[prop], child, segments);
+    };
+}
 /**
  * The three inspection traps (`in`, `Object.keys`, descriptors) answered from
  * the live object. The one Proxy invariant that could bite — a non-extensible
@@ -40,4 +122,4 @@ export function liveInspectionTraps(live) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGl2ZVZpZXcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3JlYWN0aXZlL2xpdmVWaWV3LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztHQVdHO0FBRUgsaUZBQWlGO0FBQ2pGLE1BQU0sVUFBVSxVQUFVLENBQUMsR0FBNEIsRUFBRSxPQUFnQjtJQUN2RSxPQUFPLE9BQU8sS0FBSyxJQUFJLElBQUksT0FBTyxPQUFPLEtBQUssUUFBUSxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUM7UUFDL0UsQ0FBQyxDQUFFLE9BQW1DO1FBQ3RDLENBQUMsQ0FBQyxHQUFHLENBQUM7QUFDVixDQUFDO0FBRUQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0sVUFBVSxtQkFBbUIsQ0FDakMsSUFBa0I7SUFFbEIsT0FBTztRQUNMLEdBQUcsQ0FBQyxNQUFNLEVBQUUsSUFBSTtZQUNkLE9BQU8sT0FBTyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQzFFLENBQUM7UUFDRCxPQUFPLENBQUMsTUFBTTtZQUNaLE9BQU8sT0FBTyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDeEUsQ0FBQztRQUNELHdCQUF3QixDQUFDLE1BQU0sRUFBRSxJQUFJO1lBQ25DLElBQUksQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLE1BQU0sQ0FBQztnQkFBRSxPQUFPLE1BQU0sQ0FBQyx3QkFBd0IsQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUM7WUFDdkYsTUFBTSxVQUFVLEdBQUcsTUFBTSxDQUFDLHdCQUF3QixDQUFDLElBQUksRUFBRSxFQUFFLElBQUksQ0FBQyxDQUFDO1lBQ2pFLE9BQU8sVUFBVSxJQUFJLENBQUMsVUFBVSxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUMsRUFBRSxHQUFHLFVBQVUsRUFBRSxZQUFZLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDLFVBQVUsQ0FBQztRQUNyRyxDQUFDO0tBQ0YsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIHJlYWN0aXZlL2xpdmVWaWV3IOKAlCB3aGF0IGEgcHJveHkgc3RhbmRzIGZvciwgQVMgSVQgU1RBTkRTIE5PVy5cbiAqXG4gKiBFdmVyeSB3cml0ZSB0aHJvdWdoIHRoZSB0eXBlZCBzY29wZSByZWJ1aWxkcyB0aGUgcm9vdCBpbW11dGFibHlcbiAqIChgc3RydWN0dXJhbFdyaXRlLnNldEluUGF0aGAsIGEgZnJlc2ggbWVyZ2UpLCBzbyB0aGUgb2JqZWN0IGEgcHJveHkgd2FzXG4gKiBjcmVhdGVkIG92ZXIgaXMgdGhlIFBSRS13cml0ZSB2YWx1ZSBmb3IgZXZlciBhZnRlci4gQSBoZWxkIHByb3h5IHRoYXQgcmVhZFxuICogZnJvbSBpdCBzYXcgaXRzIG93biB3cml0ZXMgdmFuaXNoOiBgby54ICs9IDFgIHR3aWNlIGdhdmUgMiwgYG8uYiA9IG8uYSAqIDEwYFxuICogdXNlZCB0aGUgb2xkIGBhYCwgYCd4JyBpbiBvYCB3YXMgZmFsc2UgcmlnaHQgYWZ0ZXIgYG8ueCA9IDFgICg5LjIyLjAg4oCUIGZpcnN0XG4gKiBmb3VuZCBvbiBlbGVtZW50IHByb3hpZXMsIHRoZW4gdGhlIHNhbWUgcm9vdCBvbiBuZXN0ZWQgYW5kIHRlcm1pbmFsIG9uZXMpLlxuICogU28gZXZlcnkgcmVhZCB0cmFwIHJlc29sdmVzIHRocm91Z2ggdGhlIENVUlJFTlQgdmFsdWUgYW5kIGZhbGxzIGJhY2sgdG8gdGhlXG4gKiBjYXB0dXJlZCBvYmplY3Qgb25seSB3aGVuIHRoZSBwYXRoIGlzIGdvbmUgb3Igbm8gbG9uZ2VyIGhvbGRzIGFuIG9iamVjdC5cbiAqL1xuXG4vKiogVGhlIG9iamVjdCBhdCBgc2VnbWVudHNgIHVuZGVyIHRoZSBjdXJyZW50IHJvb3QsIG9yIGByYXdgIHdoZW4gaXQgaXMgZ29uZS4gKi9cbmV4cG9ydCBmdW5jdGlvbiBsaXZlT2JqZWN0KHJhdzogUmVjb3JkPHN0cmluZywgdW5rbm93bj4sIGN1cnJlbnQ6IHVua25vd24pOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPiB7XG4gIHJldHVybiBjdXJyZW50ICE9PSBudWxsICYmIHR5cGVvZiBjdXJyZW50ID09PSAnb2JqZWN0JyAmJiAhQXJyYXkuaXNBcnJheShjdXJyZW50KVxuICAgID8gKGN1cnJlbnQgYXMgUmVjb3JkPHN0cmluZywgdW5rbm93bj4pXG4gICAgOiByYXc7XG59XG5cbi8qKlxuICogVGhlIHRocmVlIGluc3BlY3Rpb24gdHJhcHMgKGBpbmAsIGBPYmplY3Qua2V5c2AsIGRlc2NyaXB0b3JzKSBhbnN3ZXJlZCBmcm9tXG4gKiB0aGUgbGl2ZSBvYmplY3QuIFRoZSBvbmUgUHJveHkgaW52YXJpYW50IHRoYXQgY291bGQgYml0ZSDigJQgYSBub24tZXh0ZW5zaWJsZVxuICogdGFyZ2V0IG11c3QgcmVwb3J0IGV4YWN0bHkgaXRzIG93biBrZXlzLCBhbmQgYSBwcm9wZXJ0eSB0aGUgdGFyZ2V0IGxhY2tzXG4gKiBtdXN0IGJlIHJlcG9ydGVkIGNvbmZpZ3VyYWJsZSDigJQgaXMgaG9ub3VyZWQ6IHRoZSBhbGxvd2xpc3QgYWxyZWFkeSByZWZ1c2VzXG4gKiBmcm96ZW4gYW5kIHNlYWxlZCB2YWx1ZXMsIHNvIHRoZSBgcHJldmVudEV4dGVuc2lvbnNgLW9ubHkgY29ybmVyIGFuc3dlcnNcbiAqIGZyb20gdGhlIHRhcmdldCwgYW5kIGEgbGl2ZSBkZXNjcmlwdG9yIGlzIGFsd2F5cyByZXBvcnRlZCBjb25maWd1cmFibGUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBsaXZlSW5zcGVjdGlvblRyYXBzKFxuICBsaXZlOiAoKSA9PiBvYmplY3QsXG4pOiBQaWNrPFByb3h5SGFuZGxlcjxvYmplY3Q+LCAnaGFzJyB8ICdvd25LZXlzJyB8ICdnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3InPiB7XG4gIHJldHVybiB7XG4gICAgaGFzKHRhcmdldCwgcHJvcCkge1xuICAgICAgcmV0dXJuIFJlZmxlY3QuaGFzKE9iamVjdC5pc0V4dGVuc2libGUodGFyZ2V0KSA/IGxpdmUoKSA6IHRhcmdldCwgcHJvcCk7XG4gICAgfSxcbiAgICBvd25LZXlzKHRhcmdldCkge1xuICAgICAgcmV0dXJuIFJlZmxlY3Qub3duS2V5cyhPYmplY3QuaXNFeHRlbnNpYmxlKHRhcmdldCkgPyBsaXZlKCkgOiB0YXJnZXQpO1xuICAgIH0sXG4gICAgZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9yKHRhcmdldCwgcHJvcCkge1xuICAgICAgaWYgKCFPYmplY3QuaXNFeHRlbnNpYmxlKHRhcmdldCkpIHJldHVybiBPYmplY3QuZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9yKHRhcmdldCwgcHJvcCk7XG4gICAgICBjb25zdCBkZXNjcmlwdG9yID0gT2JqZWN0LmdldE93blByb3BlcnR5RGVzY3JpcHRvcihsaXZlKCksIHByb3ApO1xuICAgICAgcmV0dXJuIGRlc2NyaXB0b3IgJiYgIWRlc2NyaXB0b3IuY29uZmlndXJhYmxlID8geyAuLi5kZXNjcmlwdG9yLCBjb25maWd1cmFibGU6IHRydWUgfSA6IGRlc2NyaXB0b3I7XG4gICAgfSxcbiAgfTtcbn1cbiJdfQ==
+//# 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/esm/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/dist/esm/lib/reactive/writeTraps.js

@@ -0,0 +1,132 @@
+/**
+ * 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 { nativeGet } from '../memory/pathOps.js';
+import { buildNestedPatch } from './pathBuilder.js';
+import { deleteInPath, setInPath, unwrapProxy } from './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.
+ */
+export function rootKeySink(target, readSilent, rootKey, cache) {
+    return new RootKeySink(target, readSilent, rootKey, cache);
+}
+/** 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 : nativeGet(root, path);
+    }
+    put(path, value) {
+        if (!Array.isArray(value))
+            this.target.updateValue(this.rootKey, buildNestedPatch(path, value));
+        else
+            this.target.setValue(this.rootKey, path.length === 0 ? value : setInPath(this.readAt([]), path, value));
+        this.cache.delete(this.rootKey);
+    }
+    remove(path) {
+        this.target.setValue(this.rootKey, 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.
+ */
+export function elementSink(getCurrent, commit, index) {
+    return new ElementSink(getCurrent, commit, index);
+}
+/** 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 : 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 : 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] = 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.
+ */
+export function sinkSetTrap(sink, segments) {
+    return (_target, prop, value) => {
+        if (typeof prop !== 'string')
+            return true;
+        sink.put([...segments, prop], unwrapProxy(value));
+        return true;
+    };
+}
+/**
+ * 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 function sinkDeleteTrap(sink, segments) {
+    return (_target, prop) => {
+        if (typeof prop !== 'string')
+            return true;
+        sink.remove([...segments, prop]);
+        return true;
+    };
+}
+//# 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"]}