@rohal12/spindle 0.59.5 → 0.59.6

package/dist/pkg/headless.js

@@ -13244,13 +13244,14 @@ function atomicName(value) {
 * Members of Object.prototype (`constructor`, `toString`, `__proto__`, ...)
 * are not story state: unless an object holds one as its own property, it
 * reads as missing, as setByPath() treats it. Other inherited properties
-* (class getters, `size` of a Map) are read.
+* (class getters, `size` of a Map) are read, and so are those of a string,
+* number or boolean (`length` of a string), as JavaScript boxes them.
 */
 function getByPath(obj, segments) {
 	let current = obj;
 	for (const seg of segments) {
-		if (current == null || typeof current !== "object") return void 0;
-		if (seg in Object.prototype && !hasOwn(current, seg)) return void 0;
+		if (current == null) return void 0;
+		if (seg in Object.prototype && !hasOwn(Object(current), seg)) return;
 		current = current[seg];
 	}
 	return current;
@@ -13407,14 +13408,21 @@ function deepClone(value, options = {}) {
 		if (isTemporal(val)) return val;
 		if (val instanceof Error) {
 			const copy = keep(val, Object.create(Object.getPrototypeOf(val)));
-			for (const key of [...ERROR_HIDDEN_KEYS, "stack"]) if (hasOwn(val, key)) Object.defineProperty(copy, key, {
-				value: clone(val[key]),
-				writable: true,
-				configurable: true
-			});
+			for (const key of [...ERROR_HIDDEN_KEYS, "stack"]) if (hasOwn(val, key)) {
+				const held = val[key];
+				Object.defineProperty(copy, key, {
+					value: settled(clone(held), held),
+					writable: true,
+					configurable: true
+				});
+			}
 			return copyKeys(val, copy);
 		}
 	}
+	function settled(copy, original) {
+		const settle = options.settle;
+		return settle && isObjectValue(copy) && isObjectValue(original) ? settle(copy, original) : copy;
+	}
 	function clone(val) {
 		if (val === null || typeof val !== "object") return val;
 		const obj = val;
@@ -13426,16 +13434,12 @@ function deepClone(value, options = {}) {
 		}
 		if (val instanceof Map) {
 			const copy = keep(obj, /* @__PURE__ */ new Map());
-			for (const [k, v] of val) {
-				const key = clone(k);
-				const settle = options.mapKey;
-				copy.set(settle && isObjectValue(key) && isObjectValue(k) ? settle(key, k) : key, clone(v));
-			}
+			for (const [k, v] of val) copy.set(settled(clone(k), k), clone(v));
 			return copy;
 		}
 		if (val instanceof Set) {
 			const copy = keep(obj, /* @__PURE__ */ new Set());
-			for (const v of val) copy.add(clone(v));
+			for (const v of val) copy.add(settled(clone(v), v));
 			return copy;
 		}
 		const builtin = cloneBuiltin(obj);
@@ -13635,7 +13639,9 @@ function mergesWith(a, b, arrays) {
 * is none either. Values that merge are reported as 'nested', to be
 * compared key by key; they may still be equal. With `arrays`, arrays
 * merge too: elements at the indices both hold are compared, and the
-* elements one has beyond the other's length are added or deleted.
+* elements one has beyond the other's length are added or deleted. An
+* index that holds no element (a hole) is no element, not an undefined one,
+* and holes the length gained at the end are the change of `length`, by how many.
 */
 function keyChanges(before, after, arrays) {
 	const changes = [];
@@ -13656,16 +13662,41 @@ function keyChanges(before, after, arrays) {
 	if (Array.isArray(after)) {
 		const b = before;
 		const a = after;
-		for (let i = 0; i < Math.min(b.length, a.length); i++) compare(String(i), b[i], a[i]);
-		for (let i = b.length; i < a.length; i++) changes.push({
-			key: String(i),
-			kind: "added",
-			after: a[i]
-		});
+		for (let i = 0; i < Math.min(b.length, a.length); i++) {
+			const key = String(i);
+			if (i in b && i in a) compare(key, b[i], a[i]);
+			else if (i in b) changes.push({
+				key,
+				kind: "deleted",
+				hole: true
+			});
+			else if (i in a) changes.push({
+				key,
+				kind: "added",
+				after: a[i]
+			});
+		}
+		let next = b.length;
+		for (let i = b.length; i < a.length; i++) {
+			if (!(i in a)) continue;
+			const gap = i - next;
+			changes.push({
+				key: String(i),
+				kind: "added",
+				after: a[i],
+				...gap ? { gap } : {}
+			});
+			next = i + 1;
+		}
 		for (let i = a.length; i < b.length; i++) changes.push({
 			key: String(i),
 			kind: "deleted"
 		});
+		if (a.length > next) changes.push({
+			key: "length",
+			kind: "holes",
+			after: a.length - next
+		});
 		return changes;
 	}
 	for (const key of Object.keys(after)) if (hasOwn(before, key)) compare(key, before[key], after[key]);
@@ -13689,22 +13720,39 @@ function keyChanges(before, after, arrays) {
 function diffPaths(before, after, arrays = false) {
 	const changes = [];
 	const ancestors = /* @__PURE__ */ new Set();
+	const unchanged = /* @__PURE__ */ new WeakMap();
+	let cuts = 0;
 	(function walk(b, a, path) {
-		if (ancestors.has(a)) return;
+		if (ancestors.has(a)) {
+			cuts++;
+			return;
+		}
+		if (unchanged.get(a)?.has(b)) return;
 		ancestors.add(a);
+		const found = changes.length;
+		const cutsBefore = cuts;
 		for (const change of keyChanges(b, a, arrays)) {
 			const at = [...path, change.key];
 			if (change.kind === "nested") walk(change.before, change.after, at);
 			else changes.push(change.kind === "deleted" ? {
 				path: at,
-				deleted: true
+				deleted: true,
+				...change.hole ? { hole: true } : {}
 			} : {
 				path: at,
 				deleted: false,
 				value: change.after,
-				...change.kind === "added" && Array.isArray(a) ? { appended: true } : {}
+				...change.kind === "added" && Array.isArray(a) && Number(change.key) >= b.length ? {
+					appended: true,
+					...change.gap ? { gap: change.gap } : {}
+				} : {}
 			});
 		}
+		if (changes.length === found && cuts === cutsBefore) {
+			const seen = unchanged.get(a) ?? /* @__PURE__ */ new Set();
+			seen.add(b);
+			unchanged.set(a, seen);
+		}
 		ancestors.delete(a);
 	})(before, after, []);
 	return changes;
@@ -13715,8 +13763,62 @@ function underChange(path, keys) {
 	for (let n = 1; n <= path.length; n++) if (keys.has(pathKey(path.slice(0, n)))) return true;
 	return false;
 }
-/** The segment standing for the entry `index` of a Map or Set in a path. */
+/**
+* The segment standing for the entry `index` of a Map or Set in a path, or
+* for the `cause` or `errors` of an Error ('c', 'e').
+*/
 var entryKey = (kind, index) => `\0${kind}${index}`;
+var isEntryKey = (segment) => segment.startsWith("\0");
+/**
+* What a Map, Set or Error holds in place of properties (keys and values,
+* members, `cause` and `errors`), each with the segment standing for it in
+* a path (see entryKey); undefined for any other value.
+*/
+function entryChildren(value) {
+	const children = [];
+	if (value instanceof Map) {
+		let index = 0;
+		for (const [k, v] of value) {
+			children.push([entryKey("k", index), k], [entryKey("v", index), v]);
+			index++;
+		}
+	} else if (value instanceof Set) {
+		let index = 0;
+		for (const member of value) children.push([entryKey("s", index++), member]);
+	} else if (value instanceof Error) {
+		for (const key of ["cause", "errors"]) if (hasOwn(value, key)) children.push([entryKey(key === "cause" ? "c" : "e", 0), value[key]]);
+	} else return;
+	return children;
+}
+/**
+* The value at `path` below `root`, where a path may go through the entries
+* of Maps, Sets and Errors (see objectPaths) as well as properties.
+*/
+function getByEntryPath(root, path) {
+	let current = root;
+	let start = 0;
+	for (let i = 0; i < path.length; i++) {
+		if (!isEntryKey(path[i])) continue;
+		current = getByPath(current, path.slice(start, i));
+		if (!isObjectValue(current)) return void 0;
+		current = entryChildren(current)?.find(([at]) => at === path[i])?.[1];
+		start = i + 1;
+	}
+	return start === path.length ? current : getByPath(current, path.slice(start));
+}
+/**
+* Write `value` at the path of an object a Map holds as a value (see
+* objectPaths); other entries are not replaced, as a key or member cannot
+* change without the entry moving. Returns whether it wrote.
+*/
+function setEntryValue(root, path, value) {
+	const holder = getByEntryPath(root, path.slice(0, -1));
+	const match = /^\0v(\d+)$/.exec(path[path.length - 1]);
+	if (!(holder instanceof Map) || !match) return false;
+	const key = [...holder.keys()][Number(match[1])];
+	holder.set(key, value);
+	return true;
+}
 /**
 * Every path each object (or array, or other value) of `root` is at, the
 * first appearance first, in depth-first order. Plain objects and arrays are
@@ -13727,7 +13829,8 @@ var entryKey = (kind, index) => `\0${kind}${index}`;
 * With `entries`, the objects held in a Map or Set (as key, value or member)
 * are placed too, after everything else: one met nowhere else is at the path
 * of its Map or Set and the entry's segment (see entryKey), which is no path
-* a value can be read at, so only to tell where an object is from.
+* a value can be read at (see getByEntryPath), so only to tell where an
+* object is from; so are the `cause` and `errors` of an Error.
 */
 function objectPaths(root, skip = /* @__PURE__ */ new Set(), entries = false) {
 	const all = /* @__PURE__ */ new Map();
@@ -13740,7 +13843,7 @@ function objectPaths(root, skip = /* @__PURE__ */ new Set(), entries = false) {
 		}
 		all.set(value, [at]);
 		if (isMergeable(value) || Array.isArray(value)) walk(value, at);
-		else if (entries && (value instanceof Map || value instanceof Set)) collections.push([value, at]);
+		else if (entries && entryChildren(value)) collections.push([value, at]);
 	}
 	function walk(node, path) {
 		for (const key of Object.keys(node)) {
@@ -13752,15 +13855,7 @@ function objectPaths(root, skip = /* @__PURE__ */ new Set(), entries = false) {
 		}
 	}
 	walk(root, []);
-	for (const [collection, path] of collections) {
-		let index = 0;
-		for (const entry of collection.entries()) {
-			const [k, v] = entry;
-			const parts = collection instanceof Set ? [[k, entryKey("s", index)]] : [[k, entryKey("k", index)], [v, entryKey("v", index)]];
-			for (const [value, segment] of parts) if (isObjectValue(value) && !all.has(value)) place(value, [...path, segment]);
-			index++;
-		}
-	}
+	for (const [collection, path] of collections) for (const [segment, value] of entryChildren(collection)) if (isObjectValue(value)) place(value, [...path, segment]);
 	return all;
 }
 /** Where each object of `root` first appears (see objectPaths). */
@@ -13773,27 +13868,44 @@ function firstPaths(root, skip, entries) {
 * parents before children.
 */
 function sharedPaths(root) {
-	return [...objectPaths(root).values()].filter((paths) => paths.length > 1);
-}
-/**
-* Whether the Map or Set `y` holds, at the position of an entry of `x`, another
-* object than `x` did (as to where its first appearance is, see aliasChanges):
-* `$map.set("k", $a)` over an equal object. Entries are compared by position,
-* and only when both hold as many; other differences are changes of content.
-*/
-function entryAliasChanged(x, y, earlier, later) {
-	const isSet = x instanceof Set && y instanceof Set;
-	if (!isSet && !(x instanceof Map && y instanceof Map)) return false;
-	if (Object.getPrototypeOf(x) !== Object.getPrototypeOf(y)) return false;
-	if (x.size !== y.size) return false;
-	const moved = (a, b) => isObjectValue(a) && isObjectValue(b) && pathKey(earlier.get(a)) !== pathKey(later.get(b));
-	const ys = [...y.entries()];
-	let index = 0;
-	for (const [k, v] of x.entries()) {
-		const [k2, v2] = ys[index++];
-		if (moved(k, k2) || !isSet && moved(v, v2)) return true;
+	return [...objectPaths(root, void 0, true).values()].filter((paths) => paths.length > 1);
+}
+/**
+* Whether `y`, which takes the place of `x` at `at` (the first appearance of
+* both), holds an object elsewhere than `x` did, below an entry of a Map, Set
+* or Error (see aliasChanges): `$map.set("k", $a)` over an equal object, or
+* `$map.get("k").child = $a`. Entries are compared by position, and only
+* where both hold as many; other differences are changes of content. Below
+* an entry, objects that merge are compared key by key.
+*/
+function aliasMoved(x, y, at, earlier, later) {
+	const pairs = [];
+	const xs = entryChildren(x);
+	const ys = entryChildren(y);
+	if (xs && ys) {
+		if (Object.getPrototypeOf(x) !== Object.getPrototypeOf(y)) return false;
+		if (x instanceof Map || x instanceof Set) {
+			if (x.size !== y.size) return false;
+		}
+		const held = new Map(ys);
+		for (const [segment, a] of xs) if (held.has(segment)) pairs.push([
+			segment,
+			a,
+			held.get(segment)
+		]);
+	} else if ((isMergeable(x) || Array.isArray(x)) && mergesWith(x, y, true)) {
+		for (const key of Object.keys(y)) if (hasOwn(x, key)) pairs.push([
+			key,
+			x[key],
+			y[key]
+		]);
 	}
-	return false;
+	return pairs.some(([segment, a, b]) => {
+		if (!isObjectValue(a) || !isObjectValue(b)) return false;
+		const here = [...at, segment];
+		const isAt = later.get(b);
+		return pathKey(earlier.get(a)) !== pathKey(isAt) || pathKey(isAt) === pathKey(here) && aliasMoved(a, b, here, earlier, later);
+	});
 }
 /**
 * The paths whose object is another one in the references of `after` than in
@@ -13823,7 +13935,7 @@ function aliasChanges(before, after) {
 				value: y,
 				alias: true
 			});
-			else if (pathKey(isAt) === k && entryAliasChanged(x, y, earlier, later)) changes.push({
+			else if (pathKey(isAt) === k && entryChildren(x) && aliasMoved(x, y, at, earlier, later)) changes.push({
 				path: at,
 				deleted: false,
 				value: y,
@@ -13857,7 +13969,7 @@ function changesBetween(before, after, arrays = false) {
 * `changes` (which write something new there), for `existingObjects`.
 */
 function locateObjects(source, changes) {
-	return firstPaths(source, new Set(changes.map((c) => pathKey(c.path))));
+	return firstPaths(source, new Set(changes.map((c) => pathKey(c.path))), true);
 }
 /**
 * A map for `deepClone`'s `seen`: an object of the source `paths` locate
@@ -13872,7 +13984,7 @@ function existingObjects(paths, target) {
 			if (super.has(obj)) return true;
 			const path = paths.get(obj);
 			if (!path) return false;
-			const found = getByPath(target, path);
+			const found = getByEntryPath(target, path);
 			if (!(isObjectValue(found) && (Array.isArray(found) ? Array.isArray(obj) : Object.getPrototypeOf(found) === Object.getPrototypeOf(obj)))) return false;
 			super.set(obj, found);
 			return true;
@@ -13887,32 +13999,20 @@ function isApplied(target, change) {
 	if (!hasOwn(parent, key)) return change.deleted;
 	return !change.deleted && deepEqual(parent[key], change.value);
 }
+/**
+* Make `path` below `root` hold `object` (an object that `sharedPaths` found
+* at several paths): a property is written like setByPath() does, a Map's
+* value replaced; an entry that is a key or member is left as it is.
+*/
+function relinkPath(root, path, object) {
+	if (path.some(isEntryKey)) setEntryValue(root, path, object);
+	else setByPath(root, path, object);
+}
 function applyChange(target, change) {
 	const root = target;
 	if (change.deleted) deleteByPath(root, change.path);
 	else setByPath(root, change.path, change.value);
 }
-/**
-* Write how `after` differs from `before` (see keyChanges; arrays merge by
-* index) into `target`, another version of the same object or array.
-* Values that changed are written whole, as deep copies; for values that
-* merge, `mergeNested` may merge them into `target` instead, returning
-* whether it did. Into an array, elements removed from the end are removed
-* at the same indices and elements added are appended, and changes at
-* indices `target` lacks are dropped: where `target` was resized, its
-* indices do not line up with `before`'s.
-*/
-function mergeKeys(target, before, after, mergeNested) {
-	const list = Array.isArray(target) ? target : void 0;
-	for (const change of keyChanges(before, after, true)) {
-		const { key } = change;
-		if (change.kind === "deleted") if (list) list.length = Math.min(list.length, Number(key));
-		else delete target[key];
-		else if (list && change.kind === "added") list.push(deepClone(change.after));
-		else if (list && Number(key) >= list.length) continue;
-		else if (change.kind !== "nested" || !(mergeNested?.(key, change.before, change.after) || deepEqual(change.before, change.after))) target[key] = deepClone(change.after);
-	}
-}
 //#endregion
 //#region src/event-emitter.ts
 var VALID_EVENTS = new Set([
@@ -14672,18 +14772,18 @@ var cloneValue = (value) => deepClone(value, { keepUnregistered: true });
 */
 function clonerFor(target, paths) {
 	const seen = paths ? existingObjects(paths, target) : /* @__PURE__ */ new Map();
-	const mapKey = (copy, original) => {
+	const settle = (copy, original) => {
 		const path = paths?.get(original);
 		if (!path || !isDraft(copy)) return copy;
 		const plain = current(copy);
-		setByPath(target, path, plain);
+		if (!path.some(isEntryKey)) setByPath(target, path, plain);
 		seen.set(original, plain);
 		return plain;
 	};
 	return (value) => deepClone(value, {
 		keepUnregistered: true,
 		seen,
-		mapKey
+		settle
 	});
 }
 /** One cloner per target copy, made when first used. */
@@ -14870,9 +14970,9 @@ function relink(draft, work, changes) {
 		const prefixes = [first, ...others].map((p) => pathKey(p).slice(0, -1));
 		if (!written.some((w) => prefixes.some((p) => w.startsWith(p)))) continue;
 		try {
-			const object = getByPath(draft, first);
+			const object = getByEntryPath(draft, first);
 			if (object === null || typeof object !== "object") continue;
-			for (const path of others) setByPath(draft, path, object);
+			for (const path of others) relinkPath(draft, path, object);
 		} catch {}
 	}
 }
@@ -14969,12 +15069,26 @@ var running = () => activeScopes.map((scope) => ({
 /**
 * Bring a suspended mutation's copies up to the store after an action
 * replaced or changed state under it (navigation clears temporaries, back
-* and restart replace variables). Roots that still match keep the objects
-* the code may hold.
+* and restart replace variables). What the action changed (see
+* changesBetween) is written into the code's working copy, which keeps the
+* objects the code may hold where nothing changed, and the references among
+* the values written, and to the objects it holds already, as a commit does.
 */
 function resync(scope) {
 	const state = useStoryStore.getState();
-	for (const ns of NAMESPACES) mergeKeys(scope.work[ns], scope.work[ns], state[ns]);
+	const now = namespacesOf(state);
+	const changes = changesBetween(scope.base, now);
+	const copy = clonerFor(scope.work, locateObjects(now, changes));
+	for (const change of changes) try {
+		applyChange(scope.work, change.deleted ? change : {
+			...change,
+			value: copy(change.value)
+		});
+	} catch {
+		const [ns, root] = change.path;
+		if (hasOwn(now[ns], root)) scope.work[ns][root] = copy(now[ns][root]);
+		else delete scope.work[ns][root];
+	}
 	scope.base = cloneNamespaces(state);
 }
 /**
@@ -15038,7 +15152,11 @@ function executeMutation(code, mergedLocals, scopeUpdate) {
 		scope,
 		keepRunning: false
 	}]);
-	for (const key of Object.keys(localsClone)) if (!deepEqual(localsClone[key], mergedLocals[key])) scopeUpdate(key, localsClone[key]);
+	const changed = new Set(changesBetween(mergedLocals, localsClone, true).map((c) => c.path[0]));
+	for (const group of sharedPaths(localsClone)) if (group.some((path) => changed.has(path[0]))) {
+		for (const path of group) if (localsClone[path[0]] !== mergedLocals[path[0]]) changed.add(path[0]);
+	}
+	for (const key of Object.keys(localsClone)) if (changed.has(key)) scopeUpdate(key, localsClone[key]);
 	for (const key of Object.keys(mergedLocals)) if (!hasOwn(localsClone, key)) scopeUpdate(key, void 0);
 }
 //#endregion
@@ -15799,20 +15917,25 @@ function writeHookChange(work, after, change, own) {
 		const child = hasOwn(holder, key) ? holder[key] : void 0;
 		const held = getByPath(after, path.slice(0, depth + 1));
 		if (!mergesWith(child, held, true)) {
-			writeKey(holder, key, false, own(held));
+			writeKey(holder, key, own(held));
 			return;
 		}
 		holder = child;
 	}
 	const key = path[depth];
-	if (change.deleted) writeKey(holder, key, true, void 0);
-	else writeKey(holder, key, false, own(change.value), change.appended);
+	if (change.deleted) writeKey(holder, key, void 0, change);
+	else writeKey(holder, key, own(change.value), change);
 }
-function writeKey(holder, key, deleted, value, appended) {
+function writeKey(holder, key, value, change) {
+	const deleted = change?.deleted ?? false;
 	if (Array.isArray(holder)) {
 		const index = Number(key);
-		if (deleted) holder.length = Math.min(holder.length, index);
-		else if (appended) holder.push(value);
+		if (deleted) if (change && "hole" in change) delete holder[index];
+		else holder.length = Math.min(holder.length, index);
+		else if (change && "appended" in change) {
+			holder.length += change.gap ?? 0;
+			holder.push(value);
+		} else if (key === "length" && change) holder.length += value;
 		else if (index < holder.length) holder[index] = value;
 	} else if (deleted) delete holder[key];
 	else setOwn(holder, key, value);
@@ -19995,7 +20118,8 @@ defineMacro({
 		return useRunOnce("unset", rawArgs, () => {
 			const state = useStoryStore.getState();
 			const name = ctx.args.variable ?? "";
-			if (name.startsWith("$")) state.deleteVariable(name.slice(1));
+			if (/^[$_%@][^.]*\./.test(name)) ctx.mutate(`delete ${name}`);
+			else if (name.startsWith("$")) state.deleteVariable(name.slice(1));
 			else if (name.startsWith("_")) state.deleteTemporary(name.slice(1));
 			else if (name.startsWith("%")) state.deleteTransient(name.slice(1));
 			else if (name.startsWith("@")) ctx.update(name.slice(1), void 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rohal12/spindle",
-  "version": "0.59.5",
+  "version": "0.59.6",
   "type": "module",
   "description": "A Preact-based story format for Twine 2.",
   "license": "Unlicense",

package/src/components/macros/Unset.tsx

@@ -10,7 +10,11 @@ defineMacro({
       const state = useStoryStore.getState();
       const name = ctx.args.variable ?? '';
 
-      if (name.startsWith('$')) {
+      if (/^[$_%@][^.]*\./.test(name)) {
+        // A field of a variable: delete it as mutation code does, which
+        // resolves the path in every namespace
+        ctx.mutate(`delete ${name}`);
+      } else if (name.startsWith('$')) {
         state.deleteVariable(name.slice(1));
       } else if (name.startsWith('_')) {
         state.deleteTemporary(name.slice(1));

package/src/execute-mutation.ts

@@ -13,12 +13,13 @@ import {
   changesBetween,
   applyChange,
   deepClone,
-  deepEqual,
   existingObjects,
+  getByEntryPath,
+  isEntryKey,
   isApplied,
   isMergeable,
   locateObjects,
-  mergeKeys,
+  relinkPath,
   pathKey,
   sharedPaths,
   type PathChange,
@@ -94,18 +95,23 @@ function clonerFor(
   paths?: ReadonlyMap<object, string[]>,
 ): Cloner {
   const seen = paths ? existingObjects(paths, target) : new Map();
-  // Immer does not finalize a draft held as a Map key, so an existing object
-  // met there is put in the draft as the object itself: its base while the
-  // code did not change it, which other references to it then agree with.
-  const mapKey = (copy: object, original: object): object => {
+  // Immer does not finalize a draft held as a Map key or Set member, so an
+  // existing object met there is put in the draft as the object itself: its
+  // base while the code did not change it, which other references to it then
+  // agree with.
+  const settle = (copy: object, original: object): object => {
     const path = paths?.get(original);
     if (!path || !isDraft(copy)) return copy;
     const plain = currentDraft(copy) as object;
-    setByPath(target as Record<string, unknown>, path, plain);
+    // Where the object is in an entry of a Map or Set the path cannot be
+    // written (see getByEntryPath): that entry keeps its own
+    if (!path.some(isEntryKey)) {
+      setByPath(target as Record<string, unknown>, path, plain);
+    }
     seen.set(original, plain);
     return plain;
   };
-  return (value) => deepClone(value, { keepUnregistered: true, seen, mapKey });
+  return (value) => deepClone(value, { keepUnregistered: true, seen, settle });
 }
 
 /** One cloner per target copy, made when first used. */
@@ -358,10 +364,10 @@ function relink(
     const prefixes = [first!, ...others].map((p) => pathKey(p).slice(0, -1));
     if (!written.some((w) => prefixes.some((p) => w.startsWith(p)))) continue;
     try {
-      const object = getByPath(draft, first!);
+      const object = getByEntryPath(draft, first!);
       if (object === null || typeof object !== 'object') continue;
       for (const path of others)
-        setByPath(draft as unknown as Record<string, unknown>, path, object);
+        relinkPath(draft as unknown as Record<string, unknown>, path, object);
     } catch {
       // A path the store does not hold: the code's view is not the store's
     }
@@ -506,14 +512,31 @@ const running = (): Commit[] =>
 /**
  * Bring a suspended mutation's copies up to the store after an action
  * replaced or changed state under it (navigation clears temporaries, back
- * and restart replace variables). Roots that still match keep the objects
- * the code may hold.
+ * and restart replace variables). What the action changed (see
+ * changesBetween) is written into the code's working copy, which keeps the
+ * objects the code may hold where nothing changed, and the references among
+ * the values written, and to the objects it holds already, as a commit does.
  */
 function resync(scope: MutationScope): void {
   const state = useStoryStore.getState();
-  for (const ns of NAMESPACES) {
-    // Root by root: a root that differs is replaced with a copy of the store's
-    mergeKeys(scope.work[ns], scope.work[ns], state[ns]);
+  const now = namespacesOf(state);
+  const changes = changesBetween(
+    scope.base as unknown as Record<string, unknown>,
+    now as unknown as Record<string, unknown>,
+  );
+  const copy = clonerFor(scope.work, locateObjects(now, changes));
+  for (const change of changes) {
+    try {
+      applyChange(
+        scope.work,
+        change.deleted ? change : { ...change, value: copy(change.value) },
+      );
+    } catch {
+      // A path the working copy does not hold: replace its root instead
+      const [ns, root] = change.path as [NamespaceName, string];
+      if (hasOwn(now[ns], root)) scope.work[ns][root] = copy(now[ns][root]);
+      else delete scope.work[ns][root];
+    }
   }
   scope.base = cloneNamespaces(state);
 }
@@ -611,11 +634,26 @@ export function executeMutation(
   // came before its own
   commitScopes([...running(), { scope, keepRunning: false }]);
 
-  for (const key of Object.keys(localsClone)) {
-    if (!deepEqual(localsClone[key], mergedLocals[key])) {
-      scopeUpdate(key, localsClone[key]);
+  // Locals the code changed, as content or as the objects they refer to
+  // (`@a = @b` over an equal object), and the locals that share an object
+  // with one of those: the updater takes each one's value, so they must all
+  // be written for the scope to hold one object again
+  const changed = new Set(
+    changesBetween(mergedLocals, localsClone, true).map((c) => c.path[0]!),
+  );
+  for (const group of sharedPaths(localsClone)) {
+    if (group.some((path) => changed.has(path[0]!))) {
+      // Not a value kept by reference (an unregistered class instance)
+      for (const path of group) {
+        if (localsClone[path[0]!] !== mergedLocals[path[0]!]) {
+          changed.add(path[0]!);
+        }
+      }
     }
   }
+  for (const key of Object.keys(localsClone)) {
+    if (changed.has(key)) scopeUpdate(key, localsClone[key]);
+  }
 
   // Detect deleted locals
   for (const key of Object.keys(mergedLocals)) {