@rohal12/spindle 0.59.0 → 0.59.2

package/dist/pkg/headless.js

@@ -32,6 +32,26 @@ function create() {
 	return (initializer) => bindPreact(createStore()(initializer));
 }
 //#endregion
+//#region src/utils/uuid.ts
+/**
+* A random UUID (v4). `crypto.randomUUID` exists only in secure contexts, so
+* on a plain HTTP origin the ID is built from `crypto.getRandomValues`.
+*/
+function randomUUID() {
+	if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	const bytes = crypto.getRandomValues(new Uint8Array(16));
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+	return [
+		hex.slice(0, 4).join(""),
+		hex.slice(4, 6).join(""),
+		hex.slice(6, 8).join(""),
+		hex.slice(8, 10).join(""),
+		hex.slice(10).join("")
+	].join("-");
+}
+//#endregion
 //#region src/markup/tokens.ts
 /** Variable sigils: story ($), temporary (_), local (@), transient (%). */
 var SIGIL_SCOPES$1 = {
@@ -13061,7 +13081,14 @@ function createIDBBackend() {
 					for (const [index, path] of Object.entries(indexes)) store.createIndex(index, path, { unique: false });
 				}
 			};
-			req.onsuccess = () => resolve(req.result);
+			req.onsuccess = () => {
+				const db = req.result;
+				db.onversionchange = () => {
+					db.close();
+					dbPromise = null;
+				};
+				resolve(db);
+			};
 			req.onerror = () => reject(req.error);
 		});
 		return dbPromise;
@@ -13080,7 +13107,15 @@ function createIDBBackend() {
 		const rows = name === "meta";
 		/** Run one request in a transaction of its own. */
 		const request = async (mode, make) => {
-			return idbReq(make((await openDB()).transaction(name, mode).objectStore(name)));
+			const tx = (await openDB()).transaction(name, mode);
+			const result = idbReq(make(tx.objectStore(name)));
+			if (mode === "readonly") return result;
+			const committed = new Promise((resolve, reject) => {
+				tx.oncomplete = () => resolve();
+				tx.onabort = () => reject(tx.error ?? new DOMException("Transaction aborted", "AbortError"));
+			});
+			const [value] = await Promise.all([result, committed]);
+			return value;
 		};
 		return {
 			async get(key) {
@@ -13109,6 +13144,7 @@ function createIDBBackend() {
 			const req = indexedDB.deleteDatabase(IDB_DB_NAME);
 			req.onsuccess = () => resolve();
 			req.onerror = () => reject(req.error);
+			req.onblocked = () => reject(/* @__PURE__ */ new Error("Cannot clear the saved data: another tab or window of this site still has it open. Close the other tabs and try again."));
 		});
 	});
 }
@@ -13319,15 +13355,22 @@ var ERROR_HIDDEN_KEYS = [
 	"errors"
 ];
 function deepClone(value, options = {}) {
-	const seen = /* @__PURE__ */ new Map();
+	const seen = options.seen ?? /* @__PURE__ */ new Map();
 	/** Record `copy` as the copy of `obj` before its contents are copied. */
 	const keep = (obj, copy) => {
 		seen.set(obj, copy);
 		return copy;
 	};
-	/** Copy the own (enumerable) keys of `obj` into `copy`. */
+	/**
+	* Copy the own (enumerable) keys of `obj` into `copy`, symbol keys too: a
+	* save refuses them, which a copy must not hide.
+	*/
 	function copyKeys(obj, copy) {
 		for (const key of Object.keys(obj)) setOwn(copy, key, clone(obj[key]));
+		for (const sym of Object.getOwnPropertySymbols(obj)) {
+			if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) continue;
+			copy[sym] = clone(obj[sym]);
+		}
 		return copy;
 	}
 	function cloneBuiltin(val) {
@@ -13410,65 +13453,83 @@ function loosePairs() {
 /**
 * Pairs that also require the same reference structure: each object of one
 * value pairs with exactly one of the other, so shared references and
-* cycles are shared at the same places.
+* cycles are shared at the same places. `ab` and `ba` hold the pairs (and
+* may hold some already); those made are listed in `added`.
 */
-function strictPairs() {
-	const ab = /* @__PURE__ */ new Map();
-	const ba = /* @__PURE__ */ new Map();
-	const pairs = (a, b) => {
+function strictPairs(ab = /* @__PURE__ */ new Map(), ba = /* @__PURE__ */ new Map()) {
+	const added = [];
+	const pairs = ((a, b) => {
 		const known = ab.get(a);
 		if (known !== void 0) return known === b;
 		if (ba.has(b)) return false;
 		ab.set(a, b);
 		ba.set(b, a);
-	};
+		added.push([a, b]);
+	});
 	pairs.strict = true;
+	pairs.added = added;
 	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
 * once. Containers on the way to a change are copied; neither value is
-* changed. Shared references and cycles within `curr` stay so.
+* changed. The result has the reference structure of `curr`: what `curr`
+* shares or cycles through stays so, and what it does not share stays
+* apart, whichever parts are reused.
 */
 function shareEqual(prev, curr) {
+	if (!isObjectValue(prev) || !isObjectValue(curr)) return curr;
+	/** The object of the result standing for each object of `curr` met. */
 	const done = /* @__PURE__ */ new Map();
-	function share(p, c) {
-		if (p === c || !isObjectValue(c) || !isObjectValue(p)) return c;
-		if (done.has(c)) return done.get(c);
-		if (deepEqualStrict(p, c)) {
-			done.set(c, p);
-			return p;
+	/** The object of `curr` each object of `prev` in the result stands for. */
+	const used = /* @__PURE__ */ new Map();
+	/** `value` for the result: copied, as far as it is not met already. */
+	const fresh = (value) => isObjectValue(value) ? deepClone(value, {
+		keepUnregistered: true,
+		seen: done
+	}) : value;
+	/**
+	* Whether `p` and `c` are equal and so can stand for each other, which
+	* needs each object in them to stand for one object only, in the whole
+	* result. Then every pair of objects they hold is placed in the result.
+	*/
+	function reuse(p, c) {
+		const pairs = strictPairs(used, done);
+		if (equal(p, c, pairs)) return true;
+		for (const [a, b] of pairs.added) {
+			used.delete(a);
+			done.delete(b);
 		}
+		return false;
+	}
+	function share(p, c) {
+		if (!isObjectValue(c)) return c;
+		const placed = done.get(c);
+		if (placed !== void 0) return placed;
+		if (!isObjectValue(p)) return fresh(c);
+		if (reuse(p, c)) return p;
 		if (c instanceof Map && p instanceof Map) {
 			const out = /* @__PURE__ */ new Map();
 			done.set(c, out);
-			for (const [k, v] of c) out.set(k, p.has(k) ? share(p.get(k), v) : v);
+			for (const [k, v] of c) out.set(fresh(k), share(p.get(k), v));
 			return out;
 		}
 		if (Array.isArray(c) && Array.isArray(p)) {
 			const out = new Array(c.length);
 			done.set(c, out);
-			for (let i = 0; i < c.length; i++) if (i in c) out[i] = i < p.length ? share(p[i], c[i]) : c[i];
+			for (let i = 0; i < c.length; i++) if (i in c) out[i] = share(p[i], c[i]);
 			return out;
 		}
 		if (mergesWith(p, c, false)) {
 			const out = Object.create(Object.getPrototypeOf(c));
 			done.set(c, out);
 			const cr = c;
-			for (const key of Object.keys(cr)) setOwn(out, key, hasOwn(p, key) ? share(p[key], cr[key]) : cr[key]);
+			for (const key of Object.keys(cr)) setOwn(out, key, share(hasOwn(p, key) ? p[key] : void 0, cr[key]));
 			return out;
 		}
-		done.set(c, c);
-		return c;
+		return fresh(c);
 	}
 	return share(prev, curr);
 }
@@ -13484,7 +13545,11 @@ function equalBytes(a, b) {
 function equalBuiltin(a, b, assumed) {
 	if (a instanceof Date) return Object.is(a.getTime(), b.getTime());
 	if (a instanceof RegExp) return String(a) === String(b);
-	if (ArrayBuffer.isView(a) || a instanceof ArrayBuffer) return equalBytes(a, b);
+	if (ArrayBuffer.isView(a)) {
+		const v = b;
+		return a.byteOffset === v.byteOffset && a.byteLength === v.byteLength && equal(a.buffer, v.buffer, assumed);
+	}
+	if (a instanceof ArrayBuffer) return equalBytes(a, b);
 	if (a instanceof URL || a instanceof URLSearchParams) return String(a) === String(b);
 	if (isBoxed(a)) return Object.is(a.valueOf(), b.valueOf());
 	if (isTemporal(a)) return String(a) === String(b);
@@ -13621,6 +13686,91 @@ function diffPaths(before, after) {
 	})(before, after, []);
 	return changes;
 }
+var pathKey = (path) => JSON.stringify(path);
+/** Whether `path`, or one of its ancestors, is one of `keys`. */
+function underChange(path, keys) {
+	for (let n = 1; n <= path.length; n++) if (keys.has(pathKey(path.slice(0, n)))) return true;
+	return false;
+}
+/**
+* Where each object (or array, or other value) of `root` first appears, in
+* depth-first order. Plain objects are entered; arrays and other values are
+* leaves. A path at or below one of `skip` is left out.
+*/
+function firstPaths(root, skip = /* @__PURE__ */ new Set()) {
+	const found = /* @__PURE__ */ new Map();
+	(function walk(node, path) {
+		for (const key of Object.keys(node)) {
+			const value = node[key];
+			if (!isObjectValue(value) || found.has(value)) continue;
+			const at = [...path, key];
+			if (skip.has(pathKey(at))) continue;
+			found.set(value, at);
+			if (isMergeable(value)) walk(value, at);
+		}
+	})(root, []);
+	return found;
+}
+/**
+* The paths whose object is another one in the references of `after` than in
+* `before`, as to where its first appearance is: `$a = $b` makes `a` another
+* name for the object of `b` even where both hold equal content, and a
+* `diffPaths` over the content finds nothing. Only paths both hold an object
+* at are reported, parents before children; each is a write of the object
+* `after` holds.
+*/
+function aliasChanges(before, after) {
+	const earlier = firstPaths(before);
+	const later = firstPaths(after);
+	const changes = [];
+	(function walk(b, a, path) {
+		for (const key of Object.keys(a)) {
+			if (!hasOwn(b, key)) continue;
+			const x = b[key];
+			const y = a[key];
+			if (!isObjectValue(x) || !isObjectValue(y)) continue;
+			const at = [...path, key];
+			const wasAt = earlier.get(x);
+			const isAt = later.get(y);
+			const k = pathKey(at);
+			if (pathKey(wasAt) !== pathKey(isAt)) changes.push({
+				path: at,
+				deleted: false,
+				value: y,
+				alias: true
+			});
+			if (isMergeable(x) && mergesWith(x, y, false) && pathKey(isAt) === k && pathKey(wasAt) === k) walk(x, y, at);
+		}
+	})(before, after, []);
+	return changes;
+}
+/**
+* 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))));
+}
+/**
+* A map for `deepClone`'s `seen`: an object of the source `paths` locate
+* (see locateObjects) is copied as the object at the same path in `target`,
+* so a value that refers to an object the store holds refers to it again
+* after the copy, not to a copy of it. Objects are looked up in `target`
+* when met, not up front.
+*/
+function existingObjects(paths, target) {
+	return new class extends Map {
+		has(obj) {
+			if (super.has(obj)) return true;
+			const path = paths.get(obj);
+			if (!path) return false;
+			const found = getByPath(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;
+		}
+	}();
+}
 /** Whether `target` already holds what `change` would write. */
 function isApplied(target, change) {
 	const parent = getByPath(target, change.path.slice(0, -1));
@@ -13765,7 +13915,7 @@ var readingSlot = (read) => queued(async (ifid, slot) => read(await slotRecord(i
 * saves issued before this resolves are tagged with it).
 */
 var startNewPlaythrough = queued(startNewPlaythroughNow);
-async function startNewPlaythroughNow(ifid, id = crypto.randomUUID()) {
+async function startNewPlaythroughNow(ifid, id = randomUUID()) {
 	const backend = await getBackend();
 	const num = await nextPlaythroughNumber(ifid);
 	const record = {
@@ -13889,7 +14039,7 @@ var createSave = queued(createSaveNow);
 async function createSaveNow(ifid, playthroughId, payload, custom = {}) {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
 	const record = storedRecord({
-		id: crypto.randomUUID(),
+		id: randomUUID(),
 		ifid,
 		playthroughId,
 		createdAt: now,
@@ -14215,7 +14365,7 @@ async function prepareImport(data, ifid) {
 	checkSaveExport(data);
 	if (data.ifid !== ifid) throw new Error(`Save is from a different story (expected IFID ${ifid}, got ${data.ifid})`);
 	const record = deepClone(data.save);
-	record.meta.id = crypto.randomUUID();
+	record.meta.id = randomUUID();
 	record.meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
 	record.meta.ifid = ifid;
 	await ensurePlaythrough(ifid, record.meta.playthroughId, record.meta.createdAt);
@@ -14405,6 +14555,32 @@ function readState() {
 }
 var cloneValue = (value) => deepClone(value, { keepUnregistered: true });
 /**
+* A cloner of values written into `target`. The references among the values
+* it copies are kept (`$b = $a` writes one array twice: the two paths get
+* one copy), and, given where the objects of the source are (see
+* locateObjects), an object that is one the target holds already is that
+* one, not a copy: `$a.self = $a` refers to the root of `a` in the store.
+*/
+function clonerFor(target, paths) {
+	const seen = paths ? existingObjects(paths, target) : /* @__PURE__ */ new Map();
+	return (value) => deepClone(value, {
+		keepUnregistered: true,
+		seen
+	});
+}
+/** One cloner per target copy, made when first used. */
+var clonersFor = (paths) => {
+	const made = /* @__PURE__ */ new Map();
+	return (target) => {
+		let cloner = made.get(target);
+		if (!cloner) {
+			cloner = clonerFor(target, paths?.(target));
+			made.set(target, cloner);
+		}
+		return cloner;
+	};
+};
+/**
 * A frozen copy of a value read from a working copy, matching what reads
 * from the (frozen) store return: writing to it fails instead of changing
 * the code's pending state behind its back.
@@ -14421,12 +14597,12 @@ function frozenCopy(value) {
 * path (the code replaced or deleted an intermediate object), its root is
 * replaced with the store's root as written.
 */
-function mirror(draft, ns, change, scopes = activeScopes) {
+function mirror(draft, ns, change, scopes = activeScopes, cloner = clonerOf) {
 	const root = change.path[0];
 	for (const scope of scopes) for (const copy of [scope.work[ns], scope.base[ns]]) try {
 		applyChange(copy, change.deleted ? change : {
 			...change,
-			value: cloneValue(change.value)
+			value: cloner(copy)(change.value)
 		});
 	} catch {
 		const stored = draft[ns][root];
@@ -14434,6 +14610,8 @@ function mirror(draft, ns, change, scopes = activeScopes) {
 		else delete copy[root];
 	}
 }
+/** A cloner of a copy of its own (no references shared with others). */
+var clonerOf = (target) => clonerFor(target);
 var NAMESPACE_KEYS$1 = new Set(NAMESPACES);
 /**
 * Runs store updates on the running code's working copies. They stay the
@@ -14533,11 +14711,12 @@ function routeStoreUpdate(recipe) {
 		const own = patches.filter((p) => p.path[0] === ns);
 		return [ns, own.length ? writtenPaths(view[ns], next[ns], own) : []];
 	});
-	const owned = (change) => change.deleted ? change : {
+	const cloners = clonersFor();
+	const owned = (change, target) => change.deleted ? change : {
 		...change,
-		value: cloneValue(change.value)
+		value: cloners(target)(change.value)
 	};
-	for (const [ns, list] of changes) for (const change of list) applyChange(inner.work[ns], owned(change));
+	for (const [ns, list] of changes) for (const change of list) applyChange(inner.work[ns], owned(change, inner.work[ns]));
 	return (draft) => {
 		const target = draft;
 		for (const key of Object.keys(next)) {
@@ -14548,12 +14727,12 @@ function routeStoreUpdate(recipe) {
 		for (const [ns, list] of changes) for (const change of list) {
 			const root = change.path[0];
 			try {
-				applyChange(namespaces[ns], owned(change));
+				applyChange(namespaces[ns], owned(change, namespaces[ns]));
 			} catch {
 				if (hasOwn(inner.work[ns], root)) namespaces[ns][root] = cloneValue(inner.work[ns][root]);
 				else delete namespaces[ns][root];
 			}
-			mirror(namespaces, ns, change);
+			mirror(namespaces, ns, change, activeScopes, cloners);
 		}
 	};
 }
@@ -14581,7 +14760,7 @@ function commitScopes(commits) {
 	const all = commits.map(({ scope, keepRunning }) => ({
 		scope,
 		keepRunning,
-		changes: NAMESPACES.map((ns) => [ns, diffPaths(scope.base[ns], scope.work[ns])])
+		changes: NAMESPACES.map((ns) => [ns, changesOf(scope.base[ns], scope.work[ns])])
 	}));
 	const changed = all.filter(({ changes }) => changes.some(([, list]) => list.length > 0));
 	if (changed.length === 0) return;
@@ -14593,29 +14772,53 @@ function commitScopes(commits) {
 		committing = false;
 	}
 	function commitRecipe(draft) {
-		all.forEach(({ scope, keepRunning, changes }, i) => {
-			const own = (value) => keepRunning ? cloneValue(value) : value;
+		all.forEach(({ scope, changes }, i) => {
+			const paths = new Map(changes.map(([ns, list]) => [ns, locateObjects(scope.work[ns], list)]));
+			const own = new Map(changes.map(([ns]) => [ns, clonerFor(draft[ns], paths.get(ns))]));
+			const enclosing = all.slice(0, i).map((c) => c.scope);
+			const enclosingCloners = new Map(changes.map(([ns]) => [ns, clonersFor(() => paths.get(ns))]));
 			for (const [ns, list] of changes) {
 				const replaced = /* @__PURE__ */ new Set();
 				for (const change of list) {
 					const root = change.path[0];
-					if (replaced.has(root) || isApplied(draft[ns], change)) continue;
+					if (replaced.has(root)) continue;
 					try {
-						applyChange(draft[ns], change.deleted ? change : {
+						if (change.deleted) {
+							if (!isApplied(draft[ns], change)) applyChange(draft[ns], change);
+							continue;
+						}
+						const value = change.alias ? own.get(ns)(change.value) : void 0;
+						if (change.alias ? Object.is(getByPath(draft[ns], change.path), value) : isApplied(draft[ns], change)) continue;
+						applyChange(draft[ns], {
 							...change,
-							value: own(change.value)
+							value: change.alias ? value : own.get(ns)(change.value)
 						});
 					} catch {
-						draft[ns][root] = own(scope.work[ns][root]);
+						draft[ns][root] = own.get(ns)(scope.work[ns][root]);
 						replaced.add(root);
 					}
 				}
-				const enclosing = all.slice(0, i).map((c) => c.scope);
-				for (const change of list) mirror(draft, ns, change, enclosing);
+				for (const change of list) mirror(draft, ns, change, enclosing, enclosingCloners.get(ns));
 			}
 		});
 	}
 }
+/**
+* The changes of the code to a namespace: its property paths that differ
+* (see diffPaths), and those that hold equal content but another object
+* than they did (see aliasChanges), those first.
+*/
+function changesOf(base, work) {
+	const written = diffPaths(base, work);
+	const keys = new Set(written.map((c) => pathKey(c.path)));
+	const aliases = [];
+	for (const change of aliasChanges(base, work)) {
+		if (underChange(change.path, keys)) continue;
+		keys.add(pathKey(change.path));
+		aliases.push(change);
+	}
+	return [...aliases, ...written];
+}
 /** Every running mutation, to commit with its code going on. */
 var running = () => activeScopes.map((scope) => ({
 	scope,
@@ -14851,15 +15054,33 @@ function registerDialogHost(callbacks) {
 		if (dialogHostCallbacks === callbacks) dialogHostCallbacks = null;
 	};
 }
+/**
+* The dialogs on display, bottom first, whoever opened them: the trigger
+* host, `{dialog}` or a menubar button (each PassageDialog registers itself
+* while mounted), as the function that closes each.
+*/
+var openDialogs = [];
+/** Register a displayed dialog; returns the function that unregisters it. */
+function registerOpenDialog(close) {
+	openDialogs.push(close);
+	return () => {
+		const i = openDialogs.lastIndexOf(close);
+		if (i >= 0) openDialogs.splice(i, 1);
+	};
+}
+/** Close the topmost dialog. */
 function closeCurrentDialog() {
-	dialogHostCallbacks?.close();
+	const top = openDialogs[openDialogs.length - 1];
+	if (top) top();
+	else dialogHostCallbacks?.close();
 }
 function closeAllOpenDialogs() {
 	clearDialogQueue();
+	for (const close of [...openDialogs].reverse()) close();
 	dialogHostCallbacks?.closeAll();
 }
 function isDialogShowing() {
-	return dialogHostCallbacks?.isOpen() ?? false;
+	return openDialogs.length > 0 || (dialogHostCallbacks?.isOpen() ?? false);
 }
 //#endregion
 //#region src/runtime-errors.ts
@@ -14942,7 +15163,10 @@ var lastNavigationVars = createNamespace();
 * object) or deleted. A recorded value is a deep copy, so that changing a
 * live value in place (a class instance is not frozen) cannot change
 * history; instances of unregistered classes are kept, as the store keeps
-* them (a save then refuses them).
+* them (a save then refuses them). The copies are made together, so what
+* variables share (an object, a cycle) stays shared in them, and a variable
+* left as it is that shares with a replaced one is recorded again, to share
+* with its copy.
 */
 function computeVarPatches(prev, curr) {
 	const forward = [];
@@ -14950,11 +15174,33 @@ function computeVarPatches(prev, curr) {
 		key,
 		deleted: true
 	});
-	for (const key of Object.keys(curr)) if (!hasOwn(prev, key) || !Object.is(prev[key], curr[key])) forward.push({
+	const seen = /* @__PURE__ */ new Map();
+	const record = (key) => forward.push({
 		key,
 		deleted: false,
-		value: deepClone(curr[key], { keepUnregistered: true })
+		value: deepClone(curr[key], {
+			keepUnregistered: true,
+			seen
+		})
 	});
+	const unchanged = [];
+	for (const key of Object.keys(curr)) if (!hasOwn(prev, key) || !Object.is(prev[key], curr[key])) record(key);
+	else if (typeof curr[key] === "object" && curr[key] !== null) unchanged.push(key);
+	for (let found = seen.size > 0; found;) {
+		found = false;
+		for (const key of unchanged) {
+			const probe = /* @__PURE__ */ new Map();
+			deepClone(curr[key], {
+				keepUnregistered: true,
+				seen: probe
+			});
+			if (![...probe.keys()].some((object) => seen.has(object))) continue;
+			record(key);
+			unchanged.splice(unchanged.indexOf(key), 1);
+			found = true;
+			break;
+		}
+	}
 	return { forward };
 }
 /**
@@ -15273,7 +15519,7 @@ function switchToPlaythrough(id, stored) {
 }
 /** Move the running game to a new playthrough at once (see restart). */
 function switchToNewPlaythrough(ifid) {
-	const id = crypto.randomUUID();
+	const id = randomUUID();
 	switchToPlaythrough(id, startNewPlaythrough(ifid, id).catch((err) => {
 		console.error("spindle: failed to start new playthrough", err);
 	}));
@@ -15786,7 +16032,7 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		const ifid = storyData.ifid;
 		const current = knownPlaythroughId();
 		const established = playthroughSetup;
-		const replacementId = crypto.randomUUID();
+		const replacementId = randomUUID();
 		const deletion = deletePlaythroughData(ifid, playthroughId, {
 			current: current || established,
 			id: replacementId
@@ -16022,6 +16268,7 @@ function PassageDialog({ passageName, fallbackMarkup, panelClass, onClose, dismi
 	}, [markup, nobr]);
 	const panelRef = useRef(null);
 	useModalFocus(panelRef, ".dialog-body", dismissible, stableOnClose);
+	useLayoutEffect(() => registerOpenDialog(stableOnClose), [stableOnClose]);
 	useLayoutEffect(() => {
 		if (panelRef.current) emitFromRender("dialogrender", passageName ?? "", panelRef.current);
 	}, []);
@@ -16619,7 +16866,7 @@ function unset(param) {
 	return param.type === "options" ? {} : void 0;
 }
 var WORD_RE = /\w+/y;
-var DIGITS_RE = /\d+/y;
+var NUMBER_RE = /[-+]?(?:\d+\.?\d*|\.\d+)/y;
 var WORD_OR_PUNCT_RE = /\S+/y;
 /** Match the sticky regex `re` at `pos`, returning the matched text. */
 function matchAt(re, src, pos) {
@@ -16628,7 +16875,8 @@ function matchAt(re, src, pos) {
 }
 /**
 * Read keyword options (`goto "X" priority 5 once`). A keyword takes the
-* quoted string (with or without whitespace before it) or digit run after
+* quoted string (with or without whitespace before it) or number (signed,
+* fractional) after
 * it as its value; keywords that aren't declared, and their values, are
 * skipped. A keyword of a `string` parameter must be followed by a quoted
 * string.
@@ -16647,7 +16895,7 @@ function readOptions(params, src, { at, spans }) {
 		let j = i;
 		while (j < src.length && isWhitespace(src[j])) j++;
 		const quoted = readQuoted(src, j);
-		const digits = quoted || j === i ? null : matchAt(DIGITS_RE, src, j);
+		const digits = quoted || j === i ? null : matchAt(NUMBER_RE, src, j);
 		if (quoted) {
 			val = quoted.value;
 			i = quoted.end;
@@ -17364,10 +17612,6 @@ function parameterLookup(macros) {
 }
 /** What a `string` or `text` argument holds when its parameter doesn't say. */
 var holdsByDefault = (interpolate) => interpolate ? "markup" : "text";
-/** Whether a parameter in `params` (options too) holds code in a string. */
-function holdsCode(params) {
-	return params.some((p) => p.holds === "expression" || p.holds === "statements" || !!p.parameters && holdsCode(p.parameters));
-}
 /** The goal of the code an argument of this type holds, if it is code. */
 function codeGoal(param) {
 	if (param.type === "expression" || param.type === "passage") return "expression";
@@ -17390,15 +17634,22 @@ function* codeAndText(src, tokens, parametersOf) {
 	const closeOf = (t, name) => tokens.findIndex((c, k) => k > t && c.type === "macro" && c.isClose && c.name.toLowerCase() === name);
 	for (let t = 0; t < tokens.length; t++) {
 		const token = tokens[t];
-		if (token.type === "link") yield {
-			kind: "passage",
-			name: token.target,
-			offset: token.targetStart,
-			length: token.targetEnd - token.targetStart,
-			macro: "link",
-			label: src.slice(token.start, token.end)
-		};
-		else if (token.type === "expression") yield {
+		if (token.type === "link") {
+			yield {
+				kind: "passage",
+				name: token.target,
+				offset: token.targetStart,
+				length: token.targetEnd - token.targetStart,
+				macro: "link",
+				label: src.slice(token.start, token.end)
+			};
+			if (token.display.includes("{")) yield {
+				kind: "text",
+				text: token.display,
+				offset: locate(src, token.display, token.start),
+				where: "In the label of a link: "
+			};
+		} else if (token.type === "expression") yield {
 			kind: "code",
 			code: token.expression,
 			offset: token.end - 1 - token.expression.length,
@@ -17564,7 +17815,7 @@ function* argPieces(args, offset, params, macro, label) {
 			};
 		}
 	}
-	yield* visit(params, values);
+	yield* [...visit(params, values)].sort((a, b) => a.offset - b.offset);
 }
 /**
 * Index of `part` in `text` from `from` on, else anywhere, else `from`: the
@@ -17819,7 +18070,6 @@ function declarationRegex(sigil) {
 var VAR_PATH_RE = /\$(\w+(?:\.\w+)*)/y;
 /** Quoted first argument of an input macro naming a story variable. */
 var QUOTED_VAR_ARG_RE = /^["']\$(\w+(?:\.\w+)*)["']?$/;
-var FOR_LOCAL_RE = /\{for\s+@(\w+)(?:\s*,\s*@(\w+))?\s+of\b/g;
 var VALID_VAR_TYPES = new Set([
 	"number",
 	"string",
@@ -17882,30 +18132,14 @@ function parseStoryVariables(content, sigil = "$") {
 	return schema;
 }
 /**
-* Extract for-loop local variable names from passage content.
-* `{for @item of ...}` → "item"
-* `{for @index, @item of ...}` → "index", "item"
-*/
-function extractForLocals(content) {
-	const locals = /* @__PURE__ */ new Set();
-	let match;
-	FOR_LOCAL_RE.lastIndex = 0;
-	while ((match = FOR_LOCAL_RE.exec(content)) !== null) {
-		locals.add(match[1]);
-		if (match[2]) locals.add(match[2]);
-	}
-	return locals;
-}
-/**
 * Validate a single variable reference path (e.g. "player.health") against
 * the schema. Returns an error message or null if valid.
 */
-function validateRef(ref, schema, forLocals) {
+function validateRef(ref, schema) {
 	const parts = ref.split(".");
 	const rootName = parts[0];
 	const nameError = variableNameError(rootName, "$" + rootName);
 	if (nameError) return nameError;
-	if (forLocals.has(rootName)) return null;
 	const rootSchema = schema.get(rootName);
 	if (!rootSchema) return `Undeclared variable: $${ref}`;
 	let current = rootSchema;
@@ -17961,8 +18195,9 @@ function scanInterpolations(text, onRef, storeVarMacros = NO_STORE_VAR_MACROS) {
 * Report `$var` references in JavaScript code, lexed as the expression
 * engine lexes it (`lexJs`): references in code, but none inside string or
 * regex literals or comments, nor property names (`a.$b`, `{ $b: 1 }`).
-* The text of string and template literals is scanned for the markup that
-* labels evaluate (`{$…}`); the `${…}` parts of template literals are code.
+* The text of string and template literals is not scanned: a string in code
+* is literal text unless a macro argument that holds markup is read as such
+* (see scanArgs); the `${…}` parts of template literals are code.
 */
 function scanCode(code, onRef, goal = "expression") {
 	const parsed = parseOrError(code, goal);
@@ -17975,37 +18210,17 @@ function scanCode(code, onRef, goal = "expression") {
 		VAR_PATH_RE.lastIndex = ref.start;
 		onRef(VAR_PATH_RE.exec(code)[1]);
 	}
-	for (const text of parsed.strings) scanInterpolations(text, onRef);
 }
 /** `scanCode` for code acorn can't parse: lexed leniently. */
 function scanCodeLeniently(code, onRef, goal) {
-	/** Open template literals: their text so far, null in an interpolation. */
-	const templates = [];
 	lexJs(code, {
 		variable(sigil, _name, index) {
 			if (sigil !== "$") return;
 			VAR_PATH_RE.lastIndex = index;
 			onRef(VAR_PATH_RE.exec(code)[1]);
 		},
-		literal(text, _index, nesting) {
-			const template = templates[templates.length - 1];
-			if (template?.nesting === nesting) if (template.text === null) template.text = "";
-			else if (text === "`" || text === "${") {
-				scanInterpolations(template.text, onRef);
-				if (text === "`") templates.pop();
-				else template.text = null;
-			} else template.text += text;
-			else if (text === "`") templates.push({
-				nesting,
-				text: ""
-			});
-			else if (text[0] === "\"" || text[0] === "'") {
-				const { closed } = scanStringLiteral(text, 0);
-				scanInterpolations(text.slice(1, closed ? -1 : void 0), onRef);
-			}
-		}
+		literal() {}
 	}, goal);
-	for (const t of templates) if (t.text) scanInterpolations(t.text, onRef);
 }
 /**
 * Report the `$var` references a passage evaluates at runtime: `{$var}`
@@ -18017,14 +18232,23 @@ function collectPassageRefs(content, storeVarMacros, onRef, parametersOf) {
 	withParseCache(() => collectTokenRefs(content, tokensOf(content, false), storeVarMacros, onRef, parametersOf));
 }
 /**
-* Report the references in the code that a macro's quoted arguments hold
-* (see ParameterDef.holds), the condition and `run` action of `{watch}`:
-* the argument scan sees only the strings. Only the macros that declare
-* code in a string have their arguments read.
+* Report the references in the arguments of a macro by what its parameters
+* say each holds (see ParameterDef.holds): code is scanned as code and
+* markup as markup, but literal text (a placeholder, a passage name) holds
+* none. A macro without declared parameters, or arguments that do not
+* parse, are scanned as code.
 */
-function scanStringCode(token, params, onRef) {
-	if (!params || !token.rawArgs || !holdsCode(params)) return;
-	for (const piece of argPieces(token.rawArgs, 0, params, token.name, "")) if (piece.kind === "code" && piece.inString) scanCode(piece.code, onRef, piece.goal);
+function scanArgs(token, params, onRef) {
+	if (!token.rawArgs) return;
+	if (params) {
+		const pieces = [...argPieces(token.rawArgs, 0, params, token.name, "")];
+		if (!pieces.some((piece) => piece.kind === "argument-error")) {
+			for (const piece of pieces) if (piece.kind === "code") scanCode(piece.code, onRef, piece.goal);
+			else if (piece.kind === "text") scanInterpolations(piece.text, onRef);
+			return;
+		}
+	}
+	scanCode(token.rawArgs, onRef);
 }
 /** Report the `$var` references in the tokens of `content`. */
 function collectTokenRefs(content, tokens, storeVarMacros, onRef, parametersOf = () => void 0) {
@@ -18032,22 +18256,25 @@ function collectTokenRefs(content, tokens, storeVarMacros, onRef, parametersOf =
 		const token = tokens[t];
 		if (token.type === "variable") {
 			if (token.scope === "variable" && token.name) onRef(token.name);
-		} else if (token.type === "expression") scanCode(token.expression, onRef);
+		} else if (token.type === "link") scanInterpolations(token.display, onRef);
+		else if (token.type === "expression") scanCode(token.expression, onRef);
 		else if (token.type === "html") for (const [name, value] of Object.entries(token.attributes)) if (isCodeAttribute(name)) scanSigilReferences(value, onRef);
 		else scanInterpolations(value, onRef, storeVarMacros);
 		else if (token.type === "macro" && !token.isClose) {
-			scanCode(token.rawArgs, onRef);
-			scanStringCode(token, parametersOf(token.name), onRef);
+			scanArgs(token, parametersOf(token.name), onRef);
+			if (token.className) scanInterpolations(token.className, onRef);
+			if (token.id) scanInterpolations(token.id, onRef);
 			if (storeVarMacros.has(token.name.toLowerCase())) {
 				const first = token.rawArgs.trim().split(/\s+/)[0] ?? "";
 				const quoted = QUOTED_VAR_ARG_RE.exec(first);
 				if (quoted) onRef(quoted[1]);
+				else if (!/^["'`]/.test(first)) scanCode(first, onRef);
 			}
-			if (token.name === "do") {
+			if (token.name.toLowerCase() === "do") {
 				let close = t + 1;
 				while (close < tokens.length) {
 					const c = tokens[close];
-					if (c.type === "macro" && c.isClose && c.name === "do") break;
+					if (c.type === "macro" && c.isClose && c.name.toLowerCase() === "do") break;
 					close++;
 				}
 				if (close < tokens.length) {
@@ -18071,9 +18298,8 @@ function validatePassages(passages, schema, storeVarMacros = BUILTIN_STORE_VAR_M
 	const storeVarSet = new Set(Array.from(storeVarMacros, (m) => m.toLowerCase()));
 	for (const [name, passage] of passages) {
 		if (NOT_MARKUP.has(name)) continue;
-		const forLocals = extractForLocals(passage.content);
 		collectPassageRefs(passage.content, storeVarSet, (ref) => {
-			const error = validateRef(ref, schema, forLocals);
+			const error = validateRef(ref, schema);
 			if (error) errors.push(`Passage "${name}": ${error}`);
 		}, parametersOf);
 	}
@@ -18336,7 +18562,10 @@ defineMacro({
 	],
 	render(_props, ctx) {
 		try {
-			const { currentExpr, maxExpr, labelMode } = meterArgs(ctx.args);
+			const { currentExpr, maxExpr, labelMode } = meterArgs({
+				...ctx.args,
+				label: ctx.resolve?.(ctx.args.label)
+			});
 			const current = Number(ctx.evaluate(currentExpr));
 			const max = Number(ctx.evaluate(maxExpr));
 			const pct = max === 0 ? 0 : Math.max(0, Math.min(100, current / max * 100));
@@ -18737,7 +18966,7 @@ defineMacro({
 		type: "passage"
 	}],
 	render({ children = [] }, ctx) {
-		const display = ctx.args.text ?? "";
+		const display = ctx.resolve?.(ctx.args.text ?? "") ?? "";
 		let passage = null;
 		let failure;
 		if (ctx.args.passage !== void 0) try {
@@ -18884,7 +19113,7 @@ defineMacro({
 		visibleCharsRef.current = visibleChars;
 		useEffect(() => {
 			if (containerRef.current) setTotalChars((containerRef.current.textContent || "").length);
-		}, []);
+		});
 		useEffect(() => {
 			if (totalChars === 0) return;
 			if (visibleCharsRef.current >= totalChars) return;