@rohal12/spindle 0.59.5 → 0.59.7

package/dist/pkg/headless.js

@@ -12575,10 +12575,18 @@ var defineData = (target, key, value) => {
 	});
 };
 /**
+* A reducer extracts string keys, so devalue never sees the symbol keys of
+* the original object: refuse them here, as it does for a plain object.
+*/
+function refuseSymbolKeys(value) {
+	if (Object.getOwnPropertySymbols(value).length > 0) throw new TypeError("spindle: Cannot save an object with symbol keys");
+}
+/**
 * Own enumerable keys of `value`, as a plain object; for an error also its
 * message, cause and (AggregateError) errors, which are not enumerable.
 */
 function ownData(value) {
+	refuseSymbolKeys(value);
 	const data = {};
 	if (value instanceof Error) {
 		for (const key of ERROR_HIDDEN_KEYS$1) if (hasOwn(value, key)) defineData(data, key, value[key]);
@@ -12605,6 +12613,7 @@ function reducers() {
 		if (!isObject(v) || Object.getPrototypeOf(v) !== Object.prototype) return false;
 		const keys = Object.keys(v);
 		if (!keys.some(isEscapedOneCharKey)) return false;
+		refuseSymbolKeys(v);
 		if (keys.includes("__proto__")) throw new TypeError("spindle: Cannot save a property named \"__proto__\"");
 		return keys.flatMap((k) => [k, v[k]]);
 	};
@@ -13244,13 +13253,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 +13417,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 +13443,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);
@@ -13492,6 +13505,13 @@ function strictPairs(ab = /* @__PURE__ */ new Map(), ba = /* @__PURE__ */ new Ma
 	return pairs;
 }
 /**
+* Whether `a` and `b` are equal as deepEqual() has it and also share
+* references at the same places (a save of one loads as the other).
+*/
+function deepEqualStrict(a, b) {
+	return equal(a, b, strictPairs());
+}
+/**
 * `curr` with each part that equals (see deepEqualStrict) the part of
 * `prev` at the same place replaced by `prev`'s: the history moments of a
 * save then share what did not change between them, which a save stores
@@ -13635,7 +13655,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 +13678,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 +13736,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 +13779,64 @@ 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'), or for the buffer a
+* typed array or DataView views ('b').
+*/
 var entryKey = (kind, index) => `\0${kind}${index}`;
+var isEntryKey = (segment) => segment.startsWith("\0");
+/**
+* What a Map, Set, Error or view holds in place of properties (keys and
+* values, members, `cause` and `errors`, the buffer), 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 if (ArrayBuffer.isView(value)) children.push([entryKey("b", 0), value.buffer]);
+	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 +13847,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 +13861,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 +13873,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 +13886,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 +13953,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 +13987,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 +14002,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 +14017,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([
@@ -14145,7 +14263,9 @@ function storedRecord(meta, payload) {
 	};
 }
 var createSave = queued(createSaveNow);
-async function createSaveNow(ifid, playthroughId, payload, custom = {}) {
+async function createSaveNow(ifid, playthroughPromise, payload, custom = {}) {
+	const playthroughId = await playthroughPromise;
+	if (!playthroughId) throw new Error("No playthrough");
 	const now = (/* @__PURE__ */ new Date()).toISOString();
 	const record = storedRecord({
 		id: randomUUID(),
@@ -14161,6 +14281,10 @@ async function createSaveNow(ifid, playthroughId, payload, custom = {}) {
 	return record;
 }
 /**
+* A playthrough passed as a promise (see resolvePlaythroughId) is awaited
+* inside the operation, so the call takes its place in the order of
+* operations when it is made.
+*
 * Replace the payload of an existing save, keeping its ID and `createdAt`.
 * Pass the current `playthroughId` when the new payload comes from the
 * running game: the save then holds that playthrough's state, so it is
@@ -14176,7 +14300,8 @@ async function createSaveNow(ifid, playthroughId, payload, custom = {}) {
 * before, so slot keys and metadata not passed again are kept.
 */
 var overwriteSave = queued(overwriteSaveNow);
-async function overwriteSaveNow(saveId, payload, custom, playthroughId) {
+async function overwriteSaveNow(saveId, payload, custom, playthroughPromise) {
+	const playthroughId = await playthroughPromise;
 	const backend = await getBackend();
 	const existing = await backend.getSave(saveId);
 	if (!existing) return void 0;
@@ -14672,18 +14797,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 +14995,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 {}
 	}
 }
@@ -14883,9 +15008,18 @@ function relink(draft, work, changes) {
 function cloneNamespaces(from) {
 	const seen = /* @__PURE__ */ new Map();
 	return {
-		variables: deepClone(from.variables, { seen }),
-		temporary: deepClone(from.temporary, { seen }),
-		transient: deepClone(from.transient, { seen })
+		variables: deepClone(from.variables, {
+			keepUnregistered: true,
+			seen
+		}),
+		temporary: deepClone(from.temporary, {
+			keepUnregistered: true,
+			seen
+		}),
+		transient: deepClone(from.transient, {
+			keepUnregistered: true,
+			seen
+		})
 	};
 }
 /** The three variable namespaces of `state`, as an object to walk. */
@@ -14969,12 +15103,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 +15186,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 +15951,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);
@@ -16611,10 +16768,10 @@ function App() {
 		/* @__PURE__ */ jsx(TriggerDialogHost, {}),
 		/* @__PURE__ */ jsx(RuntimeErrors, {})
 	] });
-	return nobr ? /* @__PURE__ */ jsx(NobrContext.Provider, {
-		value: true,
+	return /* @__PURE__ */ jsx(NobrContext.Provider, {
+		value: nobr,
 		children: content
-	}) : content;
+	});
 }
 //#endregion
 //#region src/parser.ts
@@ -18656,7 +18813,7 @@ function computeAndApply(expr, name, isTemp, isLocal, getLocals, rawArgs, prevRe
 		logMacroError(`computed ${rawArgs}`, err, location);
 		return;
 	}
-	if (!deepEqual(prevRef.current, newValue)) {
+	if (!deepEqualStrict(prevRef.current, newValue)) {
 		prevRef.current = newValue;
 		if (isLocal) try {
 			localsUpdate(name, newValue);
@@ -19592,9 +19749,7 @@ function SaveManagerContent() {
 		const playthrough = resolvePlaythroughId();
 		try {
 			await saveWithHooks(void 0, void 0, beginSave, async (payload) => {
-				const ptId = await playthrough;
-				if (!ptId) throw new Error("No playthrough");
-				return createSave(ifid, ptId, payload);
+				return createSave(ifid, playthrough, payload);
 			});
 			showStatus("Save created");
 			await refresh();
@@ -19606,7 +19761,7 @@ function SaveManagerContent() {
 		const playthrough = resolvePlaythroughId();
 		try {
 			await saveWithHooks(void 0, void 0, beginSave, async (payload) => {
-				if (!await overwriteSave(saveId, payload, void 0, await playthrough || void 0)) throw new Error("Save not found");
+				if (!await overwriteSave(saveId, payload, void 0, playthrough)) throw new Error("Save not found");
 			});
 			showStatus("Save overwritten");
 			await refresh();
@@ -19995,7 +20150,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);
@@ -20442,13 +20598,13 @@ defineMacro({
 		useEffect(() => {
 			const store = useStoryStore.getState();
 			const { history, historyIndex, transitionConfig } = store;
-			const next = store.consumeNextTransition();
 			const prevLen = prevHistoryLenRef.current;
 			prevHistoryLenRef.current = history.length;
 			const isFirstLoad = !displayedPassage;
 			const isRestart = history.length === 1 && historyIndex === 0 && prevLen > 1;
 			const isLoad = history.length > 1 && historyIndex === history.length - 1 && prevLen > 1 && Math.abs(history.length - prevLen) > 1;
 			if (navigationId === displayed.id) return;
+			const next = store.consumeNextTransition();
 			cancelTransition();
 			const targetPassage = storyData?.passages.get(currentPassage);
 			if (!targetPassage) {
@@ -20629,6 +20785,15 @@ function stopWithErrors(errors) {
 	throw new Error(`spindle: ${errors.length} validation error(s):\n${errors.join("\n")}`);
 }
 /**
+* The undeclared variables the passages refer to, with the macros known now:
+* the input macros that bind a variable (registered by author JS or
+* StoryInit) and the roles of their parameters decide what is a reference.
+*/
+function variableErrors(storyData, schema) {
+	const storeVarMacros = getMacroRegistry().filter((m) => m.storeVar).map((m) => m.name);
+	return validatePassages(storyData.passages, schema, storeVarMacros);
+}
+/**
 * The markup errors (malformed markup, unknown macros, syntax errors in
 * code) of the passages for which `only` holds, with the macros and widgets
 * known now.
@@ -20677,9 +20842,8 @@ function boot() {
 		throw new Error(`spindle: ${msg}`);
 	}
 	const schema = parseStoryVariables(storyVarsPassage.content);
-	const storeVarMacros = getMacroRegistry().filter((m) => m.storeVar).map((m) => m.name);
 	for (const name of blockWidgetNames(storyData.passages.values())) registerBlockMacro(name);
-	const errors = validatePassages(storyData.passages, schema, storeVarMacros);
+	const errors = variableErrors(storyData, schema);
 	errors.push(...markupErrors(storyData, (p) => p.name === "StoryInit"));
 	let transientDefaults = {};
 	const storyTransientsPassage = storyData.passages.get("StoryTransients");
@@ -20694,7 +20858,7 @@ function boot() {
 	useStoryStore.getState().init(storyData, defaults, transientDefaults);
 	enterRuntimePhase();
 	initializeStory(loadSession(storyData.ifid));
-	const markup = markupErrors(storyData, (p) => p.name !== "StoryInit");
+	const markup = [...variableErrors(storyData, schema), ...markupErrors(storyData, (p) => p.name !== "StoryInit")];
 	if (markup.length > 0) stopWithErrors(markup);
 	for (const [, passage] of storyData.passages) if (passage.tags.includes("widget")) {
 		const widgetAST = parseMarkup(passage.content);