@earendil-works/chord 0.85.0 → 0.86.0

package/dist/delta/index.js

@@ -46,14 +46,13 @@ const cloneJson = (value) => {
         return value;
     if (Array.isArray(value))
         return value.map((item) => cloneJson(item));
-    const result = Object.create(Object.getPrototypeOf(value) === null ? null : Object.prototype);
-    for (const [key, child] of Object.entries(value)) {
-        Object.defineProperty(result, key, {
-            value: cloneJson(child),
-            writable: true,
-            enumerable: true,
-            configurable: true,
-        });
+    // Spread preserves compact object layouts instead of reserving extra slots
+    // while growing an empty object. Both branches create own writable properties.
+    const result = (Object.getPrototypeOf(value) === null ? Object.assign(Object.create(null), value) : { ...value });
+    for (const key of Object.keys(result)) {
+        const child = result[key];
+        if (isObj(child))
+            result[key] = cloneJson(child);
     }
     return result;
 };
@@ -61,7 +60,6 @@ const INDEX = /^(?:0|[1-9]\d*)$/;
 const norm = (target, key) => typeof key === "symbol" ? key : Array.isArray(target) && INDEX.test(key) ? Number(key) : key;
 const MUTATORS = new Set(["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin"]);
 const MISSING = Symbol("missing");
-const dirtyNode = () => ({ children: new Map() });
 const spliceItems = (target, index, remove, items) => {
     const removed = Reflect.apply(Array.prototype.splice, target, [index, remove]);
     const chunkSize = 10_000;
@@ -96,11 +94,6 @@ const jsonEqual = (left, right) => {
     }
     return true;
 };
-const ownValue = (value, segment) => {
-    if (!isObj(value) || !Object.hasOwn(value, segment))
-        return MISSING;
-    return value[segment];
-};
 const emitSet = (path, value, out) => {
     const snapshot = cloneJson(value);
     if (path.length === 0)
@@ -220,197 +213,461 @@ function diffArray(before, after, path, scan, out) {
             out.push(["p", [...path], after.length, before.length - after.length, []]);
     }
 }
-const walkDirty = (before, after, node, path, scan, out) => {
-    if (node.valueDirty) {
-        diffValue(before, after, path, scan, out);
-        return;
-    }
-    if (node.array !== undefined) {
-        if (node.array.kind === "replace") {
-            if (!jsonEqual(before, after))
-                emitSet(path, after, out);
+export function track(root, options = {}) {
+    const scan = options.maxOverlapScan ?? 65_536;
+    let log = [];
+    let trie = {};
+    let nextOrder = 0;
+    let tombstones = 0;
+    let liveSlots = 0;
+    let nodeCount = 1;
+    let lastAddedSlot;
+    let hasPending = false;
+    let forceBase = true;
+    const clearPending = () => {
+        log = [];
+        trie = {};
+        nextOrder = 0;
+        tombstones = 0;
+        liveSlots = 0;
+        nodeCount = 1;
+        lastAddedSlot = undefined;
+        hasPending = false;
+    };
+    const logNode = (path) => {
+        let at = trie;
+        for (const segment of path) {
+            if (!at.kids)
+                at.kids = new Map();
+            let next = at.kids.get(segment);
+            if (next === undefined) {
+                next = {};
+                at.kids.set(segment, next);
+                nodeCount++;
+            }
+            at = next;
+        }
+        return at;
+    };
+    const findLogNode = (path) => {
+        let at = trie;
+        for (const segment of path) {
+            const next = at.kids?.get(segment);
+            if (next === undefined)
+                return undefined;
+            at = next;
+        }
+        return at;
+    };
+    const compactLog = () => {
+        if (tombstones < 1_024 || tombstones * 2 < log.length)
             return;
+        const compacted = [];
+        for (const slot of log) {
+            if (slot === undefined)
+                continue;
+            slot.index = compacted.length;
+            compacted.push(slot);
         }
-        if (!Array.isArray(before) || !Array.isArray(after) || node.array.kind === "diff") {
-            diffValue(before, after, path, scan, out);
+        log = compacted;
+        tombstones = 0;
+    };
+    const killSlot = (slot) => {
+        if (slot.dead)
             return;
+        slot.dead = true;
+        liveSlots--;
+        if (log[slot.index] === slot) {
+            log[slot.index] = undefined;
+            tombstones++;
+        }
+    };
+    const liveSlot = (at) => {
+        const slots = at.slots;
+        if (slots === undefined)
+            return undefined;
+        while (slots.length > 0 && slots[slots.length - 1].dead)
+            slots.pop();
+        if (slots.length === 0) {
+            at.slots = undefined;
+            return undefined;
         }
-        const start = node.array.start;
-        if (before.length !== start || after.length < start) {
-            diffValue(before, after, path, scan, out);
+        return slots[slots.length - 1];
+    };
+    const killHere = (at) => {
+        if (at.slots === undefined)
+            return;
+        for (const slot of at.slots)
+            killSlot(slot);
+        at.slots = undefined;
+    };
+    const addSlot = (at, slot) => {
+        compactLog();
+        slot.order = nextOrder++;
+        slot.index = log.length;
+        at.lastOrder = slot.order;
+        if (at.slots === undefined)
+            at.slots = [];
+        at.slots.push(slot);
+        log.push(slot);
+        liveSlots++;
+        lastAddedSlot = slot;
+    };
+    const collapsePending = () => {
+        // Long mutation windows can otherwise retain operations and retired path
+        // generations indefinitely. Fall back to a complete snapshot once either
+        // history exceeds a bounded coalescing window. Payload bytes and transient
+        // allocation remain workload-dependent.
+        if (forceBase || (liveSlots <= 4_096 && nodeCount <= 4_096))
             return;
+        const value = cloneJson(root);
+        clearPending();
+        hasPending = true;
+        addSlot(trie, { op: ["r", value], dead: false, order: 0, index: 0 });
+    };
+    const killSubtree = (at) => {
+        killHere(at);
+        if (at.kids !== undefined) {
+            for (const child of at.kids.values())
+                killSubtree(child);
+            at.kids = undefined;
         }
-        for (const [segment, child] of node.children) {
-            if (typeof segment !== "number" || segment >= start)
-                continue;
-            const previous = ownValue(before, segment);
-            const current = ownValue(after, segment);
-            if (previous === MISSING || current === MISSING || child.valueDirty) {
-                diffValue(previous, current, [...path, segment], scan, out);
+        if (at.retiredKids !== undefined) {
+            for (const generation of at.retiredKids) {
+                for (const child of generation.values())
+                    killSubtree(child);
             }
-            else if (isObj(previous) && isObj(current)) {
-                walkDirty(previous, current, child, [...path, segment], scan, out);
+            at.retiredKids = undefined;
+        }
+    };
+    const retireKids = (at) => {
+        if (at.kids === undefined)
+            return;
+        if (at.retiredKids === undefined)
+            at.retiredKids = [];
+        at.retiredKids.push(at.kids);
+        at.kids = undefined;
+    };
+    // Deepest live ancestor op carrying a payload we can fold a later write into.
+    // `s`/`r` carry the whole subtree; `p` carries the items it inserted, so a
+    // write to one of those indices belongs inside the payload rather than after it.
+    const foldTarget = (path) => {
+        let at = trie;
+        let found;
+        let ancestorMax = -1;
+        for (let depth = 0; depth < path.length; depth++) {
+            if (found !== undefined && at.lastOrder !== undefined && at.lastOrder > found.slot.order) {
+                found = undefined;
             }
-            else {
-                diffValue(previous, current, [...path, segment], scan, out);
+            const slot = liveSlot(at);
+            // A fold is sound only if nothing has been recorded at this path or above it
+            // since: a later op there (a splice on the same array, a replacement of an
+            // ancestor) would have to apply after this write, not before it. Writes to
+            // other branches are irrelevant, which is why this is not "the most recent op".
+            if (slot !== undefined && slot.order >= ancestorMax && at.lastOrder === slot.order) {
+                if (slot.op[0] === "s" || slot.op[0] === "r")
+                    found = { slot, depth };
+                else if (slot.op[0] === "p") {
+                    const index = path[depth];
+                    const items = slot.op[4];
+                    if (typeof index === "number" && index >= slot.op[2] && index < slot.op[2] + items.length) {
+                        found = { slot, depth: depth + 1, item: index - slot.op[2] };
+                    }
+                }
             }
+            if (at.lastOrder !== undefined && at.lastOrder > ancestorMax)
+                ancestorMax = at.lastOrder;
+            const next = at.kids?.get(path[depth]);
+            if (next === undefined)
+                break;
+            at = next;
         }
-        const items = after.slice(start);
-        if (items.length > 0)
-            out.push(["p", [...path], start, 0, cloneJson(items)]);
-        return;
-    }
-    for (const [segment, child] of node.children) {
-        const previous = ownValue(before, segment);
-        const current = ownValue(after, segment);
-        if (previous === MISSING || current === MISSING || child.valueDirty) {
-            diffValue(previous, current, [...path, segment], scan, out);
-            continue;
-        }
-        if (!isObj(previous) || !isObj(current)) {
-            diffValue(previous, current, [...path, segment], scan, out);
-            continue;
-        }
-        walkDirty(previous, current, child, [...path, segment], scan, out);
-    }
-};
-/**
- * Bring `baseline` up to `root` along the dirty paths by sharing references.
- * Returns false — having changed nothing — if any dirty node is an array
- * change other than a pure append, so the caller can replay ops instead.
- * Cloning a whole array there is O(n) per flush; replay is O(changes).
- *
- * Strings are immutable, so root's `after` is shared outright, and sharing it
- * also means the next flush compares against a flat string rather than a cons.
- * Objects are cloned because root keeps mutating them.
- */
-const syncBaseline = (baseline, root, node) => {
-    if (!canSync(node))
-        return false;
-    syncInto(baseline, root, node);
-    return true;
-};
-const canSync = (node) => {
-    if (node.array !== undefined && node.array.kind !== "append")
-        return false;
-    for (const child of node.children.values())
-        if (!canSync(child))
+        if (found === undefined)
+            return undefined;
+        return { slot: found.slot, rest: path.slice(found.depth), item: found.item };
+    };
+    const foldInto = (container, rest, op) => {
+        if (rest.length === 0)
             return false;
-    return true;
-};
-const syncInto = (baseline, root, node) => {
-    const parent = baseline;
-    if (node.array?.kind === "append" && Array.isArray(baseline) && Array.isArray(root)) {
-        const start = node.array.start;
-        for (const [index, child] of node.children) {
-            if (typeof index === "number" && index < start)
-                syncChild(parent, root, index, child);
+        let target = container;
+        for (let index = 0; index < rest.length - 1; index++) {
+            if (!isObj(target))
+                return false;
+            target = target[rest[index]];
         }
-        for (let i = start; i < root.length; i++) {
-            baseline.push(isObj(root[i]) ? cloneJson(root[i]) : root[i]);
+        if (!isObj(target))
+            return false;
+        const key = rest[rest.length - 1];
+        const holder = target;
+        const write = (value) => {
+            Object.defineProperty(holder, key, { value, writable: true, enumerable: true, configurable: true });
+        };
+        switch (op[0]) {
+            case "s":
+                if (key === "__proto__")
+                    return false;
+                write(cloneJson(op[2]));
+                return true;
+            case "d":
+                delete holder[key];
+                return true;
+            case "a": {
+                const value = holder[key];
+                if (typeof value !== "string")
+                    return false;
+                write(value + op[2]);
+                return true;
+            }
+            case "t": {
+                const value = holder[key];
+                if (typeof value !== "string")
+                    return false;
+                write(value.slice(op[2]));
+                return true;
+            }
+            case "p": {
+                const value = holder[key];
+                if (!Array.isArray(value))
+                    return false;
+                spliceItems(value, op[2], op[3], cloneJson(op[4]));
+                return true;
+            }
+            default:
+                return false;
         }
-        return;
-    }
-    for (const [segment, child] of node.children)
-        syncChild(parent, root, segment, child);
-};
-const syncChild = (parent, root, segment, child) => {
-    const current = ownValue(root, segment);
-    const previous = ownValue(parent, segment);
-    if (current === MISSING) {
-        if (Array.isArray(parent))
-            parent.splice(segment, 1);
-        else
-            delete parent[segment];
-        return;
-    }
-    if (child.valueDirty || !isObj(current) || !isObj(previous) || Array.isArray(current) !== Array.isArray(previous)) {
-        parent[segment] = isObj(current) ? cloneJson(current) : current;
-        return;
-    }
-    syncInto(previous, current, child);
-};
-const cloneOp = (op) => {
-    switch (op[0]) {
-        case "r":
-            return ["r", cloneJson(op[1])];
-        case "s":
-            return ["s", op[1], cloneJson(op[2])];
-        case "p":
-            return ["p", op[1], op[2], op[3], cloneJson(op[4])];
-        default:
-            return op;
-    }
-};
-export function track(root, options = {}) {
-    const scan = options.maxOverlapScan ?? 65_536;
-    let pending = dirtyNode();
-    let hasPending = false;
-    let baseline;
-    let forceBase = true;
-    const clearPending = () => {
-        pending = dirtyNode();
-        hasPending = false;
     };
-    const ensureNode = (path) => {
+    const recordString = (path, previous, value) => {
+        if (forceBase)
+            return;
         hasPending = true;
-        let node = pending;
-        for (const segment of path) {
-            if (node.valueDirty || node.array?.kind === "diff" || node.array?.kind === "replace")
-                return undefined;
-            let child = node.children.get(segment);
-            if (child === undefined)
-                child = dirtyNode();
-            else
-                node.children.delete(segment);
-            node.children.set(segment, child);
-            node = child;
+        // a string inside a pending payload belongs in that payload, as for any write
+        const fold = foldTarget(path);
+        if (fold !== undefined) {
+            const op = ["s", path, value];
+            if (fold.item !== undefined) {
+                const items = fold.slot.op[4];
+                if (fold.rest.length === 0) {
+                    items[fold.item] = value;
+                    return;
+                }
+                if (foldInto(items[fold.item], fold.rest, op))
+                    return;
+            }
+            else {
+                const payload = fold.slot.op[0] === "r" ? fold.slot.op[1] : fold.slot.op[2];
+                if (foldInto(payload, fold.rest, op))
+                    return;
+            }
         }
-        return node;
-    };
-    const findNode = (path) => {
-        let node = pending;
-        for (const segment of path) {
-            const child = node.children.get(segment);
-            if (child === undefined)
-                return undefined;
-            node = child;
+        const at = logNode(path);
+        const live = liveSlot(at);
+        if (live?.str !== undefined) {
+            live.str.value = value;
+            return;
+        }
+        if (live !== undefined) {
+            // a pending set or delete at this path already replaced the value; keep that
+            // op and carry the new value in it rather than anchoring to it
+            if (live.op[0] === "s" || live.op[0] === "r") {
+                live.op = live.op[0] === "r" ? ["r", value] : ["s", live.op[1], value];
+                return;
+            }
+            if (live.op[0] === "d") {
+                killHere(at);
+                addSlot(at, {
+                    op: ["s", path, value],
+                    dead: false,
+                    order: 0,
+                    index: 0,
+                });
+                return;
+            }
+            // a truncate/append pair from an earlier string diff: both must go
+            killHere(at);
         }
-        return node;
+        killSubtree(at);
+        addSlot(at, {
+            op: ["s", path, value],
+            dead: false,
+            order: 0,
+            index: 0,
+            str: { anchor: previous, value },
+        });
     };
-    const markValue = (path) => {
-        const node = ensureNode(path);
-        if (node === undefined)
+    const record = (op) => {
+        if (forceBase)
             return;
-        node.valueDirty = true;
-        node.array = undefined;
-        node.children.clear();
+        hasPending = true;
+        const path = (op[0] === "r" ? [] : op[1]);
+        const existing = findLogNode(path);
+        const anchored = existing === undefined ? undefined : liveSlot(existing);
+        if (anchored?.str !== undefined) {
+            switch (op[0]) {
+                case "a":
+                    anchored.str.value += op[2];
+                    return;
+                case "t":
+                    anchored.str.value = anchored.str.value.slice(op[2]);
+                    return;
+                case "s":
+                    if (typeof op[2] === "string") {
+                        anchored.str.value = op[2];
+                        return;
+                    }
+            }
+            if (existing !== undefined)
+                killSubtree(existing);
+        }
+        else if (existing !== undefined && (op[0] === "s" || op[0] === "d" || op[0] === "r")) {
+            // A replacement absorbed into an ancestor payload must still invalidate
+            // operations already recorded at and below its destination.
+            killSubtree(existing);
+        }
+        if (path.length > 0) {
+            const fold = foldTarget(path);
+            if (fold !== undefined) {
+                if (fold.item !== undefined) {
+                    const items = fold.slot.op[4];
+                    if (fold.rest.length === 0) {
+                        if (op[0] === "s") {
+                            items[fold.item] = cloneJson(op[2]);
+                            return;
+                        }
+                    }
+                    else if (foldInto(items[fold.item], fold.rest, op))
+                        return;
+                }
+                else {
+                    const payload = fold.slot.op[0] === "r" ? fold.slot.op[1] : fold.slot.op[2];
+                    if (foldInto(payload, fold.rest, op))
+                        return;
+                }
+            }
+        }
+        const at = logNode(path);
+        const live = liveSlot(at);
+        if (live !== undefined) {
+            const previous = live.op;
+            if (op[0] === "a" && previous[0] === "a") {
+                live.op = ["a", previous[1], previous[2] + op[2]];
+                return;
+            }
+            if (op[0] === "a" && (previous[0] === "s" || previous[0] === "r")) {
+                const value = previous[0] === "r" ? previous[1] : previous[2];
+                if (typeof value === "string") {
+                    live.op = previous[0] === "r" ? ["r", value + op[2]] : ["s", previous[1], value + op[2]];
+                    return;
+                }
+            }
+            if (op[0] === "t" && (previous[0] === "s" || previous[0] === "r")) {
+                const value = previous[0] === "r" ? previous[1] : previous[2];
+                if (typeof value === "string") {
+                    const cut = value.slice(op[2]);
+                    live.op = previous[0] === "r" ? ["r", cut] : ["s", previous[1], cut];
+                    return;
+                }
+            }
+            if (op[0] === "p" && previous[0] === "p") {
+                const previousItems = previous[4];
+                // These rewrites are sound only for adjacent recorded operations. A
+                // tombstoned operation remains a barrier through lastAddedSlot.
+                if (previous[3] === 0 &&
+                    op[3] === 0 &&
+                    previous[2] + previousItems.length === op[2] &&
+                    lastAddedSlot === live) {
+                    const items = op[4];
+                    for (let index = 0; index < items.length; index++)
+                        previousItems.push(items[index]);
+                    return;
+                }
+                if (previous[3] === 0 &&
+                    lastAddedSlot === live &&
+                    op[2] >= previous[2] &&
+                    op[2] + op[3] <= previous[2] + previousItems.length) {
+                    spliceItems(previousItems, op[2] - previous[2], op[3], op[4]);
+                    if (previousItems.length === 0 && previous[3] === 0)
+                        killSlot(live);
+                    return;
+                }
+                if (op[3] > 0 &&
+                    op[4].length === 0 &&
+                    previousItems.length > 0 &&
+                    lastAddedSlot === live) {
+                    const from = op[2] - previous[2];
+                    if (from >= 0 && from + op[3] === previousItems.length) {
+                        previousItems.length = from;
+                        if (previousItems.length === 0 && previous[3] === 0)
+                            killSlot(live);
+                        return;
+                    }
+                }
+            }
+            if (op[0] === "s" || op[0] === "d" || op[0] === "r")
+                killHere(at);
+        }
+        if (op[0] === "s" || op[0] === "r" || op[0] === "d") {
+            // Replacements dominate all earlier descendants, including generations
+            // detached by array splices.
+            killSubtree(at);
+        }
+        else if (op[0] === "p") {
+            // Splices preserve earlier writes but form a barrier for later folding.
+            retireKids(at);
+        }
+        addSlot(at, { op, dead: false, order: 0, index: 0 });
     };
-    const markArrayAppend = (path, start) => {
-        const node = ensureNode(path);
-        if (node === undefined || node.valueDirty || node.array?.kind === "diff" || node.array?.kind === "replace") {
+    // Local diff, used when a whole container is assigned: keeps op quality
+    // without a baseline by comparing the outgoing value with the incoming one at
+    // the moment of the write. String leaves go through recordString so every
+    // string path keeps a single anchored slot; otherwise a later write to the
+    // same string would have to supersede ops whose starting value it no longer
+    // knows.
+    const diffInto = (before, after, at) => {
+        if (forceBase)
+            return;
+        hasPending = true;
+        if (before === after)
+            return;
+        if (typeof before === "string" && typeof after === "string") {
+            recordString(at.slice(), before, after);
             return;
         }
-        if (node.array === undefined)
-            node.array = { kind: "append", start };
-    };
-    const markArrayDiff = (path) => {
-        const node = ensureNode(path);
-        if (node === undefined || node.valueDirty || node.array?.kind === "replace")
+        if (Array.isArray(before) && Array.isArray(after) && before.length === after.length) {
+            for (let index = 0; index < after.length; index++) {
+                at.push(index);
+                diffInto(before[index], after[index], at);
+                at.pop();
+            }
             return;
-        node.array = { kind: "diff" };
-        node.children.clear();
-    };
-    const markArrayReplace = (path) => {
-        const node = ensureNode(path);
-        if (node === undefined || node.valueDirty)
+        }
+        if (isObj(before) && isObj(after) && !Array.isArray(before) && !Array.isArray(after)) {
+            const beforeObject = before;
+            const afterObject = after;
+            const beforeKeys = Object.keys(beforeObject);
+            const afterKeys = Object.keys(afterObject);
+            if ([...beforeKeys, ...afterKeys].some((key) => RESERVED_SEGMENTS.has(key))) {
+                record(["s", at.slice(), cloneJson(after)]);
+                return;
+            }
+            for (const key of afterKeys) {
+                at.push(key);
+                if (Object.hasOwn(beforeObject, key))
+                    diffInto(beforeObject[key], afterObject[key], at);
+                else
+                    record(["s", at.slice(), cloneJson(afterObject[key])]);
+                at.pop();
+            }
+            for (const key of beforeKeys) {
+                if (!Object.hasOwn(afterObject, key))
+                    record(["d", [...at, key]]);
+            }
             return;
-        node.array = { kind: "replace" };
-        node.children.clear();
-    };
-    const appendStart = (path) => {
-        const array = findNode(path)?.array;
-        return array?.kind === "append" ? array.start : undefined;
+        }
+        // arrays of differing length, and everything else: chord's own diff
+        const out = [];
+        diffValue(before, after, at, scan, out);
+        for (const op of out)
+            record(op);
     };
     const guard = (segment) => {
         if (typeof segment === "symbol")
@@ -419,7 +676,6 @@ export function track(root, options = {}) {
             throw new UnsafePathError(segment);
         return segment;
     };
-    const adoptItems = (values) => values;
     const integer = (value) => {
         const number = Number(value);
         if (Number.isNaN(number) || number === 0)
@@ -436,189 +692,619 @@ export function track(root, options = {}) {
                 : Math.max(0, Math.min(integer(args[1]), length - index));
         return { index, remove };
     };
-    const wrap = (object, path, blockedSegment) => {
-        const childProxies = new Map();
-        const proxy = new Proxy(object, {
-            get(target, key, receiver) {
-                if (Array.isArray(target) && typeof key === "string" && MUTATORS.has(key)) {
-                    return (...args) => {
-                        if (blockedSegment !== undefined)
-                            throw new UnsafePathError(blockedSegment);
-                        const before = target.length;
-                        let result;
-                        switch (key) {
-                            case "push": {
-                                const items = adoptItems(args);
-                                if (items.length > 0)
-                                    markArrayAppend(path, before);
-                                spliceItems(target, before, 0, items);
-                                result = target.length;
-                                break;
-                            }
-                            case "unshift": {
-                                const items = adoptItems(args);
-                                if (items.length > 0)
-                                    markArrayDiff(path);
-                                spliceItems(target, 0, 0, items);
-                                result = target.length;
-                                break;
-                            }
-                            case "pop":
-                                if (before > 0) {
-                                    const start = appendStart(path);
-                                    if (start === undefined || before - 1 < start)
-                                        markArrayDiff(path);
-                                }
-                                result = Reflect.apply(Array.prototype.pop, target, args);
-                                break;
-                            case "shift":
-                                if (before > 0)
-                                    markArrayDiff(path);
-                                result = Reflect.apply(Array.prototype.shift, target, args);
-                                break;
-                            case "splice": {
-                                const items = adoptItems(args.slice(2));
-                                const { index, remove } = spliceRange(before, args);
-                                if (remove > 0 || items.length > 0) {
-                                    const start = appendStart(path);
-                                    if (index === 0 && remove === before)
-                                        markArrayReplace(path);
-                                    else if (start !== undefined && index >= start) {
-                                        // The final append payload includes all tail edits.
-                                    }
-                                    else if (index === before && remove === 0)
-                                        markArrayAppend(path, before);
-                                    else
-                                        markArrayDiff(path);
-                                }
-                                result = spliceItems(target, index, remove, items);
-                                break;
-                            }
-                            default:
-                                markArrayDiff(path);
-                                result = Reflect.apply(Array.prototype[key], target, args);
-                        }
-                        if (key === "pop")
-                            childProxies.delete(String(before - 1));
-                        else if (key !== "push")
-                            childProxies.clear();
-                        return key === "sort" || key === "reverse" || key === "fill" || key === "copyWithin" ? proxy : result;
-                    };
+    // Paths are walked from placement cells rather than baked into proxies. A held
+    // descendant keeps its cells and their owner entries alive, so an ancestor can
+    // be re-created after GC without losing array-renumbering metadata. Entries keep
+    // only weak references to public proxies; parent caches keep only weak cells.
+    let shape = 0;
+    // Ordinary tree entries are weak values. Explicit aliases are sparse and stay
+    // strong while their raw weak key is alive so alias locations survive a period
+    // in which no public proxy exists.
+    const entries = new WeakMap();
+    const aliases = new WeakMap();
+    // A live public proxy retains its entry through this ephemeron. Raw proxy RHS
+    // values can therefore be unwrapped before they are written into plain targets.
+    const proxyEntries = new WeakMap();
+    // WeakRef targets already stay alive through the current JavaScript job. These
+    // strong job-local caches avoid repeated deref bookkeeping without extending
+    // that lifetime; one microtask drops both maps before the next job.
+    let jobCells = new WeakMap();
+    let jobProxies = new WeakMap();
+    let jobCleanupScheduled = false;
+    const scheduleJobCleanup = () => {
+        if (jobCleanupScheduled)
+            return;
+        jobCleanupScheduled = true;
+        queueMicrotask(() => {
+            jobCells = new WeakMap();
+            jobProxies = new WeakMap();
+            jobCleanupScheduled = false;
+        });
+    };
+    const keepCellForJob = (ref, cell) => {
+        jobCells.set(ref, cell);
+        scheduleJobCleanup();
+    };
+    const derefCell = (ref) => {
+        const cached = jobCells.get(ref);
+        if (cached !== undefined)
+            return cached;
+        const cell = ref.deref();
+        if (cell !== undefined)
+            keepCellForJob(ref, cell);
+        return cell;
+    };
+    const entryFinalizer = new FinalizationRegistry(({ target, token }) => {
+        const raw = target.deref();
+        if (raw !== undefined && entries.get(raw)?.token === token)
+            entries.delete(raw);
+    });
+    const cellFinalizer = new FinalizationRegistry(({ owner, key, ref }) => {
+        const entry = owner.deref();
+        if (entry === undefined)
+            return;
+        if (key !== undefined && entry.childProxies?.get(key) === ref)
+            entry.childProxies.delete(key);
+        entry.childCells?.delete(ref);
+    });
+    // Almost no document ever puts one object at two positions. Until one does,
+    // every write has exactly one path, so the per-write cell walk is skipped.
+    let aliased = false;
+    const isDetached = (cell) => {
+        for (let c = cell; c !== undefined; c = c.parent)
+            if (c.dead)
+                return true;
+        return false;
+    };
+    const pathOf = (cell) => {
+        if (cell.at === shape && cell.cached !== undefined)
+            return cell.cached;
+        const out = [];
+        for (let c = cell; c !== undefined && c.parent !== undefined; c = c.parent)
+            out.push(c.seg);
+        out.reverse();
+        cell.at = shape;
+        cell.cached = out;
+        return out;
+    };
+    const liveCells = (entry) => {
+        const out = [];
+        for (const cell of entry.cells)
+            if (!isDetached(cell))
+                out.push(cell);
+        return out;
+    };
+    const primary = (entry) => (aliased ? (liveCells(entry)[0] ?? entry.fallback) : entry.fallback);
+    const pathNow = (entry) => pathOf(primary(entry));
+    const findEntry = (target) => {
+        const alias = aliases.get(target);
+        if (alias !== undefined)
+            return alias;
+        const slot = entries.get(target);
+        const entry = slot?.ref.deref();
+        if (slot !== undefined && entry === undefined)
+            entries.delete(target);
+        return entry;
+    };
+    const indexEntry = (entry) => {
+        const token = {};
+        entries.set(entry.target, { ref: new WeakRef(entry), token });
+        entryFinalizer.register(entry, { target: new WeakRef(entry.target), token });
+    };
+    const addPlacement = (entry, cell) => {
+        if (entry.cells.has(cell))
+            return;
+        let hasLive = false;
+        for (const existing of entry.cells) {
+            if (!isDetached(existing)) {
+                hasLive = true;
+                break;
+            }
+        }
+        cell.entry = entry;
+        cell.target = entry.target;
+        entry.cells.add(cell);
+        if (!hasLive) {
+            const previous = entry.fallback;
+            entry.fallback = cell;
+            if (previous !== cell) {
+                shape++;
+                // Reattaching a held container moves every known immediate child to
+                // its new placement. Array registrations survive cache clears.
+                const children = new Set();
+                for (const ref of entry.childProxies?.values() ?? []) {
+                    const child = derefCell(ref);
+                    if (child !== undefined)
+                        children.add(child);
+                }
+                for (const ref of entry.childCells ?? []) {
+                    const child = derefCell(ref);
+                    if (child !== undefined)
+                        children.add(child);
+                }
+                for (const child of children) {
+                    if (!child.dead && child.parent === previous)
+                        child.parent = cell;
+                }
+            }
+        }
+        else if (entry.blocked === undefined) {
+            aliased = true;
+            aliases.set(entry.target, entry);
+        }
+    };
+    const cachePlacement = (owner, key, cell) => {
+        let cleanup = cell.cleanup;
+        if (cleanup === undefined) {
+            cleanup = { owner: new WeakRef(owner), key: undefined, ref: new WeakRef(cell) };
+            cell.cleanup = cleanup;
+            cellFinalizer.register(cell, cleanup);
+        }
+        keepCellForJob(cleanup.ref, cell);
+        if (cleanup.key !== undefined && cleanup.key !== key && owner.childProxies?.get(cleanup.key) === cleanup.ref) {
+            owner.childProxies.delete(cleanup.key);
+        }
+        if (owner.childProxies === undefined)
+            owner.childProxies = new Map();
+        owner.childProxies.set(key, cleanup.ref);
+        cleanup.key = key;
+        if (Array.isArray(owner.target)) {
+            if (owner.childCells === undefined)
+                owner.childCells = new Set();
+            owner.childCells.add(cleanup.ref);
+        }
+    };
+    const findPlacement = (owner, parent, segment, target, blocked) => {
+        if (blocked === undefined) {
+            const known = findEntry(target);
+            if (known !== undefined) {
+                for (const cell of known.cells) {
+                    if (!cell.dead && cell.owner === owner && cell.parent === parent && cell.seg === segment)
+                        return cell;
                 }
-                const value = Reflect.get(target, key, receiver);
-                if (!isObj(value))
-                    return value;
-                const cached = childProxies.get(key);
-                if (cached?.target === value)
-                    return cached.proxy;
-                const rawSegment = norm(target, key);
-                let segment;
-                let childBlocked = blockedSegment;
-                if (blockedSegment !== undefined) {
-                    if (typeof rawSegment === "symbol")
-                        throw new UnsafePathError(String(rawSegment));
-                    segment = rawSegment;
+            }
+            return undefined;
+        }
+        // Blocked views are intentionally absent from the ordinary raw-entry index.
+        for (const ref of owner.childCells ?? []) {
+            const cell = derefCell(ref);
+            if (cell !== undefined &&
+                !cell.dead &&
+                cell.target === target &&
+                cell.entry?.blocked === blocked &&
+                cell.parent === parent &&
+                cell.seg === segment) {
+                return cell;
+            }
+        }
+        return undefined;
+    };
+    const unwrap = (value) => (isObj(value) ? (proxyEntries.get(value)?.target ?? value) : value);
+    const adoptItems = (values) => values.map(unwrap);
+    // Every operation is emitted once per live location of an explicitly aliased
+    // object. Alias cells are independent of public proxy lifetimes.
+    const emit = (entry, op) => {
+        record(op);
+        if (!aliased)
+            return;
+        const live = liveCells(entry);
+        if (live.length <= 1)
+            return;
+        const base = pathNow(entry);
+        const head = primary(entry);
+        for (const cell of live) {
+            if (cell === head || op[0] === "r")
+                continue;
+            const rest = op[1].slice(base.length);
+            const cloned = [...op];
+            cloned[1] = [...pathOf(cell), ...rest];
+            record(cloned);
+        }
+    };
+    // Structural mutation updates every still-live placement cell, including cells
+    // retained only by held descendants. Dead weak registrations are pruned lazily;
+    // finalizers keep idle live parents from accumulating them indefinitely.
+    const renumber = (entry, key, before, after, spliceAt, spliceRemove, spliceInsert) => {
+        shape++;
+        const childCells = entry.childCells;
+        if (key === "push" || !Array.isArray(entry.target) || childCells === undefined || childCells.size === 0)
+            return;
+        let index;
+        let remove = 0;
+        let insert = 0;
+        if (key === "pop") {
+            index = before - 1;
+            remove = before > 0 ? 1 : 0;
+        }
+        else if (key === "shift") {
+            index = 0;
+            remove = before > 0 ? 1 : 0;
+        }
+        else if (key === "unshift") {
+            index = 0;
+            insert = after - before;
+        }
+        else if (key === "splice") {
+            index = spliceAt;
+            remove = spliceRemove;
+            insert = spliceInsert;
+        }
+        else {
+            for (const ref of [...childCells]) {
+                const cell = derefCell(ref);
+                if (cell === undefined) {
+                    childCells.delete(ref);
+                    continue;
                 }
-                else if (typeof rawSegment === "string" &&
-                    RESERVED_SEGMENTS.has(rawSegment) &&
-                    Object.hasOwn(target, key)) {
-                    segment = rawSegment;
-                    childBlocked = rawSegment;
+                const at = entry.target.indexOf(cell.target);
+                if (at < 0) {
+                    cell.dead = true;
+                    childCells.delete(ref);
                 }
                 else
-                    segment = guard(rawSegment);
-                const child = wrap(value, [...path, segment], childBlocked);
-                childProxies.set(key, { target: value, proxy: child });
-                return child;
-            },
-            set(target, key, value) {
-                if (blockedSegment !== undefined)
-                    throw new UnsafePathError(blockedSegment);
-                if (Array.isArray(target) && key === "length") {
-                    const before = target.length;
-                    const next = Number(value);
-                    if (!Number.isSafeInteger(next) || next < 0 || next > 4_294_967_295) {
-                        return Reflect.set(target, key, value);
+                    cell.seg = at;
+            }
+            entry.childProxies?.clear();
+            return;
+        }
+        const delta = insert - remove;
+        for (const ref of [...childCells]) {
+            const cell = derefCell(ref);
+            if (cell === undefined) {
+                childCells.delete(ref);
+                continue;
+            }
+            const at = cell.seg;
+            if (typeof at !== "number")
+                continue;
+            if (at >= index && at < index + remove) {
+                cell.dead = true;
+                childCells.delete(ref);
+            }
+            else if (at >= index + remove)
+                cell.seg = at + delta;
+        }
+        entry.childProxies?.clear();
+    };
+    const wrap = (object, cell, blockedSegment) => {
+        const placed = cell.entry;
+        if (placed !== undefined && placed.target === object && placed.blocked === blockedSegment) {
+            return proxyFor(placed);
+        }
+        const existing = blockedSegment === undefined ? findEntry(object) : undefined;
+        if (existing !== undefined) {
+            addPlacement(existing, cell);
+            return proxyFor(existing);
+        }
+        const entry = {
+            target: object,
+            cells: new Set(),
+            fallback: cell,
+            blocked: blockedSegment,
+            proxy: undefined,
+            childProxies: undefined,
+            childCells: undefined,
+        };
+        addPlacement(entry, cell);
+        if (blockedSegment === undefined)
+            indexEntry(entry);
+        return proxyFor(entry);
+    };
+    const handlerPrototype = {
+        get(target, key, receiver) {
+            const entry = this.entry;
+            if (Array.isArray(target) && typeof key === "string" && MUTATORS.has(key)) {
+                return (...args) => {
+                    if (entry.blocked !== undefined)
+                        throw new UnsafePathError(entry.blocked);
+                    const detached = aliased ? liveCells(entry).length === 0 : isDetached(entry.fallback);
+                    if (detached) {
+                        return Reflect.apply(Array.prototype[key], target, args.map(unwrap));
                     }
-                    if (next < before) {
-                        const start = appendStart(path);
-                        if (next === 0)
-                            markArrayReplace(path);
-                        else if (start === undefined || next < start)
-                            markArrayDiff(path);
-                        Reflect.set(target, key, next);
-                        childProxies.clear();
+                    const before = target.length;
+                    let spliceAt = -1;
+                    let spliceRemove = 0;
+                    let spliceInsert = 0;
+                    let insertAt = -1;
+                    let insertCount = 0;
+                    let result;
+                    switch (key) {
+                        case "push": {
+                            const items = adoptItems(args);
+                            if (items.length > 0)
+                                emit(entry, ["p", [...pathNow(entry)], before, 0, cloneJson(items)]);
+                            insertAt = before;
+                            insertCount = items.length;
+                            spliceItems(target, before, 0, items);
+                            result = target.length;
+                            break;
+                        }
+                        case "unshift": {
+                            const items = adoptItems(args);
+                            if (items.length > 0)
+                                emit(entry, ["p", [...pathNow(entry)], 0, 0, cloneJson(items)]);
+                            insertAt = 0;
+                            insertCount = items.length;
+                            spliceItems(target, 0, 0, items);
+                            result = target.length;
+                            break;
+                        }
+                        case "pop":
+                            if (before > 0)
+                                emit(entry, ["p", [...pathNow(entry)], before - 1, 1, []]);
+                            result = Reflect.apply(Array.prototype.pop, target, args);
+                            break;
+                        case "shift":
+                            if (before > 0)
+                                emit(entry, ["p", [...pathNow(entry)], 0, 1, []]);
+                            result = Reflect.apply(Array.prototype.shift, target, args);
+                            break;
+                        case "splice": {
+                            const items = adoptItems(args.slice(2));
+                            const { index, remove } = spliceRange(before, args);
+                            spliceAt = index;
+                            spliceRemove = remove;
+                            spliceInsert = items.length;
+                            insertAt = index;
+                            insertCount = items.length;
+                            if (remove > 0 || items.length > 0) {
+                                if (index === 0 && remove === before) {
+                                    if (pathNow(entry).length === 0)
+                                        emit(entry, ["r", cloneJson(items)]);
+                                    else
+                                        emit(entry, [
+                                            "s",
+                                            [...pathNow(entry)],
+                                            cloneJson(items),
+                                        ]);
+                                }
+                                else
+                                    emit(entry, ["p", [...pathNow(entry)], index, remove, cloneJson(items)]);
+                            }
+                            result = spliceItems(target, index, remove, items);
+                            break;
+                        }
+                        default: {
+                            result = Reflect.apply(Array.prototype[key], target, args.map(unwrap));
+                            if (pathNow(entry).length === 0)
+                                emit(entry, ["r", cloneJson(target)]);
+                            else
+                                emit(entry, [
+                                    "s",
+                                    [...pathNow(entry)],
+                                    cloneJson(target),
+                                ]);
+                        }
                     }
-                    else if (next > before) {
-                        markArrayAppend(path, before);
-                        target.length = next;
-                        target.fill(null, before);
+                    collapsePending();
+                    renumber(entry, key, before, target.length, spliceAt, spliceRemove, spliceInsert);
+                    for (let index = insertAt; insertCount > 0 && index < insertAt + insertCount; index++) {
+                        const item = target[index];
+                        if (!isObj(item))
+                            continue;
+                        const known = findEntry(item);
+                        if (known === undefined || known.target === entry.target)
+                            continue;
+                        const parent = primary(entry);
+                        let seen = false;
+                        for (const existingCell of known.cells) {
+                            if (!existingCell.dead && existingCell.parent === parent && existingCell.seg === index)
+                                seen = true;
+                        }
+                        if (!seen) {
+                            const inserted = {
+                                parent,
+                                owner: entry,
+                                entry: undefined,
+                                target: item,
+                                seg: index,
+                                dead: false,
+                            };
+                            addPlacement(known, inserted);
+                            cachePlacement(entry, String(index), inserted);
+                        }
                     }
-                    return true;
-                }
-                const segment = guard(norm(target, key));
-                if (Array.isArray(target)) {
-                    if (typeof segment !== "number")
-                        throw new UnsafePathError(segment);
-                    if (segment > target.length)
-                        throw new UnsafePathError(segment);
+                    return key === "sort" || key === "reverse" || key === "fill" || key === "copyWithin" ? receiver : result;
+                };
+            }
+            const value = Reflect.get(target, key, receiver);
+            if (!isObj(value))
+                return value;
+            const cachedRef = entry.childProxies?.get(key);
+            const cached = cachedRef === undefined ? undefined : derefCell(cachedRef);
+            if (cached !== undefined && cached.target === value && cached.entry !== undefined) {
+                return proxyFor(cached.entry);
+            }
+            if (cachedRef !== undefined && cached === undefined && entry.childProxies?.get(key) === cachedRef) {
+                entry.childProxies?.delete(key);
+            }
+            const rawSegment = norm(target, key);
+            let segment;
+            let childBlocked = entry.blocked;
+            if (entry.blocked !== undefined) {
+                if (typeof rawSegment === "symbol")
+                    throw new UnsafePathError(String(rawSegment));
+                segment = rawSegment;
+            }
+            else if (typeof rawSegment === "string" && RESERVED_SEGMENTS.has(rawSegment) && Object.hasOwn(target, key)) {
+                segment = rawSegment;
+                childBlocked = rawSegment;
+            }
+            else
+                segment = guard(rawSegment);
+            const parent = primary(entry);
+            const existingCell = findPlacement(entry, parent, segment, value, childBlocked);
+            if (existingCell?.entry !== undefined) {
+                cachePlacement(entry, key, existingCell);
+                return proxyFor(existingCell.entry);
+            }
+            const childCell = {
+                parent,
+                owner: entry,
+                entry: undefined,
+                target: value,
+                seg: segment,
+                dead: false,
+            };
+            const child = wrap(value, childCell, childBlocked);
+            cachePlacement(entry, key, childCell);
+            return child;
+        },
+        set(target, key, value) {
+            const entry = this.entry;
+            if (entry.blocked !== undefined)
+                throw new UnsafePathError(entry.blocked);
+            const rawValue = unwrap(value);
+            if (aliased ? liveCells(entry).length === 0 : isDetached(entry.fallback)) {
+                return Reflect.set(target, key, rawValue);
+            }
+            if (Array.isArray(target) && key === "length") {
+                const before = target.length;
+                const next = Number(rawValue);
+                if (!Number.isSafeInteger(next) || next < 0 || next > 4_294_967_295) {
+                    return Reflect.set(target, key, rawValue);
                 }
-                const at = [...path, segment];
-                if (value === undefined) {
-                    if (Array.isArray(target)) {
-                        throw new TypeError("undefined would create a sparse array; use splice instead");
+                if (next < before) {
+                    if (next === 0) {
+                        if (pathNow(entry).length === 0)
+                            emit(entry, ["r", []]);
+                        else
+                            emit(entry, ["s", [...pathNow(entry)], []]);
                     }
-                    markValue(at);
-                    childProxies.delete(key);
-                    return Reflect.deleteProperty(target, key);
+                    else
+                        emit(entry, ["p", [...pathNow(entry)], next, before - next, []]);
+                    Reflect.set(target, key, next);
+                    renumber(entry, "splice", before, next, next, before - next, 0);
+                    entry.childProxies?.clear();
                 }
-                const previous = target[key];
-                if (previous === value)
-                    return true;
-                const cached = childProxies.get(key);
-                if (cached !== undefined && cached.target === previous && cached.proxy === value)
-                    return true;
-                if (Array.isArray(target)) {
-                    const index = segment;
-                    if (index === target.length)
-                        markArrayAppend(path, target.length);
-                    else {
-                        const start = appendStart(path);
-                        if (start === undefined || index < start)
-                            markValue(at);
-                    }
+                else if (next > before) {
+                    target.length = next;
+                    target.fill(null, before);
+                    const grown = new Array(next - before).fill(null);
+                    emit(entry, ["p", [...pathNow(entry)], before, 0, grown]);
                 }
+                collapsePending();
+                return true;
+            }
+            const segment = guard(norm(target, key));
+            if (Array.isArray(target)) {
+                if (typeof segment !== "number")
+                    throw new UnsafePathError(segment);
+                if (segment > target.length)
+                    throw new UnsafePathError(segment);
+            }
+            const at = [...pathNow(entry), segment];
+            if (rawValue === undefined) {
+                if (Array.isArray(target))
+                    throw new TypeError("undefined would create a sparse array; use splice instead");
+                if (Object.hasOwn(target, key))
+                    emit(entry, ["d", at]);
+                entry.childProxies?.delete(key);
+                const deleted = Reflect.deleteProperty(target, key);
+                if (deleted)
+                    collapsePending();
+                return deleted;
+            }
+            const previous = target[key];
+            if (previous === rawValue)
+                return true;
+            if (Array.isArray(target) && segment === target.length) {
+                emit(entry, ["p", [...pathNow(entry)], target.length, 0, [cloneJson(rawValue)]]);
+            }
+            else if (isObj(previous) && isObj(rawValue)) {
+                diffInto(previous, rawValue, [...pathNow(entry), segment]);
+            }
+            else if (typeof previous === "string" && typeof rawValue === "string") {
+                if (!aliased)
+                    recordString([...pathNow(entry), segment], previous, rawValue);
                 else
-                    markValue(at);
-                childProxies.delete(key);
-                return Reflect.set(target, key, value);
-            },
-            deleteProperty(target, key) {
-                if (blockedSegment !== undefined)
-                    throw new UnsafePathError(blockedSegment);
-                const segment = guard(norm(target, key));
-                if (Array.isArray(target)) {
-                    if (typeof segment !== "number")
-                        throw new UnsafePathError(segment);
-                    throw new TypeError("delete would create a sparse array; use splice instead");
+                    for (const cell of liveCells(entry))
+                        recordString([...pathOf(cell), segment], previous, rawValue);
+            }
+            else {
+                emit(entry, ["s", at, cloneJson(rawValue)]);
+            }
+            entry.childProxies?.delete(key);
+            const updated = Reflect.set(target, key, rawValue);
+            if (updated) {
+                if (isObj(rawValue)) {
+                    const known = findEntry(rawValue);
+                    if (known !== undefined) {
+                        const placement = {
+                            parent: primary(entry),
+                            owner: entry,
+                            entry: undefined,
+                            target: rawValue,
+                            seg: segment,
+                            dead: false,
+                        };
+                        addPlacement(known, placement);
+                        cachePlacement(entry, key, placement);
+                    }
                 }
-                markValue([...path, segment]);
-                childProxies.delete(key);
+                collapsePending();
+            }
+            return updated;
+        },
+        deleteProperty(target, key) {
+            const entry = this.entry;
+            if (entry.blocked !== undefined)
+                throw new UnsafePathError(entry.blocked);
+            if (aliased ? liveCells(entry).length === 0 : isDetached(entry.fallback)) {
                 return Reflect.deleteProperty(target, key);
-            },
-            defineProperty() {
-                throw new TypeError("defineProperty is not supported on tracked state; use assignment");
-            },
-            setPrototypeOf() {
-                throw new TypeError("setPrototypeOf is not supported on tracked state");
-            },
-            preventExtensions() {
-                throw new TypeError("preventExtensions is not supported on tracked state");
-            },
-        });
+            }
+            const segment = guard(norm(target, key));
+            if (Array.isArray(target)) {
+                if (typeof segment !== "number")
+                    throw new UnsafePathError(segment);
+                throw new TypeError("delete would create a sparse array; use splice instead");
+            }
+            if (Object.hasOwn(target, key))
+                emit(entry, ["d", [...pathNow(entry), segment]]);
+            entry.childProxies?.delete(key);
+            const deleted = Reflect.deleteProperty(target, key);
+            if (deleted)
+                collapsePending();
+            return deleted;
+        },
+        defineProperty() {
+            throw new TypeError("defineProperty is not supported on tracked state; use assignment");
+        },
+        setPrototypeOf() {
+            throw new TypeError("setPrototypeOf is not supported on tracked state");
+        },
+        preventExtensions() {
+            throw new TypeError("preventExtensions is not supported on tracked state");
+        },
+    };
+    function proxyFor(entry) {
+        const cached = jobProxies.get(entry);
+        if (cached !== undefined)
+            return cached;
+        const existing = entry.proxy?.deref();
+        if (existing !== undefined) {
+            jobProxies.set(entry, existing);
+            scheduleJobCleanup();
+            return existing;
+        }
+        const handler = Object.create(handlerPrototype);
+        handler.entry = entry;
+        const proxy = new Proxy(entry.target, handler);
+        entry.proxy = new WeakRef(proxy);
+        jobProxies.set(entry, proxy);
+        scheduleJobCleanup();
+        proxyEntries.set(proxy, entry);
         return proxy;
+    }
+    const rootCell = {
+        parent: undefined,
+        owner: undefined,
+        entry: undefined,
+        target: root,
+        seg: "",
+        dead: false,
     };
-    let state = wrap(root, []);
+    let state = wrap(root, rootCell);
     return {
         get state() {
             return state;
@@ -627,15 +1313,22 @@ export function track(root, options = {}) {
             return root;
         },
         set state(next) {
-            if (next === state) {
+            const rawNext = unwrap(next);
+            if (rawNext === root) {
                 clearPending();
                 forceBase = true;
                 return;
             }
             clearPending();
-            root = next;
-            state = wrap(root, []);
-            baseline = undefined;
+            root = rawNext;
+            state = wrap(root, {
+                parent: undefined,
+                owner: undefined,
+                entry: undefined,
+                target: root,
+                seg: "",
+                dead: false,
+            });
             forceBase = true;
         },
         rebase() {
@@ -643,33 +1336,31 @@ export function track(root, options = {}) {
             forceBase = true;
         },
         get dirty() {
+            // conservative: true if anything was written since the last flush, even
+            // if the writes cancelled out
             return forceBase || hasPending;
         },
         discard() {
-            baseline = cloneJson(root);
             clearPending();
         },
         flush() {
             if (forceBase) {
                 const value = cloneJson(root);
-                baseline = cloneJson(root);
                 forceBase = false;
                 clearPending();
                 return [["r", value]];
             }
-            if (!hasPending || baseline === undefined)
+            if (!hasPending)
                 return [];
             const out = [];
-            walkDirty(baseline, root, pending, [], scan, out);
-            // Advance the baseline by SHARING references from root where that is
-            // cheap and exact — scalars, strings, and array appends. Replaying the
-            // ops rebuilds every touched string via slice + concat: two window-sized
-            // allocations per flush and a cons the next flush must flatten. For
-            // anything the sync cannot express cheaply (a non-append array change),
-            // it declines and the original replay runs unchanged.
-            if (!syncBaseline(baseline, root, pending)) {
-                if (out.length > 0)
-                    baseline = apply(baseline, out.map(cloneOp));
+            for (const slot of log) {
+                if (slot === undefined || slot.dead)
+                    continue;
+                if (slot.str !== undefined) {
+                    diffValue(slot.str.anchor, slot.str.value, slot.op[1], scan, out);
+                    continue;
+                }
+                out.push(slot.op);
             }
             clearPending();
             return out;