@rohal12/spindle 0.52.3 → 0.52.5

package/dist/pkg/headless.js

@@ -32,28 +32,192 @@ function create() {
 	return (initializer) => bindPreact(createStore()(initializer));
 }
 //#endregion
-//#region src/class-registry.ts
-var registry$1 = /* @__PURE__ */ new Map();
-var ctorToName = /* @__PURE__ */ new Map();
-function registerClass(name, ctor) {
-	registry$1.set(name, ctor);
-	ctorToName.set(ctor, name);
+//#region src/utils/namespace.ts
+/** The variable name no namespace can hold. */
+var RESERVED_NAME = "__proto__";
+/**
+* Why `name` (without its sigil) cannot be a variable name, or undefined if
+* it can. `label` is the name as the author wrote it (e.g. `$__proto__`).
+*/
+function variableNameError(name, label = name) {
+	return name === "__proto__" ? `"${label}" cannot be used as a variable name (${RESERVED_NAME} is reserved)` : void 0;
+}
+/** Throw a TypeError if `name` cannot be a variable name. */
+function checkVariableName(name, label = name) {
+	const error = variableNameError(name, label);
+	if (error) throw new TypeError(`spindle: ${error}`);
 }
+/** Whether `obj` holds `key` as an own property. */
+var hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+/** `ns[key]` if `ns` holds it as an own property, else undefined. */
+var ownValue = (ns, key) => ns && hasOwn(ns, key) ? ns[key] : void 0;
 /**
-* The registered name of the class `value` is an instance of, or undefined.
-* Looks the constructor up on the prototype, so an own property named
-* "constructor" (plain data) cannot hide or fake the class.
+* A record with no prototype holding the own entries of `sources`, or only
+* those whose value passes `keep`.
 */
-function registeredClassName(value) {
-	const proto = Object.getPrototypeOf(value);
-	return proto === null ? void 0 : ctorToName.get(proto.constructor);
+function ownEntries(sources, keep = () => true) {
+	const record = Object.create(null);
+	for (const source of sources) {
+		if (!source) continue;
+		for (const key of Object.keys(source)) {
+			const value = source[key];
+			if (keep(value)) record[key] = value;
+		}
+	}
+	return record;
 }
-function isPlainObject(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const proto = Object.getPrototypeOf(value);
-	return proto === Object.prototype || proto === null;
+/** A namespace with no prototype holding the own entries of `sources`. */
+var createNamespace = (...sources) => ownEntries(sources);
+/** Whether `value` is an object with no prototype. */
+var isNamespace = (value) => Object.getPrototypeOf(value) === null;
+/** `ns` itself if it has no prototype, else a namespace copy of it. */
+var asNamespace = (ns) => isNamespace(ns) ? ns : createNamespace(ns);
+/** A namespace copy of `ns` with `key` set to `value`. */
+function withEntry(ns, key, value) {
+	const next = createNamespace(ns);
+	next[key] = value;
+	return next;
+}
+/** An empty namespace that cannot change. */
+var EMPTY_NAMESPACE = Object.freeze(createNamespace());
+/** The names whose own entries differ between `a` and `b`, `a`'s first. */
+function changedNames(a, b) {
+	return [...new Set([...Object.keys(a), ...Object.keys(b)])].filter((name) => ownValue(a, name) !== ownValue(b, name));
+}
+var isCount = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
+/** The count of `name` in `counts`: its own entry, or 0. */
+function countOf(counts, name) {
+	const value = ownValue(counts, name);
+	return isCount(value) ? value : 0;
+}
+/**
+* Counters with no prototype holding the own entries of `source` that are
+* counts, with `name` (if given) counted once more. Immer copies the
+* counters on every write anyway, so counting into a fresh copy costs no
+* more than counting in place.
+*/
+function createCounts(source, name) {
+	const counts = ownEntries([source], isCount);
+	if (name !== void 0) counts[name] = countOf(source, name) + 1;
+	return counts;
+}
+//#endregion
+//#region src/utils/object-path.ts
+/**
+* Traverse dot-path segments on an object and return the nested 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.
+*/
+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;
+		current = current[seg];
+	}
+	return current;
+}
+/** Array indices ("0", "1", …) and "length": the keys an array holds. */
+var isArrayKey = (key) => key === "length" || /^(0|[1-9]\d*)$/.test(key);
+/**
+* Built-ins whose content is not their properties: a property written into
+* one would be dropped by clones and saves (and by Immer, for Map and Set).
+*/
+var builtinName = (value) => value instanceof Map ? "a Map" : value instanceof Set ? "a Set" : value instanceof Date ? "a Date" : value instanceof RegExp ? "a RegExp" : void 0;
+/**
+* Shallow copy that keeps the prototype, so a registered class instance
+* stays an instance of its class (with the same own keys deepClone copies).
+*/
+function shallowCopy(value) {
+	const copy = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value));
+	for (const key of Object.keys(value)) Object.defineProperty(copy, key, {
+		value: value[key],
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	return copy;
+}
+/**
+* Set a value at dot-path `segments` below `root`.
+*
+* When `root` is an Immer draft, objects Immer does not draft (registered
+* class instances and everything below them) are copied on the way down and
+* the copy is assigned to its parent, so the write produces new references
+* up to the root. Writing into such an object directly would mutate the
+* instance shared with the previous state and with history, and subscribers
+* would see no change. Outside a draft (a private working copy) the path is
+* written in place.
+*
+* The path goes through own properties of plain objects, class instances
+* and arrays (by index); anything else throws a TypeError rather than
+* writing where no clone or save would see it: an inherited property such
+* as a method counts as missing, and Map, Set, Date and RegExp values and
+* other keys of arrays are refused, as is a "__proto__" segment.
+*/
+function setByPath(root, segments, value, options = {}) {
+	const parent = walkToParent(root, segments, options.createMissing ?? false);
+	parent[segments[segments.length - 1]] = value;
+}
+/**
+* Delete the property at dot-path `segments` below `root`, copying
+* undrafted objects on the way down like setByPath(). Does nothing when an
+* intermediate is missing or not an object, or the property is absent (or
+* only inherited).
+*/
+function deleteByPath(root, segments) {
+	const last = segments[segments.length - 1];
+	checkSegments(segments);
+	let holder = root;
+	for (const seg of segments.slice(0, -1)) {
+		if (holder == null || typeof holder !== "object" || !hasOwn(holder, seg)) return;
+		holder = holder[seg];
+	}
+	if (holder == null || typeof holder !== "object" || !hasOwn(holder, last)) return;
+	const parent = walkToParent(root, segments, false);
+	delete parent[last];
+}
+/** Refuse a segment that would reach a prototype instead of story state. */
+function checkSegments(segments) {
+	if (segments.includes("__proto__")) throw new TypeError(`spindle: Cannot use "__proto__" in a variable path ("${segments.join(".")}")`);
+}
+/** Throw unless `holder` can take `key` as story state (see setByPath). */
+function checkHolder(holder, key, segments, depth) {
+	const kind = builtinName(holder) ?? (Array.isArray(holder) && !isArrayKey(key) ? "an array" : "");
+	if (kind) throw new TypeError(`spindle: Cannot set property "${key}" on ${kind} (at "${segments.slice(0, depth).join(".")}")`);
 }
 /**
+* Walk to the object holding the last of `segments`, copying undrafted
+* objects when `root` is an Immer draft (see setByPath). A missing or
+* non-object intermediate is replaced by a plain object when
+* `createMissing` is set, and throws a TypeError otherwise.
+*/
+function walkToParent(root, segments, createMissing) {
+	checkSegments(segments);
+	const copyOnWrite = isDraft(root);
+	let current = root;
+	for (let i = 0; i < segments.length - 1; i++) {
+		const seg = segments[i];
+		checkHolder(current, seg, segments, i);
+		let next = hasOwn(current, seg) ? current[seg] : void 0;
+		if (next == null || typeof next !== "object") {
+			if (!createMissing) throw new TypeError(`spindle: Cannot set property "${segments[i + 1]}" on ${next === null ? "null" : typeof next} (at "${segments.slice(0, i + 1).join(".")}")`);
+			next = {};
+			current[seg] = next;
+		} else if (copyOnWrite && !isDraft(next) && !builtinName(next)) {
+			next = shallowCopy(next);
+			current[seg] = next;
+		}
+		current = next;
+	}
+	checkHolder(current, segments[segments.length - 1], segments, segments.length - 1);
+	return current;
+}
+//#endregion
+//#region src/structural.ts
+/**
 * Set an own enumerable property. A "__proto__" key is defined as an own
 * property (as JSON.parse does) instead of replacing the prototype.
 */
@@ -66,6 +230,11 @@ function setOwn(target, key, value) {
 	});
 	else target[key] = value;
 }
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
 function deepClone(value, options = {}) {
 	const seen = /* @__PURE__ */ new Map();
 	function clone(val) {
@@ -92,15 +261,9 @@ function deepClone(value, options = {}) {
 			for (const v of val) copy.add(clone(v));
 			return copy;
 		}
-		if (registeredClassName(obj) !== void 0) {
-			const copy = Object.create(Object.getPrototypeOf(obj));
-			seen.set(obj, copy);
-			for (const key of Object.keys(obj)) setOwn(copy, key, clone(obj[key]));
-			return copy;
-		}
-		const plain = isPlainObject(val);
-		if (!plain && options.keepUnregistered) return val;
-		const copy = plain ? Object.create(Object.getPrototypeOf(obj)) : {};
+		const keepsProto = registeredClassName(obj) !== void 0 || isPlainObject(val);
+		if (!keepsProto && options.keepUnregistered) return val;
+		const copy = keepsProto ? Object.create(Object.getPrototypeOf(obj)) : {};
 		seen.set(obj, copy);
 		for (const key of Object.keys(obj)) setOwn(copy, key, clone(obj[key]));
 		return copy;
@@ -150,10 +313,156 @@ function equal(a, b, assumed) {
 	const bo = b;
 	const keys = Object.keys(ao);
 	if (keys.length !== Object.keys(bo).length) return false;
-	for (const key of keys) if (!hasOwn$3(bo, key) || !equal(ao[key], bo[key], assumed)) return false;
+	for (const key of keys) if (!hasOwn(bo, key) || !equal(ao[key], bo[key], assumed)) return false;
 	return true;
 }
-var hasOwn$3 = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+/**
+* Objects merged property by property: plain objects and (registered)
+* class instances. Arrays, Map, Set, Date and RegExp are values that are
+* replaced as a whole, since their elements have no stable identity to
+* merge by (a shift moves every index).
+*/
+function isMergeable(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Map) && !(value instanceof Set) && !(value instanceof Date) && !(value instanceof RegExp);
+}
+/**
+* Whether changes between `a` and `b` merge key by key: both are objects of
+* one class (see isMergeable), or, with `arrays`, both are arrays.
+*/
+function mergesWith(a, b, arrays) {
+	if (arrays && (Array.isArray(a) || Array.isArray(b))) return Array.isArray(a) && Array.isArray(b);
+	return isMergeable(a) && isMergeable(b) && Object.getPrototypeOf(a) === Object.getPrototypeOf(b);
+}
+/**
+* The keys at which `after` differs from `before`, two values that merge
+* (see mergesWith): keys added, deleted, or holding another value. Store
+* updates are immutable, so a value that kept its identity is no change,
+* and one rebuilt with equal content (mutation code commits whole values)
+* 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.
+*/
+function keyChanges(before, after, arrays) {
+	const changes = [];
+	const compare = (key, b, a) => {
+		if (Object.is(b, a)) return;
+		if (mergesWith(b, a, arrays)) changes.push({
+			key,
+			kind: "nested",
+			before: b,
+			after: a
+		});
+		else if (!deepEqual(b, a)) changes.push({
+			key,
+			kind: "changed",
+			after: a
+		});
+	};
+	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 = a.length; i < b.length; i++) changes.push({
+			key: String(i),
+			kind: "deleted"
+		});
+		return changes;
+	}
+	for (const key of Object.keys(after)) if (hasOwn(before, key)) compare(key, before[key], after[key]);
+	else changes.push({
+		key,
+		kind: "added",
+		after: after[key]
+	});
+	for (const key of Object.keys(before)) if (!hasOwn(after, key)) changes.push({
+		key,
+		kind: "deleted"
+	});
+	return changes;
+}
+/**
+* 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.
+*/
+function diffPaths(before, after) {
+	const changes = [];
+	const ancestors = /* @__PURE__ */ new Set();
+	(function walk(b, a, path) {
+		if (ancestors.has(a)) return;
+		ancestors.add(a);
+		for (const change of keyChanges(b, a, false)) {
+			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
+			} : {
+				path: at,
+				deleted: false,
+				value: change.after
+			});
+		}
+		ancestors.delete(a);
+	})(before, after, []);
+	return changes;
+}
+/** Whether `target` already holds what `change` would write. */
+function isApplied(target, change) {
+	const parent = getByPath(target, change.path.slice(0, -1));
+	if (parent === null || typeof parent !== "object") return change.deleted;
+	const key = change.path[change.path.length - 1];
+	if (!hasOwn(parent, key)) return change.deleted;
+	return !change.deleted && deepEqual(parent[key], change.value);
+}
+function applyChange(target, change) {
+	if (change.deleted) deleteByPath(target, change.path);
+	else setByPath(target, 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/class-registry.ts
+var registry$1 = /* @__PURE__ */ new Map();
+var ctorToName = /* @__PURE__ */ new Map();
+function registerClass(name, ctor) {
+	registry$1.set(name, ctor);
+	ctorToName.set(ctor, name);
+}
+/**
+* The registered name of the class `value` is an instance of, or undefined.
+* Looks the constructor up on the prototype, so an own property named
+* "constructor" (plain data) cannot hide or fake the class.
+*/
+function registeredClassName(value) {
+	const proto = Object.getPrototypeOf(value);
+	return proto === null ? void 0 : ctorToName.get(proto.constructor);
+}
 var CLASS_TAG = "__spindle_class__";
 var DATA_TAG = "__spindle_data__";
 /** A tagged value, as serialize() writes and deserialize() reads it. */
@@ -225,7 +534,7 @@ function serialize(value) {
 		const name = registeredClassName(val);
 		if (name !== void 0) return tagged(name, serKeys(val));
 		const data = serKeys(val);
-		return hasOwn$3(val, CLASS_TAG) ? tagged("__Object__", data) : data;
+		return hasOwn(val, CLASS_TAG) ? tagged("__Object__", data) : data;
 	}
 	return ser(value);
 }
@@ -311,7 +620,7 @@ function isDeserializable(value) {
 			case "__Map__": return Array.isArray(data.entries) && Array.from(data.entries).every((entry) => Array.isArray(entry) && entry.length === 2 && check(entry[0]) && check(entry[1]));
 			case "__Set__": return Array.isArray(data.entries) && Array.from(data.entries).every(check);
 			case "__Undefined__": return true;
-			case "__Number__": return typeof data.value === "string" && hasOwn$3(SPECIAL_NUMBERS, data.value);
+			case "__Number__": return typeof data.value === "string" && hasOwn(SPECIAL_NUMBERS, data.value);
 			case "__BigInt__": return typeof data.value === "string" && /^-?\d+$/.test(data.value);
 			default: return checkKeys(data);
 		}
@@ -382,6 +691,10 @@ function isSavePayload(value) {
 	if (typeof obj.historyIndex !== "number") return false;
 	return true;
 }
+/** Estimated byte size of a serialized save payload. */
+function estimatePayloadBytes(payload) {
+	return JSON.stringify(payload).length;
+}
 //#endregion
 //#region src/js-lexer.ts
 /** Transient name after `%`: an identifier, so `%3` is never a reference. */
@@ -486,13 +799,13 @@ function scanRegex(src, start, cache) {
 	};
 	let i = start + 1;
 	while (i < src.length) {
+		const lineEnd = regexLineEnd(src, i);
+		if (lineEnd !== -1) return done(lineEnd, false);
 		const c = src.charAt(i);
 		if (c === "\\") {
-			if (LINE_TERMINATOR_RE.test(src.charAt(i + 1))) return done(i + 1, false);
 			i += 2;
 			continue;
 		}
-		if (LINE_TERMINATOR_RE.test(c)) return done(i, false);
 		if (c === "[") {
 			i = scanRegexClass(src, i, cache);
 			if (src.charAt(i) !== "]") return done(i, false);
@@ -523,16 +836,17 @@ function scanRegexClass(src, open, cache) {
 	const opens = [open];
 	let i = open + 1;
 	while (i < src.length) {
+		const lineEnd = regexLineEnd(src, i);
+		if (lineEnd !== -1) {
+			i = lineEnd;
+			break;
+		}
 		const c = src.charAt(i);
 		if (c === "\\") {
-			if (LINE_TERMINATOR_RE.test(src.charAt(i + 1))) {
-				i++;
-				break;
-			}
 			i += 2;
 			continue;
 		}
-		if (c === "]" || LINE_TERMINATOR_RE.test(c)) break;
+		if (c === "]") break;
 		if (c === "[" && cache) opens.push(i);
 		i++;
 	}
@@ -541,6 +855,16 @@ function scanRegexClass(src, open, cache) {
 	return i;
 }
 /**
+* Index of the line break at `i`, escaped (`\` then a line break) or not,
+* where a regex literal or class ends unterminated; -1 if there is none.
+*/
+function regexLineEnd(src, i) {
+	const c = src.charAt(i);
+	if (LINE_TERMINATOR_RE.test(c)) return i;
+	if (c === "\\" && LINE_TERMINATOR_RE.test(src.charAt(i + 1))) return i + 1;
+	return -1;
+}
+/**
 * The next index from `from` on where `find` matches (-1 for none), for
 * searches from increasing positions: a search from within the stretch the
 * last one covered has the same answer.
@@ -1490,8 +1814,7 @@ function splitSigilTemplate(template) {
 		}
 		text += template.slice(i, brace);
 		i = brace + 1;
-		const sigil = template[i];
-		const end = sigil === "$" || sigil === "_" || sigil === "@" || sigil === "%" ? scanBalancedBrace(template, i, memo) : -1;
+		const end = isSigil(template[i]) ? scanBalancedBrace(template, i, memo) : -1;
 		if (end === -1) {
 			text += "{";
 			continue;
@@ -1507,6 +1830,26 @@ function splitSigilTemplate(template) {
 }
 //#endregion
 //#region src/markup/tokenizer.ts
+/** Variable sigils: story ($), temporary (_), local (@), transient (%). */
+var SIGIL_SCOPES = {
+	$: "variable",
+	_: "temporary",
+	"@": "local",
+	"%": "transient"
+};
+/** The sigil of each variable scope. */
+var SCOPE_SIGILS = Object.fromEntries(Object.entries(SIGIL_SCOPES).map(([sigil, scope]) => [scope, sigil]));
+var SIGIL_CHARS = new Set(Object.keys(SIGIL_SCOPES));
+/** Whether `c` is a variable sigil. */
+function isSigil(c) {
+	return c !== void 0 && SIGIL_CHARS.has(c);
+}
+/** Copy the selectors set in `from` onto `target`, and return it. */
+function withSelectors(target, from) {
+	if (from.className) target.className = from.className;
+	if (from.id) target.id = from.id;
+	return target;
+}
 /** Tag name must start with a letter (covers standard and custom elements). */
 var VALID_TAG_START = /[a-zA-Z]/;
 /** HTML void elements: never have children or a closing tag. */
@@ -1526,13 +1869,6 @@ var HTML_VOID_TAGS = new Set([
 	"track",
 	"wbr"
 ]);
-/** Variable sigils: story ($), temporary (_), local (@), transient (%). */
-var SIGIL_CHARS = new Set([
-	"$",
-	"_",
-	"@",
-	"%"
-]);
 /**
 * Characters other than a sigil that open an expression after `{`:
 * `{(Math.max($a, 0))}`, `{!$done}`. Other characters that can start an
@@ -1543,25 +1879,32 @@ var EXPRESSION_START = new Set(["(", "!"]);
 /** Macros whose body is JavaScript source, kept verbatim instead of tokenized. */
 var RAW_BODY_MACROS = new Set(["do"]);
 /**
+* Link separators, in the order they are tried, and whether the target
+* comes first: display|target, display->target, target<-display.
+*/
+var LINK_SEPARATORS = [
+	["|", false],
+	["->", false],
+	["<-", true]
+];
+/**
 * Parse a Twine link interior into display and target.
 * Supports: display|target, display->target, target<-display, plain
 */
 function parseLink(inner) {
-	const pipeIdx = inner.indexOf("|");
-	if (pipeIdx !== -1) return {
-		display: inner.slice(0, pipeIdx).trim(),
-		target: inner.slice(pipeIdx + 1).trim()
-	};
-	const arrowIdx = inner.indexOf("->");
-	if (arrowIdx !== -1) return {
-		display: inner.slice(0, arrowIdx).trim(),
-		target: inner.slice(arrowIdx + 2).trim()
-	};
-	const revIdx = inner.indexOf("<-");
-	if (revIdx !== -1) return {
-		target: inner.slice(0, revIdx).trim(),
-		display: inner.slice(revIdx + 2).trim()
-	};
+	for (const [separator, targetFirst] of LINK_SEPARATORS) {
+		const idx = inner.indexOf(separator);
+		if (idx === -1) continue;
+		const before = inner.slice(0, idx).trim();
+		const after = inner.slice(idx + separator.length).trim();
+		return targetFirst ? {
+			display: after,
+			target: before
+		} : {
+			display: before,
+			target: after
+		};
+	}
 	const trimmed = inner.trim();
 	return {
 		display: trimmed,
@@ -1592,8 +1935,10 @@ function parseMacroContent(content) {
 }
 /**
 * Parse CSS selectors: .foo.bar#baz → { className: "foo bar", id: "baz" }
-* Scans .[a-zA-Z0-9_-]+ and #[a-zA-Z0-9_-]+ segments in any order.
-* Returns space-joined class string, last id wins, and position after last segment.
+* Scans .[a-zA-Z0-9_-]+ and #[a-zA-Z0-9_-]+ segments in any order, and one
+* space after them. Returns space-joined class string, last id wins (each
+* left out if empty), and the position after them: `startIdx` if there are
+* none.
 */
 function parseSelectors(input, startIdx) {
 	const classes = [];
@@ -1606,7 +1951,7 @@ function parseSelectors(input, startIdx) {
 		while (i < input.length) if (/[a-zA-Z0-9_-]/.test(input[i])) {
 			name += input[i];
 			i++;
-		} else if (input[i] === "{" && SIGIL_CHARS.has(input[i + 1])) {
+		} else if (input[i] === "{" && isSigil(input[i + 1])) {
 			const braceStart = i;
 			i += 2;
 			while (i < input.length && /[\w.]/.test(input[i])) i++;
@@ -1621,10 +1966,13 @@ function parseSelectors(input, startIdx) {
 		if (name) if (prefix === ".") classes.push(name);
 		else id = name;
 	}
+	if (i > startIdx && input[i] === " ") i++;
 	return {
-		className: classes.join(" "),
-		id,
-		endIdx: i
+		selectors: withSelectors({}, {
+			className: classes.join(" "),
+			id
+		}),
+		end: i
 	};
 }
 /**
@@ -1739,7 +2087,7 @@ function scanQuotedValue(input, j, quote, code, memo) {
 			continue;
 		}
 		if (input[j] === "{") {
-			const closeIdx = !code ? scanBlockClose(input, j, memo) : SIGIL_CHARS.has(input[j + 1]) ? scanBalancedBrace(input, j + 1, memo) : -1;
+			const closeIdx = !code ? scanBlockClose(input, j, memo) : isSigil(input[j + 1]) ? scanBalancedBrace(input, j + 1, memo) : -1;
 			if (closeIdx !== -1) {
 				j = closeIdx + 1;
 				checkpoint = true;
@@ -1815,12 +2163,7 @@ function scanMacroClose(input, contentStart, memo) {
 * code from just past the {. Returns -1 if it is unclosed.
 */
 function scanBlockClose(input, open, memo) {
-	let at = open + 1;
-	const c = input[at];
-	if (c === "." || c === "#") {
-		at = parseSelectors(input, at).endIdx;
-		if (input[at] === " ") at++;
-	}
+	const at = parseSelectors(input, open + 1).end;
 	const first = input[at];
 	if (first !== void 0 && (first === "/" || /[a-zA-Z]/.test(first))) return scanMacroClose(input, at, memo);
 	return scanBalancedBrace(input, at, memo);
@@ -2012,13 +2355,22 @@ function tokenize(input, options = {}) {
 	const memo = createScanMemo();
 	let i = 0;
 	let textStart = 0;
+	/** Push a text token for the text not yet tokenized before `end`. */
 	function flushText(end) {
-		if (end > textStart) tokens.push({
-			type: "text",
-			value: input.slice(textStart, end),
-			start: textStart,
-			end
-		});
+		if (end > textStart) {
+			tokens.push({
+				type: "text",
+				value: input.slice(textStart, end),
+				start: textStart,
+				end
+			});
+			textStart = end;
+		}
+	}
+	/** Push `token` and go on after it. */
+	function emit(token) {
+		tokens.push(token);
+		i = textStart = token.end;
 	}
 	/**
 	* After an opening raw-body macro ({do}), emit everything up to its
@@ -2060,34 +2412,66 @@ function tokenize(input, options = {}) {
 		atRe.lastIndex = closeStart;
 		const closeEnd = closeStart + atRe.exec(input)[0].length;
 		flushText(closeStart);
-		tokens.push({
+		emit({
 			type: "macro",
 			...parseMacroContent(input.slice(closeStart + 1, closeEnd - 1)),
 			start: closeStart,
 			end: closeEnd
 		});
-		i = closeEnd;
-		textStart = closeEnd;
 	}
 	/**
-	* Push an expression token for the `{…}` block opened at `start` whose
-	* expression starts at `exprStart`, flushing the text before it first
-	* when `flush`. Returns false, consuming nothing, if the block is unclosed.
+	* Push an expression token for the `{…}` block opened at `start` whose
+	* expression starts at `exprStart`, flushing the text before it first.
+	* Returns false, consuming nothing, if the block is unclosed.
+	*/
+	function pushExpression(exprStart, start, selectors) {
+		const closeIdx = scanBalancedBrace(input, exprStart, memo);
+		if (closeIdx === -1) return false;
+		flushText(start);
+		emit(withSelectors({
+			type: "expression",
+			expression: input.slice(exprStart, closeIdx),
+			start,
+			end: closeIdx + 1
+		}, selectors));
+		return true;
+	}
+	/**
+	* Push a variable token for the `{…}` block opened at `start` whose sigil
+	* is at `sigilAt`: `{$name}`, `{_name.field.subfield}`. Anything else
+	* after the name makes the block an expression from the sigil on
+	* (`{$expr[...]}`). Returns false, consuming nothing, if it is unclosed.
+	*/
+	function pushVariable(sigilAt, start, selectors) {
+		let nameEnd = sigilAt + 1;
+		while (nameEnd < input.length && /[\w.]/.test(input[nameEnd])) nameEnd++;
+		if (input[nameEnd] !== "}") return pushExpression(sigilAt, start, selectors);
+		emit(withSelectors({
+			type: "variable",
+			name: input.slice(sigilAt + 1, nameEnd),
+			scope: SIGIL_SCOPES[input[sigilAt]],
+			start,
+			end: nameEnd + 1
+		}, selectors));
+		return true;
+	}
+	/**
+	* Push a macro token for the `{…}` block opened at `start` whose content
+	* (name, then arguments) starts at `contentStart`, then consume the body
+	* of a raw-body macro. Returns false, consuming nothing, if the block is
+	* unclosed.
 	*/
-	function pushExpression(exprStart, start, flush, className, id) {
-		const closeIdx = scanBalancedBrace(input, exprStart, memo);
+	function pushMacro(contentStart, start, selectors) {
+		const closeIdx = scanMacroClose(input, contentStart, memo);
 		if (closeIdx === -1) return false;
-		if (flush) flushText(start);
-		const token = {
-			type: "expression",
-			expression: input.slice(exprStart, closeIdx),
+		const token = withSelectors({
+			type: "macro",
+			...parseMacroContent(input.slice(contentStart, closeIdx)),
 			start,
 			end: closeIdx + 1
-		};
-		if (className) token.className = className;
-		if (id) token.id = id;
-		tokens.push(token);
-		i = textStart = closeIdx + 1;
+		}, selectors);
+		emit(token);
+		consumeRawBody(token.name, token.isClose);
 		return true;
 	}
 	while (i < input.length) {
@@ -2111,14 +2495,12 @@ function tokenize(input, options = {}) {
 			}
 			if ((next === "{" || next === "}") && (k - i) % 2 === 1) {
 				flushText(k - 1);
-				tokens.push({
+				emit({
 					type: "text",
 					value: next,
 					start: k - 1,
 					end: k + 1
 				});
-				i = k + 1;
-				textStart = i;
 				continue;
 			}
 			i = k;
@@ -2127,413 +2509,36 @@ function tokenize(input, options = {}) {
 		if (!textMode && input[i] === "[" && input[i + 1] === "[") {
 			flushText(i);
 			const start = i;
-			i += 2;
-			let className;
-			let id;
-			if (input[i] === "." || input[i] === "#") {
-				const parsed = parseSelectors(input, i);
-				className = parsed.className || void 0;
-				id = parsed.id || void 0;
-				i = parsed.endIdx;
-				if (input[i] === " ") i++;
-			}
-			const innerStart = i;
+			const { selectors, end: innerStart } = parseSelectors(input, i + 2);
 			const closeIdx = scanLinkClose(input, innerStart, memo);
 			if (closeIdx === -1) {
 				i = start + 2;
-				textStart = start;
 				continue;
 			}
-			const inner = input.slice(innerStart, closeIdx);
-			i = closeIdx + 2;
-			const { display, target } = parseLink(inner);
-			const linkToken = {
+			emit(withSelectors({
 				type: "link",
-				display,
-				target,
+				...parseLink(input.slice(innerStart, closeIdx)),
 				start,
-				end: i
-			};
-			if (className) linkToken.className = className;
-			if (id) linkToken.id = id;
-			tokens.push(linkToken);
-			textStart = i;
+				end: closeIdx + 2
+			}, selectors));
 			continue;
 		}
 		if (input[i] === "{") {
 			const start = i;
-			let nextChar = input[i + 1];
-			let className;
-			let id;
-			if (nextChar === "." || nextChar === "#") {
-				flushText(i);
-				const parsed = parseSelectors(input, i + 1);
-				className = parsed.className || void 0;
-				id = parsed.id || void 0;
-				let afterSelectors = parsed.endIdx;
-				if (input[afterSelectors] === " ") afterSelectors++;
-				const charAfter = input[afterSelectors];
-				if (charAfter === "$") {
-					i = afterSelectors + 1;
-					const nameStart = i;
-					while (i < input.length && /[\w.]/.test(input[i])) i++;
-					const name = input.slice(nameStart, i);
-					if (input[i] === "}") {
-						i++;
-						const token = {
-							type: "variable",
-							name,
-							scope: "variable",
-							start,
-							end: i
-						};
-						if (className) token.className = className;
-						if (id) token.id = id;
-						tokens.push(token);
-						textStart = i;
-						continue;
-					}
-					const closeIdx$ = scanBalancedBrace(input, nameStart - 1, memo);
-					if (closeIdx$ !== -1) {
-						const expression = input.slice(afterSelectors, closeIdx$);
-						i = closeIdx$ + 1;
-						const token = {
-							type: "expression",
-							expression,
-							start,
-							end: i
-						};
-						if (className) token.className = className;
-						if (id) token.id = id;
-						tokens.push(token);
-						textStart = i;
-						continue;
-					}
-					i = start + 1;
-					textStart = start;
-					continue;
-				}
-				if (charAfter === "_") {
-					i = afterSelectors + 1;
-					const nameStart = i;
-					while (i < input.length && /[\w.]/.test(input[i])) i++;
-					const name = input.slice(nameStart, i);
-					if (input[i] === "}") {
-						i++;
-						const token = {
-							type: "variable",
-							name,
-							scope: "temporary",
-							start,
-							end: i
-						};
-						if (className) token.className = className;
-						if (id) token.id = id;
-						tokens.push(token);
-						textStart = i;
-						continue;
-					}
-					const closeIdx_ = scanBalancedBrace(input, nameStart - 1, memo);
-					if (closeIdx_ !== -1) {
-						const expression = input.slice(afterSelectors, closeIdx_);
-						i = closeIdx_ + 1;
-						const token = {
-							type: "expression",
-							expression,
-							start,
-							end: i
-						};
-						if (className) token.className = className;
-						if (id) token.id = id;
-						tokens.push(token);
-						textStart = i;
-						continue;
-					}
-					i = start + 1;
-					textStart = start;
-					continue;
-				}
-				if (charAfter === "@") {
-					i = afterSelectors + 1;
-					const nameStart = i;
-					while (i < input.length && /[\w.]/.test(input[i])) i++;
-					const name = input.slice(nameStart, i);
-					if (input[i] === "}") {
-						i++;
-						const token = {
-							type: "variable",
-							name,
-							scope: "local",
-							start,
-							end: i
-						};
-						if (className) token.className = className;
-						if (id) token.id = id;
-						tokens.push(token);
-						textStart = i;
-						continue;
-					}
-					const closeIdx_at = scanBalancedBrace(input, nameStart - 1, memo);
-					if (closeIdx_at !== -1) {
-						const expression = input.slice(afterSelectors, closeIdx_at);
-						i = closeIdx_at + 1;
-						const token = {
-							type: "expression",
-							expression,
-							start,
-							end: i
-						};
-						if (className) token.className = className;
-						if (id) token.id = id;
-						tokens.push(token);
-						textStart = i;
-						continue;
-					}
-					i = start + 1;
-					textStart = start;
-					continue;
-				}
-				if (charAfter === "%") {
-					i = afterSelectors + 1;
-					const nameStart = i;
-					while (i < input.length && /[\w.]/.test(input[i])) i++;
-					const name = input.slice(nameStart, i);
-					if (input[i] === "}") {
-						i++;
-						const token = {
-							type: "variable",
-							name,
-							scope: "transient",
-							start,
-							end: i
-						};
-						if (className) token.className = className;
-						if (id) token.id = id;
-						tokens.push(token);
-						textStart = i;
-						continue;
-					}
-					const closeIdx_pct = scanBalancedBrace(input, nameStart - 1, memo);
-					if (closeIdx_pct !== -1) {
-						const expression = input.slice(afterSelectors, closeIdx_pct);
-						i = closeIdx_pct + 1;
-						const token = {
-							type: "expression",
-							expression,
-							start,
-							end: i
-						};
-						if (className) token.className = className;
-						if (id) token.id = id;
-						tokens.push(token);
-						textStart = i;
-						continue;
-					}
-					i = start + 1;
-					textStart = start;
-					continue;
-				}
-				if (EXPRESSION_START.has(charAfter) && pushExpression(afterSelectors, start, false, className, id)) continue;
-				if (charAfter !== void 0 && /[a-zA-Z]/.test(charAfter)) {
-					const contentStart = afterSelectors;
-					const closeIdx = scanMacroClose(input, contentStart, memo);
-					if (closeIdx === -1) {
-						i = start + 1;
-						textStart = start;
-						continue;
-					}
-					const content = input.slice(contentStart, closeIdx);
-					i = closeIdx + 1;
-					const { name, rawArgs, isClose } = parseMacroContent(content);
-					const token = {
-						type: "macro",
-						name,
-						rawArgs,
-						isClose,
-						start,
-						end: i
-					};
-					if (className) token.className = className;
-					if (id) token.id = id;
-					tokens.push(token);
-					textStart = i;
-					consumeRawBody(name, isClose);
-					continue;
-				}
-				i = start + 1;
-				textStart = start;
-				continue;
-			}
-			if (nextChar === "$") {
-				flushText(i);
-				i += 2;
-				const nameStart = i;
-				while (i < input.length && /[\w.]/.test(input[i])) i++;
-				const name = input.slice(nameStart, i);
-				if (input[i] === "}") {
-					i++;
-					tokens.push({
-						type: "variable",
-						name,
-						scope: "variable",
-						start,
-						end: i
-					});
-					textStart = i;
-					continue;
-				}
-				const closeIdx = scanBalancedBrace(input, nameStart - 1, memo);
-				if (closeIdx !== -1) {
-					const expression = input.slice(start + 1, closeIdx);
-					i = closeIdx + 1;
-					tokens.push({
-						type: "expression",
-						expression,
-						start,
-						end: i
-					});
-					textStart = i;
-					continue;
-				}
-				i = start + 1;
-				textStart = start;
-				continue;
-			}
-			if (nextChar === "_") {
-				flushText(i);
-				i += 2;
-				const nameStart = i;
-				while (i < input.length && /[\w.]/.test(input[i])) i++;
-				const name = input.slice(nameStart, i);
-				if (input[i] === "}") {
-					i++;
-					tokens.push({
-						type: "variable",
-						name,
-						scope: "temporary",
-						start,
-						end: i
-					});
-					textStart = i;
-					continue;
-				}
-				const closeIdx = scanBalancedBrace(input, nameStart - 1, memo);
-				if (closeIdx !== -1) {
-					const expression = input.slice(start + 1, closeIdx);
-					i = closeIdx + 1;
-					tokens.push({
-						type: "expression",
-						expression,
-						start,
-						end: i
-					});
-					textStart = i;
-					continue;
-				}
-				i = start + 1;
-				textStart = start;
-				continue;
-			}
-			if (nextChar === "@") {
-				flushText(i);
-				i += 2;
-				const nameStart = i;
-				while (i < input.length && /[\w.]/.test(input[i])) i++;
-				const name = input.slice(nameStart, i);
-				if (input[i] === "}") {
-					i++;
-					tokens.push({
-						type: "variable",
-						name,
-						scope: "local",
-						start,
-						end: i
-					});
-					textStart = i;
-					continue;
-				}
-				const closeIdx = scanBalancedBrace(input, nameStart - 1, memo);
-				if (closeIdx !== -1) {
-					const expression = input.slice(start + 1, closeIdx);
-					i = closeIdx + 1;
-					tokens.push({
-						type: "expression",
-						expression,
-						start,
-						end: i
-					});
-					textStart = i;
-					continue;
-				}
-				i = start + 1;
-				textStart = start;
-				continue;
-			}
-			if (nextChar === "%") {
-				flushText(i);
-				i += 2;
-				const nameStart = i;
-				while (i < input.length && /[\w.]/.test(input[i])) i++;
-				const name = input.slice(nameStart, i);
-				if (input[i] === "}") {
-					i++;
-					tokens.push({
-						type: "variable",
-						name,
-						scope: "transient",
-						start,
-						end: i
-					});
-					textStart = i;
-					continue;
-				}
-				const closeIdx = scanBalancedBrace(input, nameStart - 1, memo);
-				if (closeIdx !== -1) {
-					const expression = input.slice(start + 1, closeIdx);
-					i = closeIdx + 1;
-					tokens.push({
-						type: "expression",
-						expression,
-						start,
-						end: i
-					});
-					textStart = i;
-					continue;
-				}
-				i = start + 1;
-				textStart = start;
-				continue;
-			}
-			if (EXPRESSION_START.has(nextChar)) {
-				if (pushExpression(i + 1, start, true)) continue;
-				i++;
-				continue;
-			}
-			if (nextChar !== void 0 && (nextChar === "/" || /[a-zA-Z]/.test(nextChar))) {
-				flushText(i);
-				const contentStart = i + 1;
-				const closeIdx = scanMacroClose(input, contentStart, memo);
-				if (closeIdx === -1) {
-					i = start + 1;
-					textStart = start;
-					continue;
-				}
-				const content = input.slice(contentStart, closeIdx);
-				i = closeIdx + 1;
-				const { name, rawArgs, isClose } = parseMacroContent(content);
-				tokens.push({
-					type: "macro",
-					name,
-					rawArgs,
-					isClose,
-					start,
-					end: i
-				});
-				textStart = i;
-				consumeRawBody(name, isClose);
-				continue;
+			const { selectors, end: at } = parseSelectors(input, i + 1);
+			const prefixed = at > i + 1;
+			if (prefixed) flushText(start);
+			const c = input[at];
+			if (isSigil(c)) {
+				flushText(start);
+				if (pushVariable(at, start, selectors)) continue;
+			} else if (EXPRESSION_START.has(c)) {
+				if (pushExpression(at, start, selectors)) continue;
+			} else if (c !== void 0 && (/[a-zA-Z]/.test(c) || c === "/" && !prefixed)) {
+				flushText(start);
+				if (pushMacro(at, start, selectors)) continue;
 			}
-			i++;
+			i = start + 1;
 			continue;
 		}
 		if (!textMode && input[i] === "<") {
@@ -2551,11 +2556,10 @@ function tokenize(input, options = {}) {
 					j++;
 					flushText(start);
 					if (HTML_VOID_TAGS.has(tagLower)) {
-						textStart = j;
-						i = j;
+						i = textStart = j;
 						continue;
 					}
-					tokens.push({
+					emit({
 						type: "html",
 						tag,
 						attributes: {},
@@ -2564,8 +2568,6 @@ function tokenize(input, options = {}) {
 						start,
 						end: j
 					});
-					textStart = j;
-					i = j;
 					continue;
 				}
 			} else {
@@ -2579,7 +2581,7 @@ function tokenize(input, options = {}) {
 				if (input[j] === ">") {
 					j++;
 					flushText(start);
-					tokens.push({
+					emit({
 						type: "html",
 						tag,
 						attributes: parseHtmlAttributes(input, attrsStart, memo).attributes,
@@ -2588,8 +2590,6 @@ function tokenize(input, options = {}) {
 						start,
 						end: j
 					});
-					textStart = j;
-					i = j;
 					continue;
 				}
 			}
@@ -2645,6 +2645,21 @@ var BRANCHING_BLOCK_MACROS = new Set([
 function quoteArg(value) {
 	return `"${value.replace(/[\\"]/g, "\\$&")}"`;
 }
+/** A new branch for the macro token opening it, with its selectors. */
+function newBranch(token) {
+	return withSelectors({
+		rawArgs: token.rawArgs,
+		children: []
+	}, token);
+}
+/** The name of a macro or HTML element. */
+function tagName(tagged) {
+	return tagged.type === "html" ? tagged.tag : tagged.name;
+}
+/** The tag closing a macro or HTML element, as written in markup. */
+function closerOf(tagged) {
+	return tagged.type === "html" ? `</${tagged.tag}>` : `{/${tagged.name}}`;
+}
 /**
 * Build an AST from a token array. Block macros are nested into trees
 * using a stack. Throws on unclosed or mismatched macros.
@@ -2658,6 +2673,18 @@ function buildAST(tokens) {
 		if (top.type === "macro" && top.branches && top.branches.length > 0) return top.branches[top.branches.length - 1].children;
 		return top.children;
 	}
+	/**
+	* Pop the node on top of the stack, which the closing `token` (`</b>`,
+	* `{/if}`) must close. Names match ignoring case.
+	*/
+	function close(token) {
+		const found = closerOf(token);
+		if (stack.length === 0) throw new Error(`Unexpected closing ${found} (at character ${token.start})`);
+		const top = stack[stack.length - 1];
+		if (top.node.type !== token.type || tagName(top.node).toLowerCase() !== tagName(token).toLowerCase()) throw new Error(`Expected ${closerOf(top.node)} but found ${found} (at character ${token.start})`);
+		stack.pop();
+		current().push(top.node);
+	}
 	for (const token of tokens) switch (token.type) {
 		case "text":
 			current().push({
@@ -2666,133 +2693,72 @@ function buildAST(tokens) {
 			});
 			break;
 		case "link": {
-			const macroNode = {
+			const rawArgs = `${quoteArg(token.display)} ${quoteArg(token.target)}`;
+			current().push(withSelectors({
 				type: "macro",
 				name: "link",
-				rawArgs: `${quoteArg(token.display)} ${quoteArg(token.target)}`,
+				rawArgs,
 				children: []
-			};
-			if (token.className) macroNode.className = token.className;
-			if (token.id) macroNode.id = token.id;
-			current().push(macroNode);
+			}, token));
 			break;
 		}
-		case "variable": {
-			const varNode = {
+		case "variable":
+			current().push(withSelectors({
 				type: "variable",
 				name: token.name,
 				scope: token.scope
-			};
-			if (token.className) varNode.className = token.className;
-			if (token.id) varNode.id = token.id;
-			current().push(varNode);
+			}, token));
 			break;
-		}
-		case "expression": {
-			const exprNode = {
+		case "expression":
+			current().push(withSelectors({
 				type: "expression",
 				expression: token.expression
-			};
-			if (token.className) exprNode.className = token.className;
-			if (token.id) exprNode.id = token.id;
-			current().push(exprNode);
+			}, token));
 			break;
-		}
 		case "html": {
-			if (token.isSelfClose) {
-				current().push({
-					type: "html",
-					tag: token.tag,
-					attributes: token.attributes,
-					children: []
-				});
-				break;
-			}
-			if (token.isClose) {
-				if (stack.length === 0) throw new Error(`Unexpected closing </${token.tag}> (at character ${token.start})`);
-				const top = stack[stack.length - 1];
-				if (top.node.type !== "html" || top.node.tag.toLowerCase() !== token.tag.toLowerCase()) {
-					const expected = top.node.type === "html" ? `</${top.node.tag}>` : `{/${top.node.name}}`;
-					throw new Error(`Expected ${expected} but found </${token.tag}> (at character ${token.start})`);
-				}
-				stack.pop();
-				current().push(top.node);
-				break;
-			}
 			const htmlNode = {
 				type: "html",
 				tag: token.tag,
 				attributes: token.attributes,
 				children: []
 			};
-			stack.push({
+			if (token.isSelfClose) current().push(htmlNode);
+			else if (token.isClose) close(token);
+			else stack.push({
 				node: htmlNode,
 				start: token.start
 			});
 			break;
 		}
 		case "macro": {
-			const name = token.name.toLowerCase();
 			if (token.isClose) {
-				if (stack.length === 0) throw new Error(`Unexpected closing {/${token.name}} (at character ${token.start})`);
-				const top = stack[stack.length - 1];
-				if (top.node.type !== "macro" || top.node.name !== name) {
-					const expected = top.node.type === "macro" ? `{/${top.node.name}}` : `</${top.node.tag}>`;
-					throw new Error(`Expected ${expected} but found {/${token.name}} (at character ${token.start})`);
-				}
-				stack.pop();
-				current().push(top.node);
+				close(token);
 				break;
 			}
+			const name = token.name.toLowerCase();
 			const expectedParent = Object.prototype.hasOwnProperty.call(BRANCH_PARENT, name) ? BRANCH_PARENT[name] : void 0;
 			if (expectedParent) {
 				const topNode = stack.length > 0 ? stack[stack.length - 1].node : null;
 				if (!topNode || topNode.type !== "macro" || topNode.name !== expectedParent) throw new Error(`{${token.name}} without matching {${expectedParent}} (at character ${token.start})`);
-				const branch = {
-					rawArgs: token.rawArgs,
-					children: []
-				};
-				if (token.className) branch.className = token.className;
-				if (token.id) branch.id = token.id;
-				topNode.branches.push(branch);
+				topNode.branches.push(newBranch(token));
 				break;
 			}
-			if (BLOCK_MACROS.has(name)) {
-				const node = {
-					type: "macro",
-					name,
-					rawArgs: token.rawArgs,
-					children: []
-				};
-				if (BRANCHING_BLOCK_MACROS.has(name)) {
-					const firstBranch = {
-						rawArgs: token.rawArgs,
-						children: []
-					};
-					if (token.className) firstBranch.className = token.className;
-					if (token.id) firstBranch.id = token.id;
-					node.branches = [firstBranch];
-				} else {
-					if (token.className) node.className = token.className;
-					if (token.id) node.id = token.id;
-				}
-				stack.push({
-					node,
-					start: token.start
-				});
+			const node = {
+				type: "macro",
+				name,
+				rawArgs: token.rawArgs,
+				children: []
+			};
+			if (!BLOCK_MACROS.has(name)) {
+				current().push(withSelectors(node, token));
 				break;
 			}
-			{
-				const macroNode = {
-					type: "macro",
-					name,
-					rawArgs: token.rawArgs,
-					children: []
-				};
-				if (token.className) macroNode.className = token.className;
-				if (token.id) macroNode.id = token.id;
-				current().push(macroNode);
-			}
+			if (BRANCHING_BLOCK_MACROS.has(name)) node.branches = [newBranch(token)];
+			else withSelectors(node, token);
+			stack.push({
+				node,
+				start: token.start
+			});
 			break;
 		}
 		default: throw new Error(`Unknown token type: ${token.type}`);
@@ -2967,76 +2933,6 @@ function getPRNGPull() {
 	return currentPull;
 }
 //#endregion
-//#region src/utils/namespace.ts
-/** The variable name no namespace can hold. */
-var RESERVED_NAME = "__proto__";
-/**
-* Why `name` (without its sigil) cannot be a variable name, or undefined if
-* it can. `label` is the name as the author wrote it (e.g. `$__proto__`).
-*/
-function variableNameError(name, label = name) {
-	return name === "__proto__" ? `"${label}" cannot be used as a variable name (${RESERVED_NAME} is reserved)` : void 0;
-}
-/** Throw a TypeError if `name` cannot be a variable name. */
-function checkVariableName(name, label = name) {
-	const error = variableNameError(name, label);
-	if (error) throw new TypeError(`spindle: ${error}`);
-}
-/** Whether `obj` holds `key` as an own property. */
-var hasOwn$2 = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-/** `ns[key]` if `ns` holds it as an own property, else undefined. */
-var ownValue = (ns, key) => ns && hasOwn$2(ns, key) ? ns[key] : void 0;
-/**
-* A record with no prototype holding the own entries of `sources`, or only
-* those whose value passes `keep`.
-*/
-function ownEntries(sources, keep = () => true) {
-	const record = Object.create(null);
-	for (const source of sources) {
-		if (!source) continue;
-		for (const key of Object.keys(source)) {
-			const value = source[key];
-			if (keep(value)) record[key] = value;
-		}
-	}
-	return record;
-}
-/** A namespace with no prototype holding the own entries of `sources`. */
-var createNamespace = (...sources) => ownEntries(sources);
-/** Whether `value` is an object with no prototype. */
-var isNamespace = (value) => Object.getPrototypeOf(value) === null;
-/** `ns` itself if it has no prototype, else a namespace copy of it. */
-var asNamespace = (ns) => isNamespace(ns) ? ns : createNamespace(ns);
-/** A namespace copy of `ns` with `key` set to `value`. */
-function withEntry(ns, key, value) {
-	const next = createNamespace(ns);
-	next[key] = value;
-	return next;
-}
-/** An empty namespace that cannot change. */
-var EMPTY_NAMESPACE = Object.freeze(createNamespace());
-/** The names whose own entries differ between `a` and `b`, `a`'s first. */
-function changedNames(a, b) {
-	return [...new Set([...Object.keys(a), ...Object.keys(b)])].filter((name) => ownValue(a, name) !== ownValue(b, name));
-}
-var isCount = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
-/** The count of `name` in `counts`: its own entry, or 0. */
-function countOf(counts, name) {
-	const value = ownValue(counts, name);
-	return isCount(value) ? value : 0;
-}
-/**
-* Counters with no prototype holding the own entries of `source` that are
-* counts, with `name` (if given) counted once more. Immer copies the
-* counters on every write anyway, so counting into a fresh copy costs no
-* more than counting in place.
-*/
-function createCounts(source, name) {
-	const counts = ownEntries([source], isCount);
-	if (name !== void 0) counts[name] = countOf(source, name) + 1;
-	return counts;
-}
-//#endregion
 //#region src/expression.ts
 var FN_CACHE_MAX = 500;
 var fnCache = /* @__PURE__ */ new Map();
@@ -3463,12 +3359,6 @@ var MAX_DEPTH = 100;
 function display(value) {
 	return value == null ? "" : String(value);
 }
-var KIND_SIGILS = {
-	variable: "$",
-	temporary: "_",
-	local: "@",
-	transient: "%"
-};
 /**
 * The value of a variable reference (`name` without its sigil, with an
 * optional dot path), as `{$name}` shows it in passage text (see
@@ -3478,7 +3368,7 @@ var KIND_SIGILS = {
 function resolveVariable(scope, kind, name) {
 	const parts = name.split(".");
 	const root = parts[0];
-	checkVariableName(root, KIND_SIGILS[kind] + root);
+	checkVariableName(root, SCOPE_SIGILS[kind] + root);
 	let value = ownValue(kind === "variable" ? scope.variables : kind === "temporary" ? scope.temporary : kind === "transient" ? scope.transient : scope.locals, root);
 	for (let i = 1; i < parts.length; i++) {
 		if (value == null) return void 0;
@@ -3528,7 +3418,7 @@ var TextEvaluator = class {
 			return display(resolveVariable(scope, kind, name));
 		} catch (error) {
 			this.errors.push({
-				macro: KIND_SIGILS[kind] + name,
+				macro: SCOPE_SIGILS[kind] + name,
 				error
 			});
 			return "";
@@ -3636,12 +3526,6 @@ function interpolateText(template, scope) {
 	};
 	return renderText(parsed.nodes, scope);
 }
-var SIGIL_KINDS = {
-	$: "variable",
-	_: "temporary",
-	"@": "local",
-	"%": "transient"
-};
 /**
 * Resolve the sigil references in the value of a code attribute (see
 * isCodeAttribute): `{$x}`, `{_x.y}`, `{$n + 1}`. Everything else, other
@@ -3654,7 +3538,7 @@ function interpolateCode(template, scope, decode) {
 	for (const part of splitSigilTemplate(template)) if ("text" in part) text += decode ? decode(part.text) : part.text;
 	else if ("verbatim" in part) text += part.verbatim;
 	else if (/^[$_@%][\w.]+$/.test(part.expr)) {
-		const kind = SIGIL_KINDS[part.expr[0]];
+		const kind = SIGIL_SCOPES[part.expr[0]];
 		try {
 			text += display(resolveVariable(scope, kind, part.expr.slice(1)));
 		} catch (error) {
@@ -4681,94 +4565,92 @@ function renderNodes(nodes, options) {
 }
 //#endregion
 //#region src/saves/storage.ts
-/**
-* In-memory storage. Like the other backends it stores copies: records and
-* values go in and come out cloned, so changing a record after storing it,
-* or one that was read, changes nothing stored.
-*/
-function createMemoryBackend() {
-	const copy = (value) => structuredClone(value);
-	const saves = /* @__PURE__ */ new Map();
-	const playthroughs = /* @__PURE__ */ new Map();
-	const meta = /* @__PURE__ */ new Map();
+/** A backend's tables, made by its `table` function. */
+function makeTables(table) {
 	return {
-		type: "memory",
-		async putSave(record) {
-			saves.set(record.meta.id, copy(record));
-		},
-		async getSave(id) {
-			const record = saves.get(id);
-			return record && copy(record);
-		},
-		async deleteSave(id) {
-			saves.delete(id);
-		},
-		async getSavesByIfid(ifid) {
-			return [...saves.values()].filter((s) => s.meta.ifid === ifid).map(copy);
-		},
-		async deleteSavesByIfid(ifid) {
-			for (const id of [...saves.keys()]) {
-				const s = saves.get(id);
-				if (s && s.meta.ifid === ifid) saves.delete(id);
-			}
-		},
-		async deleteSavesByPlaythrough(playthroughId) {
-			const deleted = [];
-			for (const id of [...saves.keys()]) {
-				const s = saves.get(id);
-				if (s && s.meta.playthroughId === playthroughId) {
-					saves.delete(id);
-					deleted.push(id);
-				}
-			}
-			return deleted;
-		},
-		async putPlaythrough(record) {
-			playthroughs.set(record.id, copy(record));
-		},
-		async getPlaythroughsByIfid(ifid) {
-			return [...playthroughs.values()].filter((p) => p.ifid === ifid).map(copy);
-		},
-		async deletePlaythroughsByIfid(ifid) {
-			for (const id of [...playthroughs.keys()]) {
-				const p = playthroughs.get(id);
-				if (p && p.ifid === ifid) playthroughs.delete(id);
-			}
-		},
-		async deletePlaythroughById(id) {
-			playthroughs.delete(id);
-		},
-		async getMeta(key) {
-			return copy(meta.get(key));
-		},
-		async setMeta(key, value) {
-			meta.set(key, copy(value));
-		},
-		async deleteMeta(key) {
-			meta.delete(key);
-		},
-		async deleteMetaByPrefix(prefix) {
-			for (const key of [...meta.keys()]) if (key.startsWith(prefix)) meta.delete(key);
-		},
-		async deleteMetaByIfid(ifid) {
-			for (const key of [...meta.keys()]) if (key.includes(ifid)) meta.delete(key);
+		saves: table("saves", {
+			ifid: (r) => r.meta.ifid,
+			playthroughId: (r) => r.meta.playthroughId
+		}),
+		playthroughs: table("playthroughs", { ifid: (r) => r.ifid }),
+		meta: table("meta", {})
+	};
+}
+function createBackend(type, { saves, playthroughs, meta }, destroy) {
+	/** Delete the records `field` finds, resolving to their keys. */
+	async function deleteFound(table, keyOf, field, value) {
+		const keys = (await table.find(field, value)).map(keyOf);
+		for (const key of keys) await table.delete(key);
+		return keys;
+	}
+	async function deleteMetaWhere(test) {
+		for (const key of await meta.keys()) if (test(key)) await meta.delete(key);
+	}
+	const saveId = (r) => r.meta.id;
+	const playthroughId = (r) => r.id;
+	return {
+		type,
+		putSave: (record) => saves.put(record.meta.id, record),
+		getSave: (id) => saves.get(id),
+		deleteSave: (id) => saves.delete(id),
+		getSavesByIfid: (ifid) => saves.find("ifid", ifid),
+		deleteSavesByIfid: async (ifid) => {
+			await deleteFound(saves, saveId, "ifid", ifid);
 		},
-		async getAllMetaKeys() {
-			return [...meta.keys()];
+		deleteSavesByPlaythrough: (id) => deleteFound(saves, saveId, "playthroughId", id),
+		putPlaythrough: (record) => playthroughs.put(record.id, record),
+		getPlaythroughsByIfid: (ifid) => playthroughs.find("ifid", ifid),
+		deletePlaythroughsByIfid: async (ifid) => {
+			await deleteFound(playthroughs, playthroughId, "ifid", ifid);
 		},
-		async destroy() {
-			saves.clear();
-			playthroughs.clear();
-			meta.clear();
-		}
+		deletePlaythroughById: (id) => playthroughs.delete(id),
+		getMeta: (key) => meta.get(key),
+		setMeta: (key, value) => meta.put(key, value),
+		deleteMeta: (key) => meta.delete(key),
+		deleteMetaByPrefix: (prefix) => deleteMetaWhere((key) => key.startsWith(prefix)),
+		deleteMetaByIfid: (ifid) => deleteMetaWhere((key) => key.includes(ifid)),
+		getAllMetaKeys: () => meta.keys(),
+		destroy
 	};
 }
-var LS_SAVE_PREFIX = "spindle.save.";
-var LS_PT_PREFIX = "spindle.pt.";
-var LS_META_PREFIX = "spindle.meta.";
-var LS_IDX_SAVES_PREFIX = "spindle.idx.saves.";
-var LS_IDX_PT_PREFIX = "spindle.idx.pt.";
-var LS_IDX_SAVES_PT_PREFIX = "spindle.idx.saves-pt.";
+/**
+* In-memory storage. Like the other backends it stores copies: records and
+* values go in and come out cloned, so changing a record after storing it,
+* or one that was read, changes nothing stored.
+*/
+function createMemoryBackend() {
+	const copy = (value) => structuredClone(value);
+	const maps = [];
+	function table(_name, indexes) {
+		const rows = /* @__PURE__ */ new Map();
+		maps.push(rows);
+		return {
+			get: async (key) => copy(rows.get(key)),
+			put: async (key, value) => {
+				rows.set(key, copy(value));
+			},
+			delete: async (key) => {
+				rows.delete(key);
+			},
+			find: async (field, value) => [...rows.values()].filter((r) => indexes[field](r) === value).map(copy),
+			keys: async () => [...rows.keys()]
+		};
+	}
+	return createBackend("memory", makeTables(table), async () => {
+		for (const rows of maps) rows.clear();
+	});
+}
+/** Key prefixes: of the records, and of each index's ID lists. */
+var LS_PREFIXES = {
+	saves: "spindle.save.",
+	playthroughs: "spindle.pt.",
+	meta: "spindle.meta."
+};
+var LS_INDEX_PREFIXES = {
+	"saves.ifid": "spindle.idx.saves.",
+	"saves.playthroughId": "spindle.idx.saves-pt.",
+	"playthroughs.ifid": "spindle.idx.pt."
+};
 function lsGet(key) {
 	const raw = localStorage.getItem(key);
 	if (raw === null) return void 0;
@@ -4794,107 +4676,55 @@ function lsIndexAdd(key, entry) {
 		lsSet(key, arr);
 	}
 }
+/** Remove an ID from an index; an index left empty is removed. */
 function lsIndexRemove(key, entry) {
-	lsSet(key, lsIndex(key).filter((e) => e !== entry));
+	const arr = lsIndex(key).filter((e) => e !== entry);
+	if (arr.length > 0) lsSet(key, arr);
+	else lsDel(key);
 }
+/** The keys of every stored item that start with `prefix`. */
+var lsKeys = (prefix) => Object.keys(localStorage).filter((key) => key.startsWith(prefix));
 function createLocalStorageBackend() {
-	return {
-		type: "localstorage",
-		async putSave(record) {
-			const id = record.meta.id;
-			const previous = lsGet(`${LS_SAVE_PREFIX}${id}`);
-			if (previous && previous.meta.playthroughId !== record.meta.playthroughId) lsIndexRemove(`${LS_IDX_SAVES_PT_PREFIX}${previous.meta.playthroughId}`, id);
-			lsSet(`${LS_SAVE_PREFIX}${id}`, record);
-			lsIndexAdd(`${LS_IDX_SAVES_PREFIX}${record.meta.ifid}`, id);
-			lsIndexAdd(`${LS_IDX_SAVES_PT_PREFIX}${record.meta.playthroughId}`, id);
-		},
-		async getSave(id) {
-			return lsGet(`${LS_SAVE_PREFIX}${id}`);
-		},
-		async deleteSave(id) {
-			const record = lsGet(`${LS_SAVE_PREFIX}${id}`);
-			if (record) {
-				lsIndexRemove(`${LS_IDX_SAVES_PREFIX}${record.meta.ifid}`, id);
-				lsIndexRemove(`${LS_IDX_SAVES_PT_PREFIX}${record.meta.playthroughId}`, id);
-			}
-			lsDel(`${LS_SAVE_PREFIX}${id}`);
-		},
-		async getSavesByIfid(ifid) {
-			const ids = lsIndex(`${LS_IDX_SAVES_PREFIX}${ifid}`);
-			const results = [];
-			for (const id of ids) {
-				const record = lsGet(`${LS_SAVE_PREFIX}${id}`);
-				if (record) results.push(record);
-			}
-			return results;
-		},
-		async deleteSavesByIfid(ifid) {
-			const ids = lsIndex(`${LS_IDX_SAVES_PREFIX}${ifid}`);
-			for (const id of ids) {
-				const record = lsGet(`${LS_SAVE_PREFIX}${id}`);
-				if (record) lsIndexRemove(`${LS_IDX_SAVES_PT_PREFIX}${record.meta.playthroughId}`, id);
-				lsDel(`${LS_SAVE_PREFIX}${id}`);
-			}
-			lsDel(`${LS_IDX_SAVES_PREFIX}${ifid}`);
-		},
-		async deleteSavesByPlaythrough(playthroughId) {
-			const ids = lsIndex(`${LS_IDX_SAVES_PT_PREFIX}${playthroughId}`);
-			for (const id of ids) {
-				const record = lsGet(`${LS_SAVE_PREFIX}${id}`);
-				if (record) lsIndexRemove(`${LS_IDX_SAVES_PREFIX}${record.meta.ifid}`, id);
-				lsDel(`${LS_SAVE_PREFIX}${id}`);
-			}
-			lsDel(`${LS_IDX_SAVES_PT_PREFIX}${playthroughId}`);
-			return ids;
-		},
-		async putPlaythrough(record) {
-			lsSet(`${LS_PT_PREFIX}${record.id}`, record);
-			lsIndexAdd(`${LS_IDX_PT_PREFIX}${record.ifid}`, record.id);
-		},
-		async getPlaythroughsByIfid(ifid) {
-			const ids = lsIndex(`${LS_IDX_PT_PREFIX}${ifid}`);
-			const results = [];
-			for (const id of ids) {
-				const record = lsGet(`${LS_PT_PREFIX}${id}`);
-				if (record) results.push(record);
-			}
-			return results;
-		},
-		async deletePlaythroughsByIfid(ifid) {
-			const ids = lsIndex(`${LS_IDX_PT_PREFIX}${ifid}`);
-			for (const id of ids) lsDel(`${LS_PT_PREFIX}${id}`);
-			lsDel(`${LS_IDX_PT_PREFIX}${ifid}`);
-		},
-		async deletePlaythroughById(id) {
-			const record = lsGet(`${LS_PT_PREFIX}${id}`);
-			if (record) lsIndexRemove(`${LS_IDX_PT_PREFIX}${record.ifid}`, id);
-			lsDel(`${LS_PT_PREFIX}${id}`);
-		},
-		async getMeta(key) {
-			return lsGet(`${LS_META_PREFIX}${key}`);
-		},
-		async setMeta(key, value) {
-			lsSet(`${LS_META_PREFIX}${key}`, value);
-		},
-		async deleteMeta(key) {
-			lsDel(`${LS_META_PREFIX}${key}`);
-		},
-		async deleteMetaByPrefix(prefix) {
-			const fullPrefix = `${LS_META_PREFIX}${prefix}`;
-			for (const key of Object.keys(localStorage)) if (key.startsWith(fullPrefix)) localStorage.removeItem(key);
-		},
-		async deleteMetaByIfid(ifid) {
-			for (const key of Object.keys(localStorage)) if (key.startsWith(LS_META_PREFIX) && key.includes(ifid)) localStorage.removeItem(key);
-		},
-		async getAllMetaKeys() {
-			const keys = [];
-			for (const key of Object.keys(localStorage)) if (key.startsWith(LS_META_PREFIX)) keys.push(key.slice(13));
-			return keys;
-		},
-		async destroy() {
-			for (const key of Object.keys(localStorage)) if (key.startsWith("spindle.")) localStorage.removeItem(key);
-		}
-	};
+	function table(name, fields) {
+		const prefix = LS_PREFIXES[name];
+		const indexes = Object.entries(fields).map(([field, read]) => ({
+			field,
+			read,
+			prefix: LS_INDEX_PREFIXES[`${name}.${field}`]
+		}));
+		/** The index lists `record` is in. */
+		const listsOf = (record) => indexes.map((index) => `${index.prefix}${index.read(record)}`);
+		return {
+			get: async (key) => lsGet(`${prefix}${key}`),
+			async put(key, value) {
+				const previous = lsGet(`${prefix}${key}`);
+				const lists = listsOf(value);
+				if (previous !== void 0) {
+					for (const list of listsOf(previous)) if (!lists.includes(list)) lsIndexRemove(list, key);
+				}
+				lsSet(`${prefix}${key}`, value);
+				for (const list of lists) lsIndexAdd(list, key);
+			},
+			async delete(key) {
+				const record = lsGet(`${prefix}${key}`);
+				if (record !== void 0) for (const list of listsOf(record)) lsIndexRemove(list, key);
+				lsDel(`${prefix}${key}`);
+			},
+			async find(field, value) {
+				const index = indexes.find((i) => i.field === field);
+				const results = [];
+				for (const id of lsIndex(`${index.prefix}${value}`)) {
+					const record = lsGet(`${prefix}${id}`);
+					if (record !== void 0) results.push(record);
+				}
+				return results;
+			},
+			keys: async () => lsKeys(prefix).map((key) => key.slice(prefix.length))
+		};
+	}
+	return createBackend("localstorage", makeTables(table), async () => {
+		for (const key of lsKeys("spindle.")) lsDel(key);
+	});
 }
 var IDB_DB_NAME = "spindle";
 var IDB_DB_VERSION = 1;
@@ -4919,95 +4749,51 @@ function createIDBBackend() {
 		});
 		return dbPromise;
 	}
-	function tx(storeName, mode) {
-		return openDB().then((db) => db.transaction(storeName, mode).objectStore(storeName));
-	}
 	function idbReq(req) {
 		return new Promise((resolve, reject) => {
 			req.onsuccess = () => resolve(req.result);
 			req.onerror = () => reject(req.error);
 		});
 	}
-	async function getAllFromIndex(storeName, indexName, value) {
-		return await idbReq((await tx(storeName, "readonly")).index(indexName).getAll(value)) ?? [];
+	/**
+	* An object store. Records hold their own key (keyPath); meta values are
+	* stored as `{ key, value }` rows.
+	*/
+	function table(name) {
+		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)));
+		};
+		return {
+			async get(key) {
+				const result = await request("readonly", (s) => s.get(key));
+				return rows ? result?.value : result;
+			},
+			async put(key, value) {
+				await request("readwrite", (s) => s.put(rows ? {
+					key,
+					value
+				} : value));
+			},
+			async delete(key) {
+				await request("readwrite", (s) => s.delete(key));
+			},
+			async find(field, value) {
+				return await request("readonly", (s) => s.index(field).getAll(value)) ?? [];
+			},
+			keys: async () => await request("readonly", (s) => s.getAllKeys())
+		};
 	}
-	return {
-		type: "indexeddb",
-		async putSave(record) {
-			await idbReq((await tx("saves", "readwrite")).put(record));
-		},
-		async getSave(id) {
-			return await idbReq((await tx("saves", "readonly")).get(id)) ?? void 0;
-		},
-		async deleteSave(id) {
-			await idbReq((await tx("saves", "readwrite")).delete(id));
-		},
-		async getSavesByIfid(ifid) {
-			return getAllFromIndex("saves", "ifid", ifid);
-		},
-		async deleteSavesByIfid(ifid) {
-			const records = await getAllFromIndex("saves", "ifid", ifid);
-			const store = await tx("saves", "readwrite");
-			for (const r of records) await idbReq(store.delete(r.meta.id));
-		},
-		async deleteSavesByPlaythrough(playthroughId) {
-			const records = await getAllFromIndex("saves", "playthroughId", playthroughId);
-			const store = await tx("saves", "readwrite");
-			const ids = [];
-			for (const r of records) {
-				await idbReq(store.delete(r.meta.id));
-				ids.push(r.meta.id);
-			}
-			return ids;
-		},
-		async putPlaythrough(record) {
-			await idbReq((await tx("playthroughs", "readwrite")).put(record));
-		},
-		async getPlaythroughsByIfid(ifid) {
-			return getAllFromIndex("playthroughs", "ifid", ifid);
-		},
-		async deletePlaythroughsByIfid(ifid) {
-			const records = await getAllFromIndex("playthroughs", "ifid", ifid);
-			const store = await tx("playthroughs", "readwrite");
-			for (const r of records) await idbReq(store.delete(r.id));
-		},
-		async deletePlaythroughById(id) {
-			await idbReq((await tx("playthroughs", "readwrite")).delete(id));
-		},
-		async getMeta(key) {
-			const row = await idbReq((await tx("meta", "readonly")).get(key));
-			return row ? row.value : void 0;
-		},
-		async setMeta(key, value) {
-			await idbReq((await tx("meta", "readwrite")).put({
-				key,
-				value
-			}));
-		},
-		async deleteMeta(key) {
-			await idbReq((await tx("meta", "readwrite")).delete(key));
-		},
-		async deleteMetaByPrefix(prefix) {
-			const allRows = await idbReq((await tx("meta", "readwrite")).getAll());
-			for (const row of allRows) if (row.key.startsWith(prefix)) await idbReq((await tx("meta", "readwrite")).delete(row.key));
-		},
-		async deleteMetaByIfid(ifid) {
-			const allRows = await idbReq((await tx("meta", "readwrite")).getAll());
-			for (const row of allRows) if (row.key.includes(ifid)) await idbReq((await tx("meta", "readwrite")).delete(row.key));
-		},
-		async getAllMetaKeys() {
-			return (await idbReq((await tx("meta", "readonly")).getAll())).map((r) => r.key);
-		},
-		async destroy() {
-			(await openDB()).close();
-			dbPromise = null;
-			await new Promise((resolve, reject) => {
-				const req = indexedDB.deleteDatabase(IDB_DB_NAME);
-				req.onsuccess = () => resolve();
-				req.onerror = () => reject(req.error);
-			});
-		}
-	};
+	return createBackend("indexeddb", makeTables(table), async () => {
+		(await openDB()).close();
+		dbPromise = null;
+		await new Promise((resolve, reject) => {
+			const req = indexedDB.deleteDatabase(IDB_DB_NAME);
+			req.onsuccess = () => resolve();
+			req.onerror = () => reject(req.error);
+		});
+	});
 }
 var _backend = null;
 async function detectBackend() {
@@ -5156,15 +4942,17 @@ function inOrder(op) {
 	operationQueue = run.catch(() => {});
 	return run;
 }
+/** `op` (a `...Now` helper) as an operation that queues itself. */
+function queued(op) {
+	return (...args) => inOrder(() => op(...args));
+}
 /**
 * Store a new playthrough and make it the story's current one. Pass `id` when
 * the caller has already switched to the playthrough (restart() does, so
 * saves issued before this resolves are tagged with it).
 */
-function startNewPlaythrough(ifid, id = crypto.randomUUID()) {
-	return inOrder(() => startNewPlaythroughNow(ifid, id));
-}
-async function startNewPlaythroughNow(ifid, id) {
+var startNewPlaythrough = queued(startNewPlaythroughNow);
+async function startNewPlaythroughNow(ifid, id = crypto.randomUUID()) {
 	const backend = await getBackend();
 	const num = await nextPlaythroughNumber(ifid);
 	const record = {
@@ -5209,19 +4997,26 @@ function currentPlaythroughKey(ifid) {
 * recorded again as "Imported", as importing the save would: it was not
 * started here, so it takes no number.
 */
-function adoptPlaythrough(ifid, id) {
-	return inOrder(() => adoptPlaythroughNow(ifid, id));
-}
+var adoptPlaythrough = queued(adoptPlaythroughNow);
 async function adoptPlaythroughNow(ifid, id) {
+	const backend = await getBackend();
+	await ensurePlaythrough(ifid, id, (/* @__PURE__ */ new Date()).toISOString());
+	const key = currentPlaythroughKey(ifid);
+	if (await backend.getMeta(key) !== id) await backend.setMeta(key, id);
+}
+/**
+* Record the playthrough `id` of the story as "Imported", created at
+* `createdAt`, unless it has a record: a playthrough not started here takes
+* no number.
+*/
+async function ensurePlaythrough(ifid, id, createdAt) {
 	const backend = await getBackend();
 	if (!(await backend.getPlaythroughsByIfid(ifid)).some((p) => p.id === id)) await backend.putPlaythrough({
 		id,
 		ifid,
-		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		createdAt,
 		label: "Imported"
 	});
-	const key = currentPlaythroughKey(ifid);
-	if (await backend.getMeta(key) !== id) await backend.setMeta(key, id);
 }
 /**
 * Set up the save system for a story that boots: the story's current
@@ -5231,7 +5026,7 @@ async function adoptPlaythroughNow(ifid, id) {
 function establishPlaythrough(ifid) {
 	return inOrder(async () => {
 		return {
-			id: await (await getBackend()).getMeta(currentPlaythroughKey(ifid)) ?? await startNewPlaythroughNow(ifid, crypto.randomUUID()),
+			id: await (await getBackend()).getMeta(currentPlaythroughKey(ifid)) ?? await startNewPlaythroughNow(ifid),
 			knownSaves: await populateKnownSavesNow(ifid)
 		};
 	});
@@ -5266,12 +5061,35 @@ function saveWithHooks(slot, custom, beginCapture, write) {
 		return Promise.reject(err);
 	}
 }
-function createSave(ifid, playthroughId, payload, custom = {}) {
-	return inOrder(() => createSaveNow(ifid, playthroughId, payload, custom));
+/**
+* `payload` with `convert` applied to its live variables and to those of
+* every history moment.
+*/
+function mapVariables(payload, convert) {
+	return {
+		...payload,
+		variables: convert(payload.variables),
+		history: payload.history.map((m) => ({
+			...m,
+			variables: convert(m.variables)
+		}))
+	};
+}
+/** The record to store for a save: `payload` serialized, and its size. */
+function storedRecord(meta, payload) {
+	const serialized = mapVariables(deepClone(payload), serialize);
+	return {
+		meta: {
+			...meta,
+			estimatedBytes: estimatePayloadBytes(serialized)
+		},
+		payload: serialized
+	};
 }
-async function createSaveNow(ifid, playthroughId, payload, custom) {
+var createSave = queued(createSaveNow);
+async function createSaveNow(ifid, playthroughId, payload, custom = {}) {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const meta = {
+	const record = storedRecord({
 		id: crypto.randomUUID(),
 		ifid,
 		playthroughId,
@@ -5280,18 +5098,7 @@ async function createSaveNow(ifid, playthroughId, payload, custom) {
 		title: generateTitle(payload),
 		passage: payload.passage,
 		custom
-	};
-	const serializedPayload = deepClone(payload);
-	serializedPayload.variables = serialize(serializedPayload.variables);
-	serializedPayload.history = serializedPayload.history.map((m) => ({
-		...m,
-		variables: serialize(m.variables)
-	}));
-	const record = {
-		meta,
-		payload: serializedPayload
-	};
-	record.meta.estimatedBytes = JSON.stringify(serializedPayload).length;
+	}, payload);
 	await (await getBackend()).putSave(record);
 	return record;
 }
@@ -5310,34 +5117,22 @@ async function createSaveNow(ifid, playthroughId, payload, custom) {
 * save itself rather than describing its content. `custom` is merged, as
 * before, so slot keys and metadata not passed again are kept.
 */
-function overwriteSave(saveId, payload, custom, playthroughId) {
-	return inOrder(() => overwriteSaveNow(saveId, payload, custom, playthroughId));
-}
+var overwriteSave = queued(overwriteSaveNow);
 async function overwriteSaveNow(saveId, payload, custom, playthroughId) {
 	const backend = await getBackend();
 	const existing = await backend.getSave(saveId);
 	if (!existing) return void 0;
-	const serializedPayload = deepClone(payload);
-	serializedPayload.variables = serialize(serializedPayload.variables);
-	serializedPayload.history = serializedPayload.history.map((m) => ({
-		...m,
-		variables: serialize(m.variables)
-	}));
-	const updated = {
-		meta: {
-			...existing.meta,
-			...playthroughId ? { playthroughId } : {},
-			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			title: existing.meta.userTitle === true ? existing.meta.title : generateTitle(payload),
-			passage: payload.passage,
-			...custom != null ? { custom: {
-				...existing.meta.custom,
-				...custom
-			} } : {}
-		},
-		payload: serializedPayload
-	};
-	updated.meta.estimatedBytes = JSON.stringify(serializedPayload).length;
+	const updated = storedRecord({
+		...existing.meta,
+		...playthroughId ? { playthroughId } : {},
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		title: existing.meta.userTitle === true ? existing.meta.title : generateTitle(payload),
+		passage: payload.passage,
+		...custom != null ? { custom: {
+			...existing.meta.custom,
+			...custom
+		} } : {}
+	}, payload);
 	await backend.putSave(updated);
 	return updated;
 }
@@ -5347,15 +5142,11 @@ async function overwriteSaveNow(saveId, payload, custom, playthroughId) {
 * untouched. Payloads handed to the store's `loadFromPayload()` must be live.
 */
 function deserializePayload(payload) {
-	return {
-		...payload,
-		variables: deserialize(payload.variables),
-		history: payload.history.map((m) => ({
-			...m,
-			variables: deserialize(m.variables)
-		}))
-	};
+	return mapVariables(payload, deserialize);
 }
+/** The live payload of a stored save, if there is one. */
+var livePayload = (record) => record && deserializePayload(record.payload);
+queued(async (saveId) => livePayload(await (await getBackend()).getSave(saveId)));
 /**
 * Delete a save record. If the default slot or a named slot holds it, that
 * slot is cleared as well (pointer and slot index), as `deleteSlotSave` would.
@@ -5366,14 +5157,7 @@ function deleteSaveById(saveId) {
 		const record = await backend.getSave(saveId);
 		await backend.deleteSave(saveId);
 		if (!record) return;
-		const ifid = record.meta.ifid;
-		const slots = [void 0, ...await getIndexedSlots(ifid)];
-		for (const slot of slots) {
-			const metaKey = slotMetaKey(ifid, slot);
-			if (await backend.getMeta(metaKey) !== saveId) continue;
-			await backend.deleteMeta(metaKey);
-			await removeFromSlotIndex(ifid, slot);
-		}
+		await emptySlotsHolding(record.meta.ifid, (id) => id === saveId);
 	});
 }
 function renameSave(saveId, newTitle) {
@@ -5393,10 +5177,7 @@ function renameSave(saveId, newTitle) {
 		await backend.putSave(updated);
 	});
 }
-function getSavesGrouped(ifid) {
-	return inOrder(() => getSavesGroupedNow(ifid));
-}
-async function getSavesGroupedNow(ifid) {
+var getSavesGrouped = queued(async function getSavesGroupedNow(ifid) {
 	const backend = await getBackend();
 	const [allSaves, allPlaythroughs] = await Promise.all([backend.getSavesByIfid(ifid), backend.getPlaythroughsByIfid(ifid)]);
 	const ptMap = /* @__PURE__ */ new Map();
@@ -5428,7 +5209,7 @@ async function getSavesGroupedNow(ifid) {
 		saves
 	});
 	return result;
-}
+});
 var AUTOSAVE_KEY_PREFIX = "autosave.";
 var SLOT_KEY_PREFIX = "slot.";
 var SLOT_INDEX_KEY_PREFIX = "slotIndex.";
@@ -5442,29 +5223,49 @@ function isNamedSlot(slot) {
 function slotMetaKey(ifid, slot) {
 	return isNamedSlot(slot) ? `${SLOT_KEY_PREFIX}${slot}.${ifid}` : `${AUTOSAVE_KEY_PREFIX}${ifid}`;
 }
+var slotIndexKey = (ifid) => `${SLOT_INDEX_KEY_PREFIX}${ifid}`;
 /** Read-modify-write the per-story slot index. */
 async function updateSlotIndex(ifid, update) {
 	const backend = await getBackend();
-	const indexKey = `${SLOT_INDEX_KEY_PREFIX}${ifid}`;
-	const existing = await backend.getMeta(indexKey) ?? [];
+	const existing = await backend.getMeta(slotIndexKey(ifid)) ?? [];
 	const updated = update(existing);
-	if (updated !== existing) await backend.setMeta(indexKey, updated);
-}
-/** Record a named slot in the per-story slot index (no-op for the default slot). */
-function addToSlotIndex(ifid, slot) {
-	if (!isNamedSlot(slot)) return Promise.resolve();
-	return updateSlotIndex(ifid, (slots) => slots.includes(slot) ? slots : [...slots, slot]);
-}
-/** Remove a named slot from the per-story slot index (no-op for the default slot). */
-function removeFromSlotIndex(ifid, slot) {
-	if (!isNamedSlot(slot)) return Promise.resolve();
-	return updateSlotIndex(ifid, (slots) => slots.filter((s) => s !== slot));
-}
-/** Named slots in the per-story slot index. */
-async function getIndexedSlots(ifid) {
-	const indexKey = `${SLOT_INDEX_KEY_PREFIX}${ifid}`;
-	return (await (await getBackend()).getMeta(indexKey) ?? []).filter(isNamedSlot);
-}
+	if (updated !== existing) await backend.setMeta(slotIndexKey(ifid), updated);
+}
+/** Every slot: the default one (undefined), then those in the slot index. */
+async function allSlots(ifid) {
+	return [void 0, ...(await (await getBackend()).getMeta(slotIndexKey(ifid)) ?? []).filter(isNamedSlot)];
+}
+/** The ID of the save a slot holds, if any. */
+async function slotSaveId(ifid, slot) {
+	return (await getBackend()).getMeta(slotMetaKey(ifid, slot));
+}
+/** The record of the save a slot holds, if there is one. */
+async function slotRecord(ifid, slot) {
+	const id = await slotSaveId(ifid, slot);
+	return id ? (await getBackend()).getSave(id) : void 0;
+}
+/** Make a slot hold the save `saveId`: its pointer, and the slot index. */
+async function fillSlot(ifid, slot, saveId) {
+	await (await getBackend()).setMeta(slotMetaKey(ifid, slot), saveId);
+	if (isNamedSlot(slot)) await updateSlotIndex(ifid, (slots) => slots.includes(slot) ? slots : [...slots, slot]);
+}
+/** Clear a slot: its pointer, and its entry in the slot index. */
+async function emptySlot(ifid, slot) {
+	await (await getBackend()).deleteMeta(slotMetaKey(ifid, slot));
+	if (isNamedSlot(slot)) await updateSlotIndex(ifid, (slots) => slots.filter((s) => s !== slot));
+}
+/** Clear every slot holding a save whose ID passes `test`. */
+async function emptySlotsHolding(ifid, test) {
+	for (const slot of await allSlots(ifid)) {
+		const id = await slotSaveId(ifid, slot);
+		if (id && test(id)) await emptySlot(ifid, slot);
+	}
+}
+/** The `custom` keys that say which slot a save lives in. */
+var slotCustom = (slot) => ({
+	isAutosave: !isNamedSlot(slot),
+	...isNamedSlot(slot) ? { slot } : {}
+});
 function toSaveInfo(record, slot) {
 	return {
 		slot: isNamedSlot(slot) ? slot : "",
@@ -5482,32 +5283,26 @@ function toSaveInfo(record, slot) {
 * place in the order of operations when it is called.
 */
 function quickSave(ifid, playthroughId, payload, slot, custom) {
-	const metaKey = slotMetaKey(ifid, slot);
 	return inOrder(async () => {
 		const ptId = await playthroughId;
-		const backend = await getBackend();
-		const existingId = await backend.getMeta(metaKey);
+		const existingId = await slotSaveId(ifid, slot);
 		if (existingId) {
 			const updated = await overwriteSaveNow(existingId, payload, custom, ptId);
 			if (updated) return updated;
 		}
 		const record = await createSaveNow(ifid, ptId, payload, {
-			isAutosave: !isNamedSlot(slot),
-			...isNamedSlot(slot) ? { slot } : {},
+			...slotCustom(slot),
 			...custom
 		});
-		await backend.setMeta(metaKey, record.meta.id);
-		await addToSlotIndex(ifid, slot);
+		await fillSlot(ifid, slot, record.meta.id);
 		return record;
 	});
 }
+queued(hasQuickSaveNow);
 async function hasQuickSaveNow(ifid, slot) {
-	const backend = await getBackend();
-	const metaKey = slotMetaKey(ifid, slot);
-	const existingId = await backend.getMeta(metaKey);
-	if (!existingId) return false;
-	return await backend.getSave(existingId) !== void 0;
+	return await slotRecord(ifid, slot) !== void 0;
 }
+queued(async (ifid, slot) => livePayload(await slotRecord(ifid, slot)));
 /**
 * Read the save held in a slot (the default slot when `slot` is omitted) for
 * the running game to load, and make its playthrough the story's current one
@@ -5516,12 +5311,8 @@ async function hasQuickSaveNow(ifid, slot) {
 * and its playthrough, or undefined if the slot is empty.
 */
 function loadSlotSave(ifid, slot) {
-	const metaKey = slotMetaKey(ifid, slot);
 	return inOrder(async () => {
-		const backend = await getBackend();
-		const existingId = await backend.getMeta(metaKey);
-		if (!existingId) return void 0;
-		const record = await backend.getSave(existingId);
+		const record = await slotRecord(ifid, slot);
 		if (!record) return void 0;
 		const payload = deserializePayload(record.payload);
 		const { playthroughId } = record.meta;
@@ -5536,60 +5327,41 @@ function loadSlotSave(ifid, slot) {
 * Check storage for all known saves and return a map of slot keys to true.
 * The default (autosave) slot uses empty string as key.
 */
-function populateKnownSaves(ifid) {
-	return inOrder(() => populateKnownSavesNow(ifid));
-}
+var populateKnownSaves = queued(populateKnownSavesNow);
 async function populateKnownSavesNow(ifid) {
 	const result = Object.create(null);
-	if (await hasQuickSaveNow(ifid)) result[""] = true;
-	for (const slot of await getIndexedSlots(ifid)) if (await hasQuickSaveNow(ifid, slot)) result[slot] = true;
+	for (const slot of await allSlots(ifid)) if (await hasQuickSaveNow(ifid, slot)) result[slot ?? ""] = true;
 	return result;
 }
 /**
 * Get metadata for a specific save slot.
 * Returns null if no save exists for that slot.
 */
-function getSlotSaveInfo(ifid, slot) {
-	return inOrder(() => getSlotSaveInfoNow(ifid, slot));
-}
+var getSlotSaveInfo = queued(getSlotSaveInfoNow);
 async function getSlotSaveInfoNow(ifid, slot) {
-	const backend = await getBackend();
-	const metaKey = slotMetaKey(ifid, slot);
-	const existingId = await backend.getMeta(metaKey);
-	if (!existingId) return null;
-	const record = await backend.getSave(existingId);
-	if (!record) return null;
-	return toSaveInfo(record, slot);
+	const record = await slotRecord(ifid, slot);
+	return record ? toSaveInfo(record, slot) : null;
 }
 /**
 * List metadata for all known save slots (default + named).
 */
-function listSlotSaves(ifid) {
-	return inOrder(async () => {
-		const result = [];
-		const defaultInfo = await getSlotSaveInfoNow(ifid);
-		if (defaultInfo) result.push(defaultInfo);
-		for (const slot of await getIndexedSlots(ifid)) {
-			const info = await getSlotSaveInfoNow(ifid, slot);
-			if (info) result.push(info);
-		}
-		return result;
-	});
-}
+var listSlotSaves = queued(async (ifid) => {
+	const result = [];
+	for (const slot of await allSlots(ifid)) {
+		const info = await getSlotSaveInfoNow(ifid, slot);
+		if (info) result.push(info);
+	}
+	return result;
+});
 /**
 * Delete a save by slot name. Removes from slot index if named.
 */
-function deleteSlotSave(ifid, slot) {
-	const metaKey = slotMetaKey(ifid, slot);
-	return inOrder(async () => {
-		const backend = await getBackend();
-		const existingId = await backend.getMeta(metaKey);
-		if (!existingId) return;
-		await backend.deleteSave(existingId);
-		await backend.deleteMeta(metaKey);
-		await removeFromSlotIndex(ifid, slot);
-	});
-}
+var deleteSlotSave = queued(async (ifid, slot) => {
+	const existingId = await slotSaveId(ifid, slot);
+	if (!existingId) return;
+	await (await getBackend()).deleteSave(existingId);
+	await emptySlot(ifid, slot);
+});
 var SESSION_KEY_PREFIX = "spindle.session.";
 /**
 * Write a pre-serialized session payload to sessionStorage.
@@ -5616,11 +5388,8 @@ function clearSession(ifid) {
 		sessionStorage.removeItem(`${SESSION_KEY_PREFIX}${ifid}`);
 	} catch {}
 }
-function exportSave(saveId) {
-	return inOrder(() => exportSaveNow(saveId));
-}
-async function exportSaveNow(saveId) {
-	const record = await (await getBackend()).getSave(saveId);
+/** The export of a stored save, if there is one. */
+function toExport(record) {
 	if (!record) return void 0;
 	return {
 		version: 1,
@@ -5629,6 +5398,7 @@ async function exportSaveNow(saveId) {
 		save: record
 	};
 }
+var exportSave = queued(async (saveId) => toExport(await (await getBackend()).getSave(saveId)));
 /**
 * Validate an export against the running story and build the record to store:
 * a fresh save ID, and the playthrough record created if it doesn't exist yet.
@@ -5638,20 +5408,11 @@ async function prepareImport(data, ifid) {
 	if (data.version !== 1) throw new Error(`Unsupported save version: ${data.version}`);
 	if (data.ifid !== ifid) throw new Error(`Save is from a different story (expected IFID ${ifid}, got ${data.ifid})`);
 	if (!isSaveExport(data)) throw new Error("Invalid save file format");
-	const backend = await getBackend();
 	const record = deepClone(data.save);
 	record.meta.id = crypto.randomUUID();
 	record.meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
 	record.meta.ifid = ifid;
-	if (!(await backend.getPlaythroughsByIfid(ifid)).some((p) => p.id === record.meta.playthroughId)) {
-		const pt = {
-			id: record.meta.playthroughId,
-			ifid,
-			createdAt: record.meta.createdAt,
-			label: "Imported"
-		};
-		await backend.putPlaythrough(pt);
-	}
+	await ensurePlaythrough(ifid, record.meta.playthroughId, record.meta.createdAt);
 	return record;
 }
 function importSave(data, ifid) {
@@ -5665,13 +5426,7 @@ function importSave(data, ifid) {
 * Export the save held in a slot (default autosave slot when `slot` is omitted).
 * Returns undefined if the slot is empty.
 */
-function exportSlotSave(ifid, slot) {
-	return inOrder(async () => {
-		const saveId = await (await getBackend()).getMeta(slotMetaKey(ifid, slot));
-		if (!saveId) return void 0;
-		return exportSaveNow(saveId);
-	});
-}
+var exportSlotSave = queued(async (ifid, slot) => toExport(await slotRecord(ifid, slot)));
 /**
 * Import an exported save into a slot (default autosave slot when `slot` is
 * omitted), replacing any save already in that slot. Applies the same
@@ -5679,35 +5434,29 @@ function exportSlotSave(ifid, slot) {
 * and slot index consistent.
 */
 function importSlotSave(data, ifid, slot) {
-	const metaKey = slotMetaKey(ifid, slot);
 	return inOrder(async () => {
 		const record = await prepareImport(data, ifid);
 		const { slot: _exportedSlot, ...custom } = record.meta.custom ?? {};
 		record.meta.custom = {
 			...custom,
-			isAutosave: !isNamedSlot(slot),
-			...isNamedSlot(slot) ? { slot } : {}
+			...slotCustom(slot)
 		};
 		const backend = await getBackend();
-		const previousId = await backend.getMeta(metaKey);
+		const previousId = await slotSaveId(ifid, slot);
 		await backend.putSave(record);
-		await backend.setMeta(metaKey, record.meta.id);
-		await addToSlotIndex(ifid, slot);
+		await fillSlot(ifid, slot, record.meta.id);
 		if (previousId) await backend.deleteSave(previousId);
 		return toSaveInfo(record, slot);
 	});
 }
-function getStorageInfo(ifid) {
-	return inOrder(() => getStorageInfoNow(ifid));
-}
-async function getStorageInfoNow(ifid) {
+var getStorageInfo = queued(async function getStorageInfoNow(ifid) {
 	const backend = await getBackend();
 	const saves = await backend.getSavesByIfid(ifid);
 	const playthroughs = await backend.getPlaythroughsByIfid(ifid);
 	let totalBytes = 0;
 	for (const save of saves) if (save.meta.estimatedBytes != null) totalBytes += save.meta.estimatedBytes;
 	else {
-		const bytes = JSON.stringify(save.payload).length;
+		const bytes = estimatePayloadBytes(save.payload);
 		save.meta.estimatedBytes = bytes;
 		await backend.putSave(save);
 		totalBytes += bytes;
@@ -5718,7 +5467,7 @@ async function getStorageInfoNow(ifid) {
 		totalBytes,
 		backend: backend.type
 	};
-}
+});
 function clearGameData(ifid) {
 	return inOrder(async () => {
 		const backend = await getBackend();
@@ -5728,9 +5477,7 @@ function clearGameData(ifid) {
 		clearSession(ifid);
 	});
 }
-function clearAllData() {
-	return inOrder(clearAllDataNow);
-}
+var clearAllData = queued(clearAllDataNow);
 async function clearAllDataNow() {
 	await (await getBackend()).destroy();
 	resetBackend();
@@ -5758,14 +5505,7 @@ function deletePlaythroughData(ifid, playthroughId, replacement) {
 		const deletedSaveIds = await backend.deleteSavesByPlaythrough(playthroughId);
 		await backend.deletePlaythroughById(playthroughId);
 		const deletedSet = new Set(deletedSaveIds);
-		for (const slot of [void 0, ...await getIndexedSlots(ifid)]) {
-			const metaKey = slotMetaKey(ifid, slot);
-			const value = await backend.getMeta(metaKey);
-			if (value && deletedSet.has(value)) {
-				await backend.deleteMeta(metaKey);
-				await removeFromSlotIndex(ifid, slot);
-			}
-		}
+		await emptySlotsHolding(ifid, (id) => deletedSet.has(id));
 		if (replacement && await replacement.current === playthroughId) {
 			await startNewPlaythroughNow(ifid, replacement.id);
 			return true;
@@ -5809,135 +5549,21 @@ function executeStoryInit() {
 		render(h(() => renderNodes(ast), null), container);
 		recordStoryInitState();
 	}
-	const saveTitlePassage = state.storyData.passages.get("SaveTitle");
-	if (saveTitlePassage) setSaveTitlePassage(saveTitlePassage.content);
-}
-/**
-* Initialize a freshly booted story: run StoryInit, restore `session` (the
-* state a page refresh left behind) if there is one, then fire `storyinit`
-* once all state is settled. Without a session, what the `storyinit`
-* handlers set synchronously belongs to the start moment, like StoryInit's
-* changes; a restored session keeps the history it recorded.
-*/
-function initializeStory(session) {
-	executeStoryInit();
-	if (session) useStoryStore.getState().loadFromPayload(session);
-	emit("storyinit");
-	if (!session) recordStoryInitState();
-}
-//#endregion
-//#region src/utils/object-path.ts
-/**
-* Traverse dot-path segments on an object and return the nested 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.
-*/
-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$2(current, seg)) return void 0;
-		current = current[seg];
-	}
-	return current;
-}
-/** Array indices ("0", "1", …) and "length": the keys an array holds. */
-var isArrayKey = (key) => key === "length" || /^(0|[1-9]\d*)$/.test(key);
-/**
-* Built-ins whose content is not their properties: a property written into
-* one would be dropped by clones and saves (and by Immer, for Map and Set).
-*/
-var builtinName = (value) => value instanceof Map ? "a Map" : value instanceof Set ? "a Set" : value instanceof Date ? "a Date" : value instanceof RegExp ? "a RegExp" : void 0;
-/**
-* Shallow copy that keeps the prototype, so a registered class instance
-* stays an instance of its class (with the same own keys deepClone copies).
-*/
-function shallowCopy(value) {
-	const copy = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value));
-	for (const key of Object.keys(value)) Object.defineProperty(copy, key, {
-		value: value[key],
-		enumerable: true,
-		writable: true,
-		configurable: true
-	});
-	return copy;
-}
-/**
-* Set a value at dot-path `segments` below `root`.
-*
-* When `root` is an Immer draft, objects Immer does not draft (registered
-* class instances and everything below them) are copied on the way down and
-* the copy is assigned to its parent, so the write produces new references
-* up to the root. Writing into such an object directly would mutate the
-* instance shared with the previous state and with history, and subscribers
-* would see no change. Outside a draft (a private working copy) the path is
-* written in place.
-*
-* The path goes through own properties of plain objects, class instances
-* and arrays (by index); anything else throws a TypeError rather than
-* writing where no clone or save would see it: an inherited property such
-* as a method counts as missing, and Map, Set, Date and RegExp values and
-* other keys of arrays are refused, as is a "__proto__" segment.
-*/
-function setByPath(root, segments, value, options = {}) {
-	const parent = walkToParent(root, segments, options.createMissing ?? false);
-	parent[segments[segments.length - 1]] = value;
-}
-/**
-* Delete the property at dot-path `segments` below `root`, copying
-* undrafted objects on the way down like setByPath(). Does nothing when an
-* intermediate is missing or not an object, or the property is absent (or
-* only inherited).
-*/
-function deleteByPath(root, segments) {
-	const last = segments[segments.length - 1];
-	checkSegments(segments);
-	let holder = root;
-	for (const seg of segments.slice(0, -1)) {
-		if (holder == null || typeof holder !== "object" || !hasOwn$2(holder, seg)) return;
-		holder = holder[seg];
-	}
-	if (holder == null || typeof holder !== "object" || !hasOwn$2(holder, last)) return;
-	const parent = walkToParent(root, segments, false);
-	delete parent[last];
-}
-/** Refuse a segment that would reach a prototype instead of story state. */
-function checkSegments(segments) {
-	if (segments.includes("__proto__")) throw new TypeError(`spindle: Cannot use "__proto__" in a variable path ("${segments.join(".")}")`);
-}
-/** Throw unless `holder` can take `key` as story state (see setByPath). */
-function checkHolder(holder, key, segments, depth) {
-	const kind = builtinName(holder) ?? (Array.isArray(holder) && !isArrayKey(key) ? "an array" : "");
-	if (kind) throw new TypeError(`spindle: Cannot set property "${key}" on ${kind} (at "${segments.slice(0, depth).join(".")}")`);
+	const saveTitlePassage = state.storyData.passages.get("SaveTitle");
+	if (saveTitlePassage) setSaveTitlePassage(saveTitlePassage.content);
 }
 /**
-* Walk to the object holding the last of `segments`, copying undrafted
-* objects when `root` is an Immer draft (see setByPath). A missing or
-* non-object intermediate is replaced by a plain object when
-* `createMissing` is set, and throws a TypeError otherwise.
+* Initialize a freshly booted story: run StoryInit, restore `session` (the
+* state a page refresh left behind) if there is one, then fire `storyinit`
+* once all state is settled. Without a session, what the `storyinit`
+* handlers set synchronously belongs to the start moment, like StoryInit's
+* changes; a restored session keeps the history it recorded.
 */
-function walkToParent(root, segments, createMissing) {
-	checkSegments(segments);
-	const copyOnWrite = isDraft(root);
-	let current = root;
-	for (let i = 0; i < segments.length - 1; i++) {
-		const seg = segments[i];
-		checkHolder(current, seg, segments, i);
-		let next = hasOwn$2(current, seg) ? current[seg] : void 0;
-		if (next == null || typeof next !== "object") {
-			if (!createMissing) throw new TypeError(`spindle: Cannot set property "${segments[i + 1]}" on ${next === null ? "null" : typeof next} (at "${segments.slice(0, i + 1).join(".")}")`);
-			next = {};
-			current[seg] = next;
-		} else if (copyOnWrite && !isDraft(next) && !builtinName(next)) {
-			next = shallowCopy(next);
-			current[seg] = next;
-		}
-		current = next;
-	}
-	checkHolder(current, segments[segments.length - 1], segments, segments.length - 1);
-	return current;
+function initializeStory(session) {
+	executeStoryInit();
+	if (session) useStoryStore.getState().loadFromPayload(session);
+	emit("storyinit");
+	if (!session) recordStoryInitState();
 }
 //#endregion
 //#region src/execute-mutation.ts
@@ -5981,54 +5607,6 @@ function frozenCopy(value) {
 	return freeze(cloneValue(value), true);
 }
 /**
-* Objects merged property by property: plain objects and (registered)
-* class instances. Arrays, Map, Set, Date and RegExp are values that are
-* replaced as a whole, since their elements have no stable identity to
-* merge by (a shift moves every index).
-*/
-function isMergeable(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Map) && !(value instanceof Set) && !(value instanceof Date) && !(value instanceof RegExp);
-}
-var hasOwn$1 = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-/** Collect the property paths where `work` differs from `base`. */
-function diff(base, work, path, changes, ancestors) {
-	if (ancestors.has(work)) return;
-	ancestors.add(work);
-	for (const key of Object.keys(work)) {
-		const b = base[key];
-		const w = work[key];
-		if (!hasOwn$1(base, key)) changes.push({
-			path: [...path, key],
-			deleted: false,
-			value: w
-		});
-		else if (Object.is(b, w)) continue;
-		else if (isMergeable(b) && isMergeable(w) && Object.getPrototypeOf(b) === Object.getPrototypeOf(w)) diff(b, w, [...path, key], changes, ancestors);
-		else if (!deepEqual(b, w)) changes.push({
-			path: [...path, key],
-			deleted: false,
-			value: w
-		});
-	}
-	for (const key of Object.keys(base)) if (!hasOwn$1(work, key)) changes.push({
-		path: [...path, key],
-		deleted: true
-	});
-	ancestors.delete(work);
-}
-/** Whether `ns` already holds what `change` would write. */
-function isApplied(ns, change) {
-	const parent = getByPath(ns, change.path.slice(0, -1));
-	if (parent === null || typeof parent !== "object") return change.deleted;
-	const key = change.path[change.path.length - 1];
-	if (!hasOwn$1(parent, key)) return change.deleted;
-	return !change.deleted && deepEqual(parent[key], change.value);
-}
-function applyChange(ns, change) {
-	if (change.deleted) deleteByPath(ns, change.path);
-	else setByPath(ns, change.path, change.value);
-}
-/**
 * Apply a write that reached the store while mutations execute to their
 * `work` and `base` copies (see MutationScope), so the code sees it and
 * its commit neither drops it nor reverts it. Called from inside the store
@@ -6046,7 +5624,7 @@ function mirror(draft, ns, change, scopes = activeScopes) {
 		});
 	} catch {
 		const stored = draft[ns][root];
-		if (hasOwn$1(draft[ns], root)) copy[root] = cloneValue(isDraft(stored) ? current(stored) : stored);
+		if (hasOwn(draft[ns], root)) copy[root] = cloneValue(isDraft(stored) ? current(stored) : stored);
 		else delete copy[root];
 	}
 }
@@ -6070,7 +5648,7 @@ function changedPath(ns, segments) {
 		if (!isMergeable(node)) break;
 		const key = String(segment);
 		path.push(key);
-		node = hasOwn$1(node, key) ? node[key] : void 0;
+		node = hasOwn(node, key) ? node[key] : void 0;
 	}
 	return path;
 }
@@ -6078,7 +5656,7 @@ function changedPath(ns, segments) {
 function changeTo(ns, path) {
 	const parent = getByPath(ns, path.slice(0, -1));
 	const key = path[path.length - 1];
-	return isMergeable(parent) && hasOwn$1(parent, key) ? {
+	return isMergeable(parent) && hasOwn(parent, key) ? {
 		path,
 		deleted: false,
 		value: parent[key]
@@ -6094,7 +5672,7 @@ function changeTo(ns, path) {
 * replaces exactly what it replaced in program order.
 */
 function writtenPaths(before, after, patches) {
-	if (patches.some((p) => p.path.length === 1)) return [...new Set([...Object.keys(before), ...Object.keys(after)])].filter((root) => !hasOwn$1(before, root) || before[root] !== after[root]).map((root) => changeTo(after, [root]));
+	if (patches.some((p) => p.path.length === 1)) return [...new Set([...Object.keys(before), ...Object.keys(after)])].filter((root) => !hasOwn(before, root) || before[root] !== after[root]).map((root) => changeTo(after, [root]));
 	const seen = /* @__PURE__ */ new Set();
 	const changes = [];
 	for (const patch of patches) {
@@ -6166,7 +5744,7 @@ function routeStoreUpdate(recipe) {
 			try {
 				applyChange(namespaces[ns], owned(change));
 			} catch {
-				if (hasOwn$1(inner.work[ns], root)) namespaces[ns][root] = cloneValue(inner.work[ns][root]);
+				if (hasOwn(inner.work[ns], root)) namespaces[ns][root] = cloneValue(inner.work[ns][root]);
 				else delete namespaces[ns][root];
 			}
 			mirror(namespaces, ns, change);
@@ -6197,11 +5775,7 @@ function commitScopes(commits) {
 	const all = commits.map(({ scope, keepRunning }) => ({
 		scope,
 		keepRunning,
-		changes: NAMESPACES.map((ns) => {
-			const list = [];
-			diff(scope.base[ns], scope.work[ns], [], list, /* @__PURE__ */ new Set());
-			return [ns, list];
-		})
+		changes: NAMESPACES.map((ns) => [ns, diffPaths(scope.base[ns], scope.work[ns])])
 	}));
 	const changed = all.filter(({ changes }) => changes.some(([, list]) => list.length > 0));
 	if (changed.length === 0) return;
@@ -6249,12 +5823,7 @@ var running = () => activeScopes.map((scope) => ({
 */
 function resync(scope) {
 	const state = useStoryStore.getState();
-	for (const ns of NAMESPACES) {
-		const work = scope.work[ns];
-		const stored = state[ns];
-		for (const key of Object.keys(work)) if (!hasOwn$1(stored, key)) delete work[key];
-		for (const key of Object.keys(stored)) if (!hasOwn$1(work, key) || !deepEqual(work[key], stored[key])) work[key] = deepClone(stored[key]);
-	}
+	for (const ns of NAMESPACES) mergeKeys(scope.work[ns], scope.work[ns], state[ns]);
 	scope.base = cloneNamespaces(state);
 }
 /**
@@ -6293,7 +5862,7 @@ function executeMutation(code, mergedLocals, scopeUpdate) {
 		keepRunning: false
 	}]);
 	for (const key of Object.keys(localsClone)) if (!deepEqual(localsClone[key], mergedLocals[key])) scopeUpdate(key, localsClone[key]);
-	for (const key of Object.keys(mergedLocals)) if (!hasOwn$1(localsClone, key)) scopeUpdate(key, void 0);
+	for (const key of Object.keys(mergedLocals)) if (!hasOwn(localsClone, key)) scopeUpdate(key, void 0);
 }
 //#endregion
 //#region src/triggers.ts
@@ -6523,7 +6092,7 @@ function clonePatches(patches) {
 function computeVarPatches(prev, curr) {
 	const [, forward, inverse] = produceWithPatches(prev, (draft) => {
 		const d = draft;
-		for (const key of Object.keys(d)) if (!Object.prototype.hasOwnProperty.call(curr, key)) delete d[key];
+		for (const key of Object.keys(d)) if (!hasOwn(curr, key)) delete d[key];
 		for (const [key, val] of Object.entries(curr)) d[key] = val;
 	});
 	return {
@@ -6540,6 +6109,26 @@ function rerecordNewestMoment(vars) {
 	if (last < 0) variableBase = vars;
 	else patchEntries[last] = computeVarPatches(reconstructVarsAt(last), vars);
 }
+/**
+* Call `fn` with the variables recorded for each of the first `count`
+* history moments, replaying the patches once.
+*/
+function forEachRecorded(count, fn) {
+	let vars = variableBase;
+	for (let i = 0; i < count; i++) {
+		if (i > 0) vars = applyPatches(vars, patchEntries[i - 1].forward);
+		fn(vars, i);
+	}
+}
+/** A history moment as saves and the session hold it, with its variables. */
+function savedMoment(moment, variables) {
+	return {
+		passage: moment.passage,
+		variables,
+		timestamp: moment.timestamp,
+		prng: moment.prng
+	};
+}
 /** Reconstruct variables at a given history moment by replaying patches. */
 function reconstructVarsAt(index) {
 	let vars = variableBase;
@@ -6553,24 +6142,10 @@ function persistSession(get) {
 	if (serializedHistory.length > history.length) serializedHistory.length = history.length;
 	if (serializedHistory.length < history.length) if (history.length - serializedHistory.length === 1) {
 		const i = history.length - 1;
-		serializedHistory[i] = {
-			passage: history[i].passage,
-			variables: serialize(variables),
-			timestamp: history[i].timestamp,
-			prng: history[i].prng
-		};
-	} else {
-		let vars = variableBase;
-		for (let i = 0; i < history.length; i++) {
-			if (i > 0) vars = applyPatches(vars, patchEntries[i - 1].forward);
-			if (i >= serializedHistory.length) serializedHistory[i] = {
-				passage: history[i].passage,
-				variables: serialize(vars),
-				timestamp: history[i].timestamp,
-				prng: history[i].prng
-			};
-		}
-	}
+		serializedHistory[i] = savedMoment(history[i], serialize(variables));
+	} else forEachRecorded(history.length, (vars, i) => {
+		if (i >= serializedHistory.length) serializedHistory[i] = savedMoment(history[i], serialize(vars));
+	});
 	saveSession(storyData.ifid, {
 		passage: currentPassage,
 		variables: serialize(variables),
@@ -6642,6 +6217,58 @@ function resetModuleState(base) {
 	serializedHistory = [];
 }
 /**
+* Fresh variables from `defaults` for a game that starts over (init,
+* restart), recorded as the history base.
+*/
+function startVariables(defaults) {
+	const initialVars = createNamespace(deepClone(defaults));
+	resetModuleState(deepClone(initialVars));
+	return initialVars;
+}
+/**
+* Enter the start passage with `variables`, as the only history moment
+* (init, restart). Call it inside a store update.
+*/
+function enterStart(state, passage, variables, transientDefaults) {
+	state.currentPassage = passage;
+	state.navigationId++;
+	state.variables = variables;
+	state.transient = createNamespace(deepClone(transientDefaults));
+	state.temporary = createNamespace();
+	state.history = [{
+		passage,
+		timestamp: Date.now()
+	}];
+	state.historyIndex = 0;
+}
+/**
+* Move through history by `step` moments (back or forward), restoring the
+* snapshot recorded for the moment moved to: live variables may hold edits
+* made since the current moment was recorded.
+*/
+function moveInHistory(get, set, step) {
+	const { historyIndex, history } = get();
+	const target = historyIndex + step;
+	if (target < 0 || target >= history.length) return;
+	finishEnteredMoment(get, set);
+	const previousPassage = get().currentPassage;
+	const targetPassage = history[target].passage;
+	emit("beforenavigate", targetPassage);
+	const restoredVars = deepClone(reconstructVarsAt(target));
+	set((state) => {
+		state.historyIndex += step;
+		state.currentPassage = state.history[state.historyIndex].passage;
+		state.navigationId++;
+		state.variables = restoredVars;
+		state.temporary = createNamespace();
+	});
+	reinitTriggerState();
+	lastNavigationVars = get().variables;
+	restorePRNGFromMoment(get().history[get().historyIndex]);
+	persistSession(get);
+	emit("afternavigate", targetPassage, previousPassage);
+}
+/**
 * Record the state StoryInit left behind as the start moment: its variable
 * snapshot (the history base) and PRNG state. Called by executeStoryInit()
 * after the StoryInit passage has rendered, and again after the `storyinit`
@@ -6652,10 +6279,7 @@ function resetModuleState(base) {
 function recordStoryInitState() {
 	const { history, historyIndex, variables } = useStoryStore.getState();
 	if (history.length !== 1 || historyIndex !== 0) return;
-	variableBase = variables;
-	patchEntries = [];
-	lastNavigationVars = variables;
-	serializedHistory = [];
+	resetModuleState(variables);
 	const prng = snapshotPRNG();
 	useStoryStore.setState((state) => {
 		state.history[0].prng = prng;
@@ -6825,56 +6449,31 @@ function keepHookWrites(payload, before, after) {
 	if (!moment) return;
 	mergeHookWrites(moment.variables, before, after, /* @__PURE__ */ new Set());
 }
-var hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-/**
-* Whether changes between `a` and `b` merge key by key: both are arrays,
-* or both are objects of one class (see isMergeable).
-*/
-function mergeable(a, b) {
-	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b);
-	return isMergeable(a) && isMergeable(b) && Object.getPrototypeOf(a) === Object.getPrototypeOf(b);
-}
-/**
-* Apply the hooks' change of a value, from `before` to `after`, to the
-* snapshot's copy of it, `target[key]`. Store updates are immutable, so a
-* value no hook touched keeps its identity; one rebuilt with equal content
-* (mutation code commits whole values) is no change either. Where `target`
-* lacks the key or holds another kind of value (the passage created or
-* replaced it), the hooks' whole value is written.
-*/
-function mergeHookWrite(target, key, before, after, ancestors) {
-	if (Object.is(before, after)) return;
-	if (mergeable(before, after) && hasOwn(target, key) && mergeable(after, target[key]) && !ancestors.has(after)) mergeHookWrites(target[key], before, after, ancestors);
-	else if (!deepEqual(before, after)) target[key] = deepClone(after);
-}
 /**
-* Apply the changes between `before` and `after`, two objects or two arrays
-* (see mergeable()), to the snapshot's `target`. Array elements merge by
-* index. Elements the hooks removed from an array's end are removed from
-* the snapshot's array at the same indices, and elements they added are
-* appended to it: where the passage resized the array, its indices do not
-* line up with the snapshot's, and the passage resizes it again on load.
+* 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);
-	if (Array.isArray(target)) {
-		const b = before;
-		const a = after;
-		const shared = Math.min(b.length, a.length, target.length);
-		for (let i = 0; i < shared; i++) mergeHookWrite(target, String(i), b[i], a[i], ancestors);
-		if (a.length < b.length) target.length = Math.min(target.length, a.length);
-		for (let i = b.length; i < a.length; i++) target.push(deepClone(a[i]));
-	} else {
-		for (const key of Object.keys(before)) if (!hasOwn(after, key)) delete target[key];
-		for (const key of Object.keys(after)) if (hasOwn(before, key)) mergeHookWrite(target, key, before[key], after[key], ancestors);
-		else target[key] = deepClone(after[key]);
-	}
+	mergeKeys(target, before, after, (key, b, a) => {
+		if (!hasOwn(target, key) || !mergesWith(a, target[key], true) || ancestors.has(a)) return false;
+		mergeHookWrites(target[key], b, a, ancestors);
+		return true;
+	});
 	ancestors.delete(after);
 }
+/** Restore the PRNG from a snapshot, or reset it without one. */
+function restorePRNGFrom(prng) {
+	if (prng) restorePRNG(prng.seed, prng.pull);
+	else resetPRNG();
+}
 /** Restore or reset PRNG from a history moment's snapshot. */
 function restorePRNGFromMoment(moment) {
-	if (moment?.prng) restorePRNG(moment.prng.seed, moment.prng.pull);
-	else if (moment) resetPRNG();
+	if (moment) restorePRNGFrom(moment.prng);
 }
 var NAMESPACE_KEYS = [
 	"variables",
@@ -6957,6 +6556,46 @@ function handled(p) {
 	p.catch(() => {});
 	return p;
 }
+/**
+* `p` with its failure logged under `message` and passed to `onError`, and
+* still rejecting; marked as handled (see handled()).
+*/
+function reported(p, message, onError) {
+	return handled(p.catch((err) => {
+		console.error(message, err);
+		onError?.(err);
+		throw err;
+	}));
+}
+/** Record in the slot cache whether `slot` holds a save. */
+function recordKnownSave(set, slot, known) {
+	set((state) => {
+		const key = slot ?? "";
+		if (known) state.knownSaves = {
+			...state.knownSaves,
+			[key]: true
+		};
+		else {
+			const { [key]: _, ...rest } = state.knownSaves;
+			state.knownSaves = rest;
+		}
+	});
+}
+/**
+* Queue the clearing of saved data, then restart now: the new playthrough
+* is stored after it, and operations issued from here on belong to the new
+* game. The slot cache empties once the clearing is done, after operations
+* issued before it have updated it.
+*/
+function clearAndRestart(get, set, clearing, message) {
+	const cleared = clearing.then(() => {
+		set((state) => {
+			state.knownSaves = {};
+		});
+	});
+	get().restart();
+	return reported(cleared, message);
+}
 var useStoryStore = create()(storyStore((set, get) => ({
 	storyData: null,
 	currentPassage: "",
@@ -7002,23 +6641,13 @@ var useStoryStore = create()(storyStore((set, get) => ({
 	init: (storyData, variableDefaults = {}, transientDefaults = {}) => {
 		const startPassage = storyData.passagesById.get(storyData.startNode);
 		if (!startPassage) throw new Error(`spindle: Start passage (pid=${storyData.startNode}) not found.`);
-		const initialVars = createNamespace(deepClone(variableDefaults));
-		resetModuleState(deepClone(initialVars));
+		const initialVars = startVariables(variableDefaults);
 		set((state) => {
 			state.storyData = storyData;
 			state.playthroughId = "";
-			state.currentPassage = startPassage.name;
-			state.navigationId++;
-			state.variables = initialVars;
 			state.variableDefaults = variableDefaults;
-			state.transient = createNamespace(deepClone(transientDefaults));
 			state.transientDefaults = transientDefaults;
-			state.temporary = createNamespace();
-			state.history = [{
-				passage: startPassage.name,
-				timestamp: Date.now()
-			}];
-			state.historyIndex = 0;
+			enterStart(state, startPassage.name, initialVars, transientDefaults);
 			state.visitCounts = createCounts(null, startPassage.name);
 			state.renderCounts = createCounts(null, startPassage.name);
 		});
@@ -7087,48 +6716,8 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		emit("afternavigate", passageName, previousPassage);
 		for (const next of deferred) get().navigate(next);
 	},
-	goBack: () => {
-		const { historyIndex } = get();
-		if (historyIndex <= 0) return;
-		finishEnteredMoment(get, set);
-		const previousPassage = get().currentPassage;
-		const targetPassage = get().history[historyIndex - 1].passage;
-		emit("beforenavigate", targetPassage);
-		const restoredVars = deepClone(reconstructVarsAt(historyIndex - 1));
-		set((state) => {
-			state.historyIndex--;
-			state.currentPassage = state.history[state.historyIndex].passage;
-			state.navigationId++;
-			state.variables = restoredVars;
-			state.temporary = createNamespace();
-		});
-		reinitTriggerState();
-		lastNavigationVars = get().variables;
-		restorePRNGFromMoment(get().history[get().historyIndex]);
-		persistSession(get);
-		emit("afternavigate", targetPassage, previousPassage);
-	},
-	goForward: () => {
-		const { historyIndex, history: hist } = get();
-		if (historyIndex >= hist.length - 1) return;
-		finishEnteredMoment(get, set);
-		const previousPassage = get().currentPassage;
-		const targetPassage = hist[historyIndex + 1].passage;
-		emit("beforenavigate", targetPassage);
-		const restoredVars = deepClone(reconstructVarsAt(historyIndex + 1));
-		set((state) => {
-			state.historyIndex++;
-			state.currentPassage = state.history[state.historyIndex].passage;
-			state.navigationId++;
-			state.variables = restoredVars;
-			state.temporary = createNamespace();
-		});
-		reinitTriggerState();
-		lastNavigationVars = get().variables;
-		restorePRNGFromMoment(get().history[get().historyIndex]);
-		persistSession(get);
-		emit("afternavigate", targetPassage, previousPassage);
-	},
+	goBack: () => moveInHistory(get, set, -1),
+	goForward: () => moveInHistory(get, set, 1),
 	setVariable: (name, value) => {
 		set((state) => {
 			checkVariableName(name, `$${name}`);
@@ -7190,19 +6779,9 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		cleanupRuntimeHandlers();
 		resetPRNG();
 		resetTriggers();
-		const initialVars = createNamespace(deepClone(variableDefaults));
-		resetModuleState(deepClone(initialVars));
+		const initialVars = startVariables(variableDefaults);
 		set((state) => {
-			state.currentPassage = startPassage.name;
-			state.navigationId++;
-			state.variables = initialVars;
-			state.transient = createNamespace(deepClone(transientDefaults));
-			state.temporary = createNamespace();
-			state.history = [{
-				passage: startPassage.name,
-				timestamp: Date.now()
-			}];
-			state.historyIndex = 0;
+			enterStart(state, startPassage.name, initialVars, transientDefaults);
 			state.visitCounts = createCounts(null, startPassage.name);
 			state.renderCounts = createCounts(null, startPassage.name);
 			if (!keepDeferred) state.renderDeferred = false;
@@ -7218,23 +6797,14 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		const { storyData } = get();
 		if (!storyData) return Promise.resolve();
 		const playthrough = resolvePlaythroughId();
-		return handled(saveWithHooks(slot, custom, get().beginSave, async (payload) => {
+		return reported(saveWithHooks(slot, custom, get().beginSave, async (payload) => {
 			set((state) => {
 				state.saveError = null;
 			});
 			await quickSave(storyData.ifid, playthrough, payload, slot, custom);
-			set((state) => {
-				state.knownSaves = {
-					...state.knownSaves,
-					[slot ?? ""]: true
-				};
-			});
-		}).catch((err) => {
-			console.error("spindle: failed to save", err);
-			set((state) => {
-				state.saveError = errorMessage(err, "Failed to save");
-			});
-			throw err;
+			recordKnownSave(set, slot, true);
+		}), "spindle: failed to save", (err) => set((state) => {
+			state.saveError = errorMessage(err, "Failed to save");
 		}));
 	},
 	load: (slot) => {
@@ -7247,24 +6817,20 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		const read = loadSlotSave(storyData.ifid, slot);
 		const switched = switchToLookedUpPlaythrough(Promise.all([previous, read.catch(() => void 0)]).then(([prev, loaded]) => loaded?.playthroughId || prev));
 		const replacement = ++stateReplacementsIssued;
-		return handled(read.then(async (loaded) => {
+		return reported(read.then(async (loaded) => {
 			await switched;
 			if (!loaded) return;
 			if (latestStateApplied > replacement) return;
 			slotLoadApplying = replacement;
 			get().loadFromPayload(loaded.payload, slot);
-		}).catch((err) => {
-			console.error("spindle: failed to load save", err);
-			set((state) => {
-				state.loadError = errorMessage(err, "Failed to load");
-			});
-			throw err;
+		}), "spindle: failed to load save", (err) => set((state) => {
+			state.loadError = errorMessage(err, "Failed to load");
 		}));
 	},
 	hasSave: (slot) => {
 		const { storyData, knownSaves } = get();
 		if (!storyData) return false;
-		return Object.prototype.hasOwnProperty.call(knownSaves, slot ?? "");
+		return hasOwn(knownSaves, slot ?? "");
 	},
 	getSaveInfo: async (slot) => {
 		const { storyData } = get();
@@ -7279,16 +6845,7 @@ var useStoryStore = create()(storyStore((set, get) => ({
 	deleteSave: (slot) => {
 		const { storyData } = get();
 		if (!storyData) return Promise.resolve();
-		return handled(deleteSlotSave(storyData.ifid, slot).then(() => {
-			set((state) => {
-				const key = slot ?? "";
-				const { [key]: _, ...rest } = state.knownSaves;
-				state.knownSaves = rest;
-			});
-		}).catch((err) => {
-			console.error("spindle: failed to delete save", err);
-			throw err;
-		}));
+		return reported(deleteSlotSave(storyData.ifid, slot).then(() => recordKnownSave(set, slot, false)), "spindle: failed to delete save");
 	},
 	exportSave: async (slot) => {
 		const { storyData } = get();
@@ -7300,40 +6857,15 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		if (!storyData) throw new Error("spindle: Story is not initialized.");
 		if (!isSaveExport(data)) throw new Error("Invalid save file format");
 		const info = await importSlotSave(data, storyData.ifid, slot);
-		set((state) => {
-			state.knownSaves = {
-				...state.knownSaves,
-				[slot ?? ""]: true
-			};
-		});
+		recordKnownSave(set, slot, true);
 		return info;
 	},
 	clearGameData: () => {
 		const { storyData } = get();
 		if (!storyData) return Promise.resolve();
-		const cleared = clearGameData(storyData.ifid).then(() => {
-			set((state) => {
-				state.knownSaves = {};
-			});
-		});
-		get().restart();
-		return handled(cleared.catch((err) => {
-			console.error("spindle: failed to clear game data", err);
-			throw err;
-		}));
-	},
-	clearAllData: () => {
-		const cleared = clearAllData().then(() => {
-			set((state) => {
-				state.knownSaves = {};
-			});
-		});
-		get().restart();
-		return handled(cleared.catch((err) => {
-			console.error("spindle: failed to clear all data", err);
-			throw err;
-		}));
+		return clearAndRestart(get, set, clearGameData(storyData.ifid), "spindle: failed to clear game data");
 	},
+	clearAllData: () => clearAndRestart(get, set, clearAllData(), "spindle: failed to clear all data"),
 	deletePlaythrough: (playthroughId) => {
 		const { storyData } = get();
 		if (!storyData) return Promise.resolve();
@@ -7347,29 +6879,19 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		});
 		if (playthroughId !== "" && playthroughId === current) switchToPlaythrough(replacementId, deletion);
 		else if (current === "") switchToLookedUpPlaythrough(deletion.then((replaced) => replaced ? replacementId : established, () => established));
-		return handled(deletion.then(async () => {
+		return reported(deletion.then(async () => {
 			const known = await populateKnownSaves(storyData.ifid);
 			set((state) => {
 				state.knownSaves = known;
 			});
-		}).catch((err) => {
-			console.error("spindle: failed to delete playthrough", err);
-			throw err;
-		}));
+		}), "spindle: failed to delete playthrough");
 	},
 	getSavePayload: () => {
 		const { currentPassage, variables, history, historyIndex, visitCounts, renderCounts } = get();
 		const saveHistory = [];
-		let vars = variableBase;
-		for (let i = 0; i < history.length; i++) {
-			if (i > 0) vars = applyPatches(vars, patchEntries[i - 1].forward);
-			saveHistory.push({
-				passage: history[i].passage,
-				variables: plainCopy(vars),
-				timestamp: history[i].timestamp,
-				prng: history[i].prng
-			});
-		}
+		forEachRecorded(history.length, (vars, i) => {
+			saveHistory.push(savedMoment(history[i], plainCopy(vars)));
+		});
 		return {
 			passage: currentPassage,
 			variables: plainCopy(variables),
@@ -7410,12 +6932,7 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		}
 		variableBase = deepClone(base);
 		patchEntries = newPatchEntries;
-		serializedHistory = payload.history.map((m) => ({
-			passage: m.passage,
-			variables: serialize(m.variables),
-			timestamp: m.timestamp,
-			prng: m.prng
-		}));
+		serializedHistory = payload.history.map((m) => savedMoment(m, serialize(m.variables)));
 		set((state) => {
 			state.currentPassage = payload.passage;
 			state.navigationId++;
@@ -7434,9 +6951,7 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		});
 		reinitTriggerState();
 		lastNavigationVars = reconstructVarsAt(get().historyIndex);
-		const prng = entry?.prng !== void 0 ? entry.prng : payload.prng;
-		if (prng) restorePRNG(prng.seed, prng.pull);
-		else resetPRNG();
+		restorePRNGFrom(entry?.prng !== void 0 ? entry.prng : payload.prng);
 		persistSession(get);
 		withoutDraws(() => emit("afterload", slot));
 	},
@@ -7802,7 +7317,7 @@ function loadFromStorage() {
 /** Register a setting, starting from its default unless it has a value. */
 function define(name, def) {
 	definitions.set(name, def);
-	if (!hasOwn$2(values, name)) values[name] = def.config.default;
+	if (!hasOwn(values, name)) values[name] = def.config.default;
 	loadFromStorage();
 }
 /** The value of setting `name` if it has the type of `fallback`, else that. */
@@ -8720,6 +8235,56 @@ function astContainsChildren(nodes) {
 	return false;
 }
 //#endregion
+//#region src/components/macros/Widget.tsx
+/**
+* Read the arguments of a {widget} definition: its name (quotes dropped)
+* and its parameters, the words after it that start with one of the
+* characters of `sigils`.
+*/
+function parseWidgetDef(rawArgs, sigils = "@") {
+	const [first, ...rest] = rawArgs.trim().split(/\s+/);
+	return {
+		name: first.replace(/["']/g, ""),
+		params: rest.filter((word) => sigils.includes(word[0]))
+	};
+}
+defineMacro({
+	name: "widget",
+	block: true,
+	render({ rawArgs, children = [] }, ctx) {
+		let parsed;
+		let error;
+		try {
+			const def = parseWidgetDef(rawArgs);
+			for (const param of def.params) checkVariableName(param.slice(1), param);
+			parsed = def;
+		} catch (err) {
+			error = err;
+		}
+		const { name, params } = parsed ?? {
+			name: "",
+			params: []
+		};
+		const childrenKey = JSON.stringify(children);
+		const paramsKey = params.join(",");
+		ctx.hooks.useLayoutEffect(() => {
+			if (!parsed) return;
+			const isBlock = astContainsChildren(children);
+			registerWidget(name, children, params, isBlock);
+			if (isBlock) registerBlockMacro(name);
+		}, [
+			name,
+			childrenKey,
+			paramsKey
+		]);
+		if (error) return /* @__PURE__ */ jsx(MacroError, {
+			macro: "widget",
+			error
+		});
+		return null;
+	}
+});
+//#endregion
 //#region src/components/macros/Set.tsx
 defineMacro({
 	name: "set",
@@ -9166,7 +8731,7 @@ defineMacro({
 function liveLocalsView(getValues) {
 	return new Proxy(createNamespace(), {
 		get: (_, key) => typeof key === "string" ? ownValue(getValues(), key) : void 0,
-		has: (_, key) => typeof key === "string" && hasOwn$2(getValues(), key),
+		has: (_, key) => typeof key === "string" && hasOwn(getValues(), key),
 		ownKeys: () => Reflect.ownKeys(getValues()),
 		getOwnPropertyDescriptor: (_, key) => {
 			const desc = Object.getOwnPropertyDescriptor(getValues(), key);
@@ -9514,52 +9079,6 @@ defineMacro({
 	}
 });
 //#endregion
-//#region src/components/macros/Widget.tsx
-function parseWidgetDef(rawArgs) {
-	const tokens = rawArgs.trim().split(/\s+/);
-	const name = tokens[0].replace(/["']/g, "");
-	const params = tokens.slice(1).filter((t) => t.startsWith("@"));
-	for (const param of params) checkVariableName(param.slice(1), param);
-	return {
-		name,
-		params
-	};
-}
-defineMacro({
-	name: "widget",
-	block: true,
-	render({ rawArgs, children = [] }, ctx) {
-		let parsed;
-		let error;
-		try {
-			parsed = parseWidgetDef(rawArgs);
-		} catch (err) {
-			error = err;
-		}
-		const { name, params } = parsed ?? {
-			name: "",
-			params: []
-		};
-		const childrenKey = JSON.stringify(children);
-		const paramsKey = params.join(",");
-		ctx.hooks.useLayoutEffect(() => {
-			if (!parsed) return;
-			const isBlock = astContainsChildren(children);
-			registerWidget(name, children, params, isBlock);
-			if (isBlock) registerBlockMacro(name);
-		}, [
-			name,
-			childrenKey,
-			paramsKey
-		]);
-		if (error) return /* @__PURE__ */ jsx(MacroError, {
-			macro: "widget",
-			error
-		});
-		return null;
-	}
-});
-//#endregion
 //#region src/components/macros/StoryTitle.tsx
 defineMacro({
 	name: "story-title",
@@ -11005,9 +10524,7 @@ function boot() {
 	for (const [, passage] of storyData.passages) if (passage.tags.includes("widget")) {
 		const widgetAST = buildAST(tokenize(passage.content));
 		for (const node of widgetAST) if (node.type === "macro" && node.name === "widget" && node.rawArgs) {
-			const tokens2 = node.rawArgs.trim().split(/\s+/);
-			const widgetName = tokens2[0].replace(/["']/g, "");
-			const params = tokens2.slice(1).filter((t) => t.startsWith("$") || t.startsWith("_") || t.startsWith("@"));
+			const { name: widgetName, params } = parseWidgetDef(node.rawArgs, "$_@");
 			const children = node.children;
 			const isBlock = astContainsChildren(children);
 			try {