@rohal12/spindle 0.59.4 → 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,12 +13434,12 @@ function deepClone(value, options = {}) {
 		}
 		if (val instanceof Map) {
 			const copy = keep(obj, /* @__PURE__ */ new Map());
-			for (const [k, v] of val) copy.set(clone(k), 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);
@@ -13631,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 = [];
@@ -13652,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]);
@@ -13679,26 +13714,45 @@ function keyChanges(before, after, arrays) {
 /**
 * The property paths where `after` differs from `before`, two objects of
 * one class: objects that merge (see isMergeable) are compared property by
-* property, any other value as a whole.
+* property, any other value as a whole; with `arrays`, arrays are compared
+* by index too (see keyChanges).
 */
-function diffPaths(before, after) {
+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);
-		for (const change of keyChanges(b, a, false)) {
+		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
+				value: change.after,
+				...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;
@@ -13710,34 +13764,103 @@ function underChange(path, keys) {
 	return false;
 }
 /**
+* 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
 * entered, where first met only (an object held in an array is one object,
 * however it was reached); other values are leaves. A path at or below one
 * of `skip` is left out.
+*
+* 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 (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()) {
+function objectPaths(root, skip = /* @__PURE__ */ new Set(), entries = false) {
 	const all = /* @__PURE__ */ new Map();
-	(function walk(node, path) {
+	const collections = [];
+	function place(value, at) {
+		const known = all.get(value);
+		if (known) {
+			known.push(at);
+			return;
+		}
+		all.set(value, [at]);
+		if (isMergeable(value) || Array.isArray(value)) walk(value, at);
+		else if (entries && entryChildren(value)) collections.push([value, at]);
+	}
+	function walk(node, path) {
 		for (const key of Object.keys(node)) {
 			const value = node[key];
 			if (!isObjectValue(value)) continue;
 			const at = [...path, key];
 			if (skip.has(pathKey(at))) continue;
-			const known = all.get(value);
-			if (known) {
-				known.push(at);
-				continue;
-			}
-			all.set(value, [at]);
-			if (isMergeable(value) || Array.isArray(value)) walk(value, at);
+			place(value, at);
 		}
-	})(root, []);
+	}
+	walk(root, []);
+	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). */
-function firstPaths(root, skip) {
-	return new Map([...objectPaths(root, skip)].map(([object, paths]) => [object, paths[0]]));
+function firstPaths(root, skip, entries) {
+	return new Map([...objectPaths(root, skip, entries)].map(([object, paths]) => [object, paths[0]]));
 }
 /**
 * The objects `root` holds at more than one path (an object two variables
@@ -13745,7 +13868,44 @@ function firstPaths(root, skip) {
 * parents before children.
 */
 function sharedPaths(root) {
-	return [...objectPaths(root).values()].filter((paths) => paths.length > 1);
+	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 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
@@ -13756,8 +13916,8 @@ function sharedPaths(root) {
 * `after` holds.
 */
 function aliasChanges(before, after) {
-	const earlier = firstPaths(before);
-	const later = firstPaths(after);
+	const earlier = firstPaths(before, void 0, true);
+	const later = firstPaths(after, void 0, true);
 	const changes = [];
 	(function walk(b, a, path) {
 		for (const key of Object.keys(a)) {
@@ -13775,17 +13935,41 @@ function aliasChanges(before, after) {
 				value: y,
 				alias: true
 			});
+			else if (pathKey(isAt) === k && entryChildren(x) && aliasMoved(x, y, at, earlier, later)) changes.push({
+				path: at,
+				deleted: false,
+				value: y,
+				alias: true
+			});
 			if ((isMergeable(x) || Array.isArray(x)) && mergesWith(x, y, true) && pathKey(isAt) === k && pathKey(wasAt) === k) walk(x, y, at);
 		}
 	})(before, after, []);
 	return changes;
 }
 /**
+* The changes from `before` to `after`, as paths below them: the property
+* paths that differ (see diffPaths), and those that hold equal content but
+* another object than they did (see aliasChanges), those first. Compared as
+* one object, so an object that two of their keys share is one object,
+* whichever of them it is reached through.
+*/
+function changesBetween(before, after, arrays = false) {
+	const written = diffPaths(before, after, arrays);
+	const keys = new Set(written.map((c) => pathKey(c.path)));
+	const aliases = [];
+	for (const change of aliasChanges(before, after)) {
+		if (underChange(change.path, keys)) continue;
+		keys.add(pathKey(change.path));
+		aliases.push(change);
+	}
+	return [...aliases, ...written];
+}
+/**
 * Where the objects of `source` are, other than at or below the paths of
 * `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
@@ -13800,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;
@@ -13815,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([
@@ -14600,9 +14772,18 @@ var cloneValue = (value) => deepClone(value, { keepUnregistered: true });
 */
 function clonerFor(target, paths) {
 	const seen = paths ? existingObjects(paths, target) : /* @__PURE__ */ new Map();
+	const settle = (copy, original) => {
+		const path = paths?.get(original);
+		if (!path || !isDraft(copy)) return copy;
+		const plain = current(copy);
+		if (!path.some(isEntryKey)) setByPath(target, path, plain);
+		seen.set(original, plain);
+		return plain;
+	};
 	return (value) => deepClone(value, {
 		keepUnregistered: true,
-		seen
+		seen,
+		settle
 	});
 }
 /** One cloner per target copy, made when first used. */
@@ -14751,7 +14932,8 @@ function routeStoreUpdate(recipe) {
 			path: [ns, ...change.path]
 		})) : [];
 	});
-	const cloners = clonersFor();
+	const held = locateObjects(namespacesOf(inner.work), changes);
+	const cloners = clonersFor(() => held);
 	const owned = (change, target) => change.deleted ? change : {
 		...change,
 		value: cloners(target)(change.value)
@@ -14788,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 {}
 	}
 }
@@ -14806,6 +14988,12 @@ function cloneNamespaces(from) {
 		transient: deepClone(from.transient, { seen })
 	};
 }
+/** The three variable namespaces of `state`, as an object to walk. */
+var namespacesOf = (state) => ({
+	variables: state.variables,
+	temporary: state.temporary,
+	transient: state.transient
+});
 /**
 * Commit the property paths each mutation's code changed (work vs base) on
 * top of the current store state, so writes made elsewhere during execution
@@ -14870,24 +15058,9 @@ function commitScopes(commits) {
 }
 /**
 * The changes of the code to the namespaces, as paths below them (`['variables',
-* 'a']`): the property paths that differ (see diffPaths), and those that hold
-* equal content but another object than they did (see aliasChanges), those
-* first. Compared as one object, so an object the namespaces share is one
-* object, whichever of them it is reached through.
-*/
-function changesOf(base, work) {
-	const before = base;
-	const after = work;
-	const written = diffPaths(before, after);
-	const keys = new Set(written.map((c) => pathKey(c.path)));
-	const aliases = [];
-	for (const change of aliasChanges(before, after)) {
-		if (underChange(change.path, keys)) continue;
-		keys.add(pathKey(change.path));
-		aliases.push(change);
-	}
-	return [...aliases, ...written];
-}
+* 'a']`; see changesBetween).
+*/
+var changesOf = (base, work) => changesBetween(base, work);
 /** Every running mutation, to commit with its code going on. */
 var running = () => activeScopes.map((scope) => ({
 	scope,
@@ -14896,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);
 }
 /**
@@ -14930,9 +15117,11 @@ function runWithCommittedMutations(action) {
 */
 function mutateState(run) {
 	commitScopes(running());
+	const held = locateObjects(namespacesOf(getActiveMutationScope() ?? useStoryStore.getState()), []);
 	const scope = startScope();
+	const adopt = clonerFor(scope.work, held);
 	try {
-		run(scope.work);
+		run(scope.work, adopt);
 	} finally {
 		activeScopes.pop();
 	}
@@ -14963,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
@@ -15687,35 +15880,65 @@ function loadedEntryMoment(payload) {
 * the `beforesave` hooks) into the payload's snapshot of the saved moment. A
 * load restores that snapshot, the state on entering the passage, and runs
 * the passage again, so data a hook adds to a save would otherwise be lost
-* on load (#227). Only the property paths the hooks changed are written (into
-* copies of the objects on those paths, the rest staying shared): a
-* whole variable would bring along what the passage did to the rest of it,
-* which the passage then does again on load (#232). Only the payload's copy
-* changes: the live history keeps the recorded snapshot (#159).
+* on load (#227). Only the property paths the hooks changed are written (see
+* changesBetween): a whole variable would bring along what the passage did
+* to the rest of it, which the passage then does again on load (#232). The
+* references the hooks made stay: an object they put in two variables is one
+* object in the snapshot, and one they made another variable refer to is the
+* snapshot's own object of it (#302). Only the payload's copy changes: the
+* live history keeps the recorded snapshot (#159).
 */
 function keepHookWrites(payload, before, after) {
 	const moment = payload.history[payload.historyIndex];
 	if (!moment) return;
-	mergeHookWrites(moment.variables, before, after, /* @__PURE__ */ new Set());
-}
-/**
-* Apply the hooks' changes between `before` and `after`, two objects or two
-* arrays, to the snapshot's copy of them, `target` (see mergeKeys: array
-* elements merge by index). A changed value is merged key by key where the
-* snapshot holds the same kind of value. Where it lacks the key or holds
-* another kind (the passage created or replaced it), the hooks' whole value
-* is written.
-*/
-function mergeHookWrites(target, before, after, ancestors) {
-	ancestors.add(after);
-	mergeKeys(target, before, after, (key, b, a) => {
-		if (!hasOwn(target, key) || !mergesWith(a, target[key], true) || ancestors.has(a)) return false;
-		const copy = shallowCopy(target[key]);
-		target[key] = copy;
-		mergeHookWrites(copy, b, a, ancestors);
-		return true;
-	});
-	ancestors.delete(after);
+	const changes = changesBetween(before, after, true);
+	if (changes.length === 0) return;
+	const work = deepClone(moment.variables);
+	const seen = existingObjects(locateObjects(after, changes), work);
+	const own = (value) => deepClone(value, { seen });
+	for (const change of changes) writeHookChange(work, after, change, own);
+	moment.variables = shareEqual(moment.variables, work);
+}
+/**
+* Write `change` (of the hooks, to `after`) into `work`. The value goes in at
+* the first place `work` lacks the objects on the path of one of the kind
+* `after` holds (the passage created or replaced it): there, the hooks' whole
+* value of it is written. Into an array, elements removed from the end are
+* removed at the same indices and elements added are appended; changes at
+* indices the array lacks are dropped (it was resized, so its indices do not
+* line up with the live ones).
+*/
+function writeHookChange(work, after, change, own) {
+	const { path } = change;
+	let holder = work;
+	let depth = 0;
+	for (; depth < path.length - 1; depth++) {
+		const key = path[depth];
+		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, own(held));
+			return;
+		}
+		holder = child;
+	}
+	const key = path[depth];
+	if (change.deleted) writeKey(holder, key, void 0, change);
+	else writeKey(holder, key, own(change.value), change);
+}
+function writeKey(holder, key, value, change) {
+	const deleted = change?.deleted ?? false;
+	if (Array.isArray(holder)) {
+		const index = Number(key);
+		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);
 }
 /** Restore the PRNG from a snapshot, or reset it without one. */
 function restorePRNGFrom(prng) {
@@ -17289,8 +17512,8 @@ function defineMacro(config, source = "builtin") {
 			ctx.value = useStoryStore((s) => getByPath(s.variables, segments));
 			ctx.getValue = () => getByPath(readState().variables, segments);
 			ctx.setValue = (value) => {
-				useStoryStore.setState((state) => {
-					setByPath(state.variables, segments, value, { createMissing: true });
+				mutateState((work, adopt) => {
+					setByPath(work.variables, segments, adopt(value), { createMissing: true });
 				});
 			};
 		}
@@ -17432,8 +17655,8 @@ function createStoryAPI() {
 				warnIfUndeclared(isTransient, key);
 			}
 			if (entries.some(([k]) => k.includes("."))) {
-				mutateState((work) => {
-					for (const [k, v] of entries) setOne(work, k, v);
+				mutateState((work, adopt) => {
+					for (const [k, v] of entries) setOne(work, k, adopt(v));
 				});
 				return;
 			}
@@ -19895,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);