@rohal12/spindle 0.52.4 → 0.52.6

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. */
@@ -2620,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();
@@ -3436,11 +3679,29 @@ function ExprDisplay({ expression, className, id }) {
 	return /* @__PURE__ */ jsx(Fragment$1, { children: display });
 }
 //#endregion
-//#region src/components/macros/WidgetInvocation.tsx
-function WidgetBody({ body, parentValues, ownKeys }) {
-	const nobr = useContext(NobrContext);
-	const inline = useContext(InlineContext);
-	const raw = useContext(RawTextContext);
+//#region src/hooks/use-render-options.ts
+/**
+* The renderNodes() options of the enclosing content: nobr, inline and raw
+* rendering and the locals in scope. A macro or widget body rendered with
+* them renders as the content around it does.
+*/
+function useRenderOptions() {
+	return {
+		nobr: useContext(NobrContext),
+		inline: useContext(InlineContext),
+		raw: useContext(RawTextContext),
+		locals: useContext(LocalsValuesContext)
+	};
+}
+//#endregion
+//#region src/components/macros/locals-scope.tsx
+/**
+* Render `body` in a new locals scope: the locals of `parentValues`, with
+* `ownKeys` (an iteration's loop variables, a widget's parameters) on top.
+* Locals the body assigns are kept in this scope.
+*/
+function LocalsScope({ body, parentValues, ownKeys }) {
+	const options = useRenderOptions();
 	const [localMutations, setLocalMutations] = useState({});
 	const localState = useMemo(() => createNamespace(parentValues, ownKeys, localMutations), [
 		parentValues,
@@ -3467,29 +3728,22 @@ function WidgetBody({ body, parentValues, ownKeys }) {
 		children: /* @__PURE__ */ jsx(LocalsValuesContext.Provider, {
 			value: localState,
 			children: renderNodes(body, {
-				nobr,
-				inline,
-				raw,
+				...options,
 				locals: localState
 			})
 		})
 	});
 }
+//#endregion
+//#region src/components/macros/WidgetInvocation.tsx
 function WidgetInvocation({ body, params, rawArgs, invocationChildren }) {
-	const parentValues = useContext(LocalsValuesContext);
-	const nobr = useContext(NobrContext);
-	const inline = useContext(InlineContext);
-	const raw = useContext(RawTextContext);
+	const renderOptions = useRenderOptions();
+	const parentValues = renderOptions.locals;
 	const [mergedVars, mergedTemps, mergedLocals, mergedTrans] = useMergedLocals();
 	const childrenValue = invocationChildren?.length ? invocationChildren : null;
 	if (params.length === 0) return /* @__PURE__ */ jsx(WidgetChildrenContext.Provider, {
 		value: childrenValue,
-		children: renderNodes(body, {
-			nobr,
-			inline,
-			raw,
-			locals: parentValues
-		})
+		children: renderNodes(body, renderOptions)
 	});
 	const argExprs = rawArgs ? splitArgs(rawArgs) : [];
 	const values = [];
@@ -3510,7 +3764,7 @@ function WidgetInvocation({ body, params, rawArgs, invocationChildren }) {
 	}, values);
 	return /* @__PURE__ */ jsx(WidgetChildrenContext.Provider, {
 		value: childrenValue,
-		children: /* @__PURE__ */ jsx(WidgetBody, {
+		children: /* @__PURE__ */ jsx(LocalsScope, {
 			body,
 			parentValues,
 			ownKeys
@@ -3715,6 +3969,32 @@ function MacroError({ macro, error }) {
 		children: `{${macro} error${currentSourceLocation()}: ${errorMessage(error)}}`
 	});
 }
+/** Log an error in the macro `{label}` (its name, or name and arguments). */
+function logMacroError(label, error) {
+	console.error(`spindle: Error in {${label}}${currentSourceLocation()}:`, error);
+}
+/**
+* Run `effect` once, during the macro's first render. If it throws, the
+* error is logged under `{macro rawArgs}` and shown in place of the macro
+* from then on; otherwise the macro renders nothing.
+*/
+function useRunOnce(macro, rawArgs, effect) {
+	const failure = useRef();
+	if (failure.current === void 0) {
+		failure.current = null;
+		try {
+			effect();
+		} catch (error) {
+			failure.current = { error };
+			logMacroError(`${macro} ${rawArgs}`, error);
+		}
+	}
+	if (!failure.current) return null;
+	return /* @__PURE__ */ jsx(MacroError, {
+		macro,
+		error: failure.current.error
+	});
+}
 //#endregion
 //#region src/markup/render.tsx
 var defaultUpdater = {
@@ -4084,11 +4364,8 @@ function resolveAttributeValue(name, value, scope, errors) {
 }
 function HtmlNodeRenderer({ node }) {
 	const scope = useTextScope();
-	const nobr = useContext(NobrContext);
-	const locals = useContext(LocalsValuesContext);
-	const inRaw = useContext(RawTextContext);
+	const { nobr, locals, raw: inRaw, inline: parentInline } = useRenderOptions();
 	const inSvg = useContext(SvgContext);
-	const parentInline = useContext(InlineContext);
 	const tag = node.tag.toLowerCase();
 	const isSvgRoot = tag === "svg";
 	const isRawRoot = !inRaw && (isSvgRoot || PREFORMATTED_ELEMENTS.has(tag));
@@ -4322,6 +4599,54 @@ function renderNodes(nodes, options) {
 }
 //#endregion
 //#region src/saves/storage.ts
+/** A backend's tables, made by its `table` function. */
+function makeTables(table) {
+	return {
+		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);
+		},
+		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);
+		},
+		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
+	};
+}
 /**
 * 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,
@@ -4329,87 +4654,37 @@ function renderNodes(nodes, options) {
 */
 function createMemoryBackend() {
 	const copy = (value) => structuredClone(value);
-	const saves = /* @__PURE__ */ new Map();
-	const playthroughs = /* @__PURE__ */ new Map();
-	const meta = /* @__PURE__ */ new Map();
-	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);
-		},
-		async getAllMetaKeys() {
-			return [...meta.keys()];
-		},
-		async destroy() {
-			saves.clear();
-			playthroughs.clear();
-			meta.clear();
-		}
-	};
+	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();
+	});
 }
-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.";
+/** 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;
@@ -4435,107 +4710,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;
@@ -4559,96 +4782,52 @@ function createIDBBackend() {
 			req.onerror = () => reject(req.error);
 		});
 		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)) ?? [];
-	}
-	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);
-			});
-		}
-	};
+	}
+	function idbReq(req) {
+		return new Promise((resolve, reject) => {
+			req.onsuccess = () => resolve(req.result);
+			req.onerror = () => reject(req.error);
+		});
+	}
+	/**
+	* 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 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() {
@@ -4797,15 +4976,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 = {
@@ -4850,19 +5031,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
@@ -4872,7 +5060,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)
 		};
 	});
@@ -4907,12 +5095,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,
@@ -4921,18 +5132,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;
 }
@@ -4951,34 +5151,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;
 }
@@ -4988,15 +5176,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.
@@ -5007,14 +5191,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) {
@@ -5034,10 +5211,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();
@@ -5069,7 +5243,7 @@ async function getSavesGroupedNow(ifid) {
 		saves
 	});
 	return result;
-}
+});
 var AUTOSAVE_KEY_PREFIX = "autosave.";
 var SLOT_KEY_PREFIX = "slot.";
 var SLOT_INDEX_KEY_PREFIX = "slotIndex.";
@@ -5083,29 +5257,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 : "",
@@ -5123,32 +5317,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
@@ -5157,12 +5345,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;
@@ -5177,60 +5361,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.
@@ -5257,11 +5422,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,
@@ -5270,6 +5432,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.
@@ -5279,20 +5442,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) {
@@ -5306,13 +5460,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
@@ -5320,35 +5468,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;
@@ -5359,7 +5501,7 @@ async function getStorageInfoNow(ifid) {
 		totalBytes,
 		backend: backend.type
 	};
-}
+});
 function clearGameData(ifid) {
 	return inOrder(async () => {
 		const backend = await getBackend();
@@ -5369,9 +5511,7 @@ function clearGameData(ifid) {
 		clearSession(ifid);
 	});
 }
-function clearAllData() {
-	return inOrder(clearAllDataNow);
-}
+var clearAllData = queued(clearAllDataNow);
 async function clearAllDataNow() {
 	await (await getBackend()).destroy();
 	resetBackend();
@@ -5399,14 +5539,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;
@@ -5467,120 +5600,6 @@ function initializeStory(session) {
 	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(".")}")`);
-}
-/**
-* 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$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;
-}
-//#endregion
 //#region src/execute-mutation.ts
 var NAMESPACES = [
 	"variables",
@@ -5622,54 +5641,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
@@ -5687,7 +5658,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];
 	}
 }
@@ -5711,7 +5682,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;
 }
@@ -5719,7 +5690,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]
@@ -5735,7 +5706,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) {
@@ -5807,7 +5778,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);
@@ -5838,11 +5809,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;
@@ -5890,12 +5857,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);
 }
 /**
@@ -5934,7 +5896,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
@@ -6164,7 +6126,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 {
@@ -6181,6 +6143,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;
@@ -6194,24 +6176,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),
@@ -6283,6 +6251,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`
@@ -6293,10 +6313,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;
@@ -6466,56 +6483,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",
@@ -6598,6 +6590,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: "",
@@ -6643,23 +6675,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);
 		});
@@ -6728,48 +6750,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}`);
@@ -6831,19 +6813,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;
@@ -6859,23 +6831,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) => {
@@ -6888,24 +6851,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();
@@ -6920,16 +6879,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();
@@ -6941,40 +6891,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();
@@ -6988,29 +6913,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),
@@ -7051,12 +6966,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++;
@@ -7075,9 +6985,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));
 	},
@@ -7443,7 +7351,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. */
@@ -7620,18 +7528,236 @@ function collectText(nodes) {
 	return nodes.map((n) => n.type === "text" ? n.value : "").join("");
 }
 //#endregion
+//#region src/utils/parse-delay.ts
+/**
+* Parse a delay string into milliseconds.
+* Supports: "2s" → 2000, "500ms" → 500, bare number → ms
+*/
+function parseDelay(str) {
+	const trimmed = str.trim();
+	if (trimmed.endsWith("ms")) return parseFloat(trimmed.slice(0, -2));
+	if (trimmed.endsWith("s")) return parseFloat(trimmed.slice(0, -1)) * 1e3;
+	return parseFloat(trimmed);
+}
+//#endregion
+//#region src/components/macros/macro-args.ts
+/**
+* The macro argument layer: reads a macro's raw argument text into the
+* parameters its definition declares (see ParameterDef), so every macro
+* splits and unquotes its arguments the same way. defineMacro() passes the
+* result to the macro as `ctx.args`.
+*
+* Arguments are read in groups, split at `separator` parameters. A group's
+* `flag` parameters are taken off its start or end first. Its last
+* `expression` or `text` parameter (without one, its last parameter) reads
+* the text the others leave; each parameter before it reads one term from
+* the start, and each after it one term from the end. Terms are separated by
+* whitespace outside literals and brackets (see arg-utils.ts), and a term
+* that follows an operator belongs to the expression before it. A parameter
+* with nothing to read is unset (a flag or separator is false, options are
+* empty).
+*/
+/** The terms of `src`: the runs of text between its depth-0 whitespace. */
+function terms(src) {
+	const spans = [];
+	let start = 0;
+	for (const i of [...topLevelIndices(src, isWhitespace), src.length]) {
+		if (i > start) spans.push([start, i]);
+		start = i + 1;
+	}
+	return spans;
+}
+var slice = (src, [start, end]) => src.slice(start, end);
+/**
+* The value of a `text` argument: one quoted string, or the text with any
+* loose quotes stripped (`"Red` → `Red`).
+*/
+function readText(src) {
+	return readWholeQuoted(src) ?? stripLooseQuotes(src);
+}
+function readValue(param, src) {
+	switch (param.type) {
+		case "string": return readWholeQuoted(src) ?? void 0;
+		case "text": return readText(src);
+		case "names": return src.split(",").map((name) => name.trim());
+		case "delay": return parseDelay(src);
+		case "number": return Number(src);
+		case "options": return readOptions(param.parameters ?? [], src);
+		default: return src;
+	}
+}
+function unset(param) {
+	if (param.type === "flag" || param.type === "separator") return false;
+	return param.type === "options" ? {} : void 0;
+}
+var WORD_RE = /\w+/y;
+var DIGITS_RE = /\d+/y;
+/** Match the sticky regex `re` at `pos`, returning the matched text. */
+function matchAt(re, src, pos) {
+	re.lastIndex = pos;
+	return re.exec(src)?.[0] ?? null;
+}
+/**
+* Read keyword options (`goto "X" priority 5 once`). A keyword takes the
+* quoted string or digit run after it as its value; keywords that aren't
+* declared, and their values, are skipped.
+*/
+function readOptions(params, src) {
+	const options = {};
+	let i = 0;
+	while (i < src.length) {
+		const key = matchAt(WORD_RE, src, i);
+		if (!key) {
+			i = readQuoted(src, i)?.end ?? i + 1;
+			continue;
+		}
+		i += key.length;
+		let val;
+		let j = i;
+		while (j < src.length && isWhitespace(src[j])) j++;
+		if (j > i) {
+			const quoted = readQuoted(src, j);
+			const digits = quoted ? null : matchAt(DIGITS_RE, src, j);
+			if (quoted) {
+				val = quoted.value;
+				i = quoted.end;
+			} else if (digits) {
+				val = digits;
+				i = j + digits.length;
+			}
+		}
+		const param = params.find((p) => p.name === key);
+		if (param?.type === "flag") options[key] = true;
+		else if (param?.type === "number") options[key] = Number(val ?? 0);
+		else if (param) options[key] = val;
+	}
+	return options;
+}
+/** `inline %name` reads a transient variable; `inline % 2` is modulo. */
+var LEADING_OPERATOR_RE = /^(?:[-+*/&|^=<>?:,.]|%(?![A-Za-z_]))/;
+/**
+* The rest of `src` without the flag `word` as its last or first term, or
+* `null` if it has no such flag. Next to a binary operator the word is an
+* operand (`"a" + inline`), not a flag; the closing `/` of a regex literal
+* is not one.
+*/
+function takeFlag(src, word) {
+	const spans = terms(src);
+	if (spans.length < 2) return null;
+	if (slice(src, spans[spans.length - 1]) === word) {
+		const rest = src.slice(0, spans[spans.length - 2][1]);
+		if (!endsWithOperator(rest)) return rest;
+	}
+	if (slice(src, spans[0]) === word) {
+		const rest = src.slice(spans[1][0]);
+		if (!LEADING_OPERATOR_RE.test(rest)) return rest;
+	}
+	return null;
+}
+/**
+* Where the separator `word` splits `src`, as the end of the text before it
+* and the start of the text after it, or `null` if it doesn't. A word is a
+* term with terms on both sides; `=` is an assignment at depth 0, not part
+* of `==` or `!=`.
+*/
+function findSeparator(src, word) {
+	if (word === "=") {
+		const indices = topLevelIndices(src, (ch) => ch === "=");
+		for (let k = 0; k < indices.length; k++) {
+			const i = indices[k];
+			if (src[i + 1] === "=") {
+				k++;
+				continue;
+			}
+			if (src[i - 1] !== "!") return [i, i + 1];
+		}
+		return null;
+	}
+	const spans = terms(src);
+	for (let k = 1; k < spans.length - 1; k++) if (slice(src, spans[k]) === word) return [spans[k - 1][1], spans[k + 1][0]];
+	return null;
+}
+var takesRest = (param) => param.type === void 0 || param.type === "expression" || param.type === "text";
+/** Read the parameters of one group from `src` (`null`: no text) into `args`. */
+function readGroup(params, src, args) {
+	let text = src?.trim() ?? "";
+	for (const flag of params.filter((p) => p.type === "flag")) {
+		const rest = src === null ? null : takeFlag(text, flag.name);
+		args[flag.name] = rest !== null;
+		text = rest ?? text;
+	}
+	const positional = params.filter((p) => p.type !== "flag");
+	if (positional.length === 0) return;
+	const lastText = positional.findIndex((p, i) => takesRest(p) && !positional.slice(i + 1).some(takesRest));
+	const restIndex = lastText < 0 ? positional.length - 1 : lastText;
+	const read = (param, value) => value === "" ? unset(param) : readValue(param, value);
+	if (positional.length === 1) {
+		args[positional[0].name] = read(positional[0], text);
+		return;
+	}
+	const spans = terms(text);
+	let from = 0;
+	let to = spans.length;
+	for (const param of positional.slice(0, restIndex)) args[param.name] = from < to ? read(param, slice(text, spans[from++])) : unset(param);
+	for (const param of positional.slice(restIndex + 1).reverse()) {
+		const value = from < to && !endsWithOperator(text.slice(0, spans[to - 1][0])) ? read(param, slice(text, spans[to - 1])) : void 0;
+		args[param.name] = value ?? unset(param);
+		if (value !== void 0) to--;
+	}
+	const rest = positional[restIndex];
+	args[rest.name] = from < to ? read(rest, text.slice(spans[from][0], spans[to - 1][1])) : unset(rest);
+}
+/** Read `rawArgs` into the declared `parameters` (see above). */
+function parseMacroArgs(rawArgs, parameters) {
+	const args = {};
+	let rest = rawArgs.trim();
+	let groupStart = 0;
+	parameters.forEach((separator, i) => {
+		if (separator.type !== "separator") return;
+		const at = rest === null ? null : findSeparator(rest, separator.name);
+		args[separator.name] = at !== null;
+		const before = at ? rest.slice(0, at[0]) : rest;
+		readGroup(parameters.slice(groupStart, i), before, args);
+		rest = at ? rest.slice(at[1]) : null;
+		groupStart = i + 1;
+	});
+	readGroup(parameters.slice(groupStart), rest, args);
+	return args;
+}
+/**
+* The passage a passage-name argument names: the value of its expression
+* or, when that can't be evaluated (`{goto Bob's room}`), its text.
+*/
+function evaluatePassageName(expr, evaluate) {
+	try {
+		return String(evaluate(expr ?? ""));
+	} catch {
+		return readText(expr ?? "");
+	}
+}
+/**
+* The variable a `storeVar` macro binds: its first term, as written. Custom
+* macros may bind one without declaring parameters.
+*/
+function readBoundVariable(rawArgs) {
+	const src = rawArgs.trim();
+	const first = terms(src)[0];
+	return first ? slice(src, first) : "";
+}
+//#endregion
 //#region src/components/macros/option-utils.ts
+/** `$var "placeholder"`, the arguments of the input macros. */
 function parseVarArgs(rawArgs) {
-	const match = rawArgs.match(/^\s*(["']?\$[\w.]+["']?)\s*(["'].*["'])?\s*$/s);
-	if (!match) return {
-		varName: rawArgs.trim(),
-		placeholder: ""
-	};
-	const varName = match[1].replace(/["']/g, "");
-	const quoted = match[2];
+	const { variable = "", placeholder = "" } = parseMacroArgs(rawArgs, [{
+		name: "variable",
+		type: "variable"
+	}, {
+		name: "placeholder",
+		type: "string"
+	}]);
 	return {
-		varName,
-		placeholder: quoted ? readWholeQuoted(quoted) ?? quoted.slice(1, -1) : ""
+		varName: variable.replace(/["']/g, ""),
+		placeholder
 	};
 }
 /**
@@ -7662,6 +7788,7 @@ var sharedHooks = {
 	useContext
 };
 function defineMacro(config, source = "builtin") {
+	const parameters = config.parameters ?? [];
 	function Wrapper(props) {
 		let className = props.className;
 		let id = props.id;
@@ -7672,18 +7799,13 @@ function defineMacro(config, source = "builtin") {
 			id = resolve(id);
 		}
 		const { update, getValues } = useContext(LocalsUpdateContext);
-		const nobr = useContext(NobrContext);
-		const inline = useContext(InlineContext);
-		const raw = useContext(RawTextContext);
-		const localsValues = useContext(LocalsValuesContext);
+		const renderOptions = useRenderOptions();
 		const renderNodes$1 = (nodes, options) => renderNodes(nodes, {
-			nobr,
-			inline,
-			raw,
-			locals: localsValues,
+			...renderOptions,
 			...options
 		});
 		const ctx = {
+			args: parseMacroArgs(props.rawArgs, parameters),
 			collectText,
 			sourceLocation: currentSourceLocation,
 			parseVarArgs,
@@ -7714,7 +7836,7 @@ function defineMacro(config, source = "builtin") {
 			ctx.evaluate = (expr) => evaluate(expr, merged[0], merged[1], merged[2], merged[3]);
 		}
 		if (config.storeVar) {
-			const firstToken = props.rawArgs.trim().split(/\s+/)[0]?.replace(/["']/g, "") ?? "";
+			const firstToken = readBoundVariable(props.rawArgs).replace(/["']/g, "");
 			if (firstToken.startsWith("%")) return h("span", { class: "error" }, `{${config.name}}: transient variables (%${firstToken.slice(1)}) cannot be bound to input macros`);
 			const varExpr = firstToken.replace(/["']/g, "").replace(/^\$/, "");
 			const segments = varExpr.split(".");
@@ -7731,7 +7853,11 @@ function defineMacro(config, source = "builtin") {
 		return config.render(props, ctx);
 	}
 	registerMacro(config.name, Wrapper);
-	registerMacroText(config.name, config.text);
+	const text = config.text;
+	registerMacroText(config.name, text && ((props, ctx) => text(props, {
+		...ctx,
+		args: parseMacroArgs(props.rawArgs, parameters)
+	})));
 	const isBlock = config.block === true || config.block !== false && (config.subMacros?.length ?? 0) > 0;
 	registerMacroMetadata(config.name, {
 		name: config.name,
@@ -7741,7 +7867,7 @@ function defineMacro(config, source = "builtin") {
 		interpolate: config.interpolate,
 		merged: config.merged,
 		description: config.description,
-		parameters: config.parameters,
+		parameters: config.parameters && [...config.parameters],
 		source
 	});
 	if (config.subMacros) for (const sub of config.subMacros) registerSubMacro(sub);
@@ -8414,29 +8540,24 @@ defineMacro({
 //#region src/components/macros/Set.tsx
 defineMacro({
 	name: "set",
+	parameters: [{
+		name: "code",
+		type: "expression",
+		required: true
+	}],
 	render({ rawArgs }, ctx) {
-		const ran = ctx.hooks.useRef(false);
-		const failure = ctx.hooks.useRef(null);
-		if (!ran.current) {
-			ran.current = true;
-			try {
-				ctx.mutate(rawArgs);
-			} catch (err) {
-				failure.current = { error: err };
-				console.error(`spindle: Error in {set ${rawArgs}}${ctx.sourceLocation()}:`, err);
-			}
-		}
-		if (failure.current) return /* @__PURE__ */ jsx(MacroError, {
-			macro: "set",
-			error: failure.current.error
-		});
-		return null;
+		return useRunOnce("set", rawArgs, () => ctx.mutate(rawArgs));
 	}
 });
 //#endregion
 //#region src/components/macros/Print.tsx
 defineMacro({
 	name: "print",
+	parameters: [{
+		name: "expression",
+		type: "expression",
+		required: true
+	}],
 	interpolate: true,
 	merged: true,
 	render({ rawArgs }, ctx) {
@@ -8464,30 +8585,16 @@ defineMacro({
 * applied, even `undefined`; a first evaluation that throws leaves it unset.
 */
 var UNSET = Symbol("unset");
-function parseComputedArgs(rawArgs) {
-	const trimmed = rawArgs.trim();
-	let depth = 0;
-	for (let i = 0; i < trimmed.length; i++) {
-		const ch = trimmed[i];
-		if (ch === "(" || ch === "[" || ch === "{") depth++;
-		else if (ch === ")" || ch === "]" || ch === "}") depth--;
-		else if (ch === "=" && depth === 0) {
-			if (trimmed[i + 1] === "=") {
-				i++;
-				continue;
-			}
-			if (i > 0 && trimmed[i - 1] === "!") continue;
-			const target = trimmed.slice(0, i).trim();
-			const expr = trimmed.slice(i + 1).trim();
-			if (!target.match(/^[$_@]\w+$/)) throw new Error(`{computed}: target must be $name, _name, or @name, got "${target}"`);
-			checkVariableName(target.slice(1), target);
-			return {
-				target,
-				expr
-			};
-		}
-	}
-	throw new Error(`{computed}: expected "target = expression", got "${rawArgs}"`);
+/** Check the arguments of "target = expression". */
+function assignmentArgs(rawArgs, args) {
+	if (!args["="]) throw new Error(`{computed}: expected "target = expression", got "${rawArgs}"`);
+	const { target = "", expression: expr = "" } = args;
+	if (!target.match(/^[$_@]\w+$/)) throw new Error(`{computed}: target must be $name, _name, or @name, got "${target}"`);
+	checkVariableName(target.slice(1), target);
+	return {
+		target,
+		expr
+	};
 }
 /**
 * Evaluate `expr` against the current values — the store's state and the
@@ -8504,7 +8611,7 @@ function computeAndApply(expr, name, isTemp, isLocal, getLocals, rawArgs, prevRe
 		const { variables, temporary, transient } = readState();
 		newValue = evaluate(expr, variables, temporary, getLocals(), transient);
 	} catch (err) {
-		console.error(`spindle: Error in {computed ${rawArgs}}${currentSourceLocation()}:`, err);
+		logMacroError(`computed ${rawArgs}`, err);
 		return;
 	}
 	if (!deepEqual(prevRef.current, newValue)) {
@@ -8512,7 +8619,7 @@ function computeAndApply(expr, name, isTemp, isLocal, getLocals, rawArgs, prevRe
 		if (isLocal) try {
 			localsUpdate(name, newValue);
 		} catch (err) {
-			console.error(`spindle: Error in {computed ${rawArgs}}${currentSourceLocation()}:`, err);
+			logMacroError(`computed ${rawArgs}`, err);
 		}
 		else {
 			const state = useStoryStore.getState();
@@ -8524,12 +8631,28 @@ function computeAndApply(expr, name, isTemp, isLocal, getLocals, rawArgs, prevRe
 defineMacro({
 	name: "computed",
 	merged: true,
+	parameters: [
+		{
+			name: "target",
+			type: "variable",
+			required: true
+		},
+		{
+			name: "=",
+			type: "separator"
+		},
+		{
+			name: "expression",
+			type: "expression",
+			required: true
+		}
+	],
 	render({ rawArgs }, ctx) {
 		const [mergedVars, mergedTemps, mergedLocals, mergedTrans] = ctx.merged;
 		let target;
 		let expr;
 		try {
-			({target, expr} = parseComputedArgs(rawArgs));
+			({target, expr} = assignmentArgs(rawArgs, ctx.args));
 		} catch (err) {
 			return /* @__PURE__ */ jsx(MacroError, {
 				macro: "computed",
@@ -8541,14 +8664,13 @@ defineMacro({
 		const name = target.slice(1);
 		const localsUpdate = isLocal ? ctx.update : null;
 		const prevOutput = ctx.hooks.useRef(UNSET);
+		const compute = () => computeAndApply(expr, name, isTemp, isLocal, ctx.getValues, rawArgs, prevOutput, localsUpdate);
 		const ran = ctx.hooks.useRef(false);
 		if (!ran.current) {
 			ran.current = true;
-			computeAndApply(expr, name, isTemp, isLocal, ctx.getValues, rawArgs, prevOutput, localsUpdate);
+			compute();
 		}
-		ctx.hooks.useLayoutEffect(() => {
-			computeAndApply(expr, name, isTemp, isLocal, ctx.getValues, rawArgs, prevOutput, localsUpdate);
-		}, [
+		ctx.hooks.useLayoutEffect(compute, [
 			mergedVars,
 			mergedTemps,
 			mergedLocals,
@@ -8559,26 +8681,13 @@ defineMacro({
 });
 //#endregion
 //#region src/components/macros/Meter.tsx
-/**
-* Parse `{meter currentExpr maxExpr ["label"]}`. Arguments are separated by
-* whitespace outside string and template literals and bracket pairs; a
-* trailing standalone `"…"` or `'…'` string is the label mode, with `\"`,
-* `\'` and `\\` escapes. A string after an operator (`$a ?? "5"`) is an
-* operand of the max expression, not the label.
-*/
-function parseMeterArgs(rawArgs) {
-	const tokens = splitTopLevel(rawArgs.trim(), isWhitespace).filter(Boolean);
-	let labelMode = "";
-	const label = tokens.length >= 2 && !endsWithOperator(tokens.slice(0, -1).join(" ")) ? readWholeQuoted(tokens[tokens.length - 1]) : null;
-	if (label !== null) {
-		labelMode = label;
-		tokens.pop();
-	}
-	if (tokens.length < 2) throw new Error("meter requires two arguments: {meter currentExpr maxExpr}");
+/** Check the arguments of `{meter currentExpr maxExpr ["label"]}`. */
+function meterArgs(args) {
+	if (args.current === void 0 || args.max === void 0) throw new Error("meter requires two arguments: {meter currentExpr maxExpr}");
 	return {
-		currentExpr: tokens[0],
-		maxExpr: tokens.slice(1).join(" "),
-		labelMode
+		currentExpr: args.current,
+		maxExpr: args.max,
+		labelMode: args.label ?? ""
 	};
 }
 function formatLabel(current, max, labelMode) {
@@ -8591,9 +8700,25 @@ defineMacro({
 	name: "meter",
 	interpolate: true,
 	merged: true,
-	render({ rawArgs }, ctx) {
+	parameters: [
+		{
+			name: "current",
+			type: "expression",
+			required: true
+		},
+		{
+			name: "max",
+			type: "expression",
+			required: true
+		},
+		{
+			name: "label",
+			type: "string"
+		}
+	],
+	render(_props, ctx) {
 		try {
-			const { currentExpr, maxExpr, labelMode } = parseMeterArgs(rawArgs);
+			const { currentExpr, maxExpr, labelMode } = meterArgs(ctx.args);
 			const current = Number(ctx.evaluate(currentExpr));
 			const max = Number(ctx.evaluate(maxExpr));
 			const pct = max === 0 ? 0 : Math.max(0, Math.min(100, current / max * 100));
@@ -8698,82 +8823,46 @@ function keyOf(val, ancestors) {
 		if (Array.isArray(val)) return `[${Array.from(val, (v) => keyOf(v, ancestors)).join(",")}]`;
 		if (val instanceof Map) return `Map[${[...val].map(([k, v]) => `[${keyOf(k, ancestors)},${keyOf(v, ancestors)}]`).join(",")}]`;
 		if (val instanceof Set) return `Set[${[...val].map((v) => keyOf(v, ancestors)).join(",")}]`;
-		const record = obj;
-		const body = Object.keys(record).map((k) => `${JSON.stringify(k)}:${keyOf(record[k], ancestors)}`).join(",");
-		const className = registeredClassName(obj);
-		return className === void 0 ? `{${body}}` : `Class(${JSON.stringify(className)}){${body}}`;
-	} finally {
-		ancestors.pop();
-	}
-}
-//#endregion
-//#region src/components/macros/For.tsx
-/**
-* Parse for-loop args: "@item, @i of $list" or "@item of $list"
-*/
-function parseForArgs(rawArgs) {
-	const ofIdx = rawArgs.indexOf(" of ");
-	if (ofIdx === -1) throw new Error(`{for} requires "of" keyword: {for ${rawArgs}}`);
-	const varsPart = rawArgs.slice(0, ofIdx).trim();
-	const listExpr = rawArgs.slice(ofIdx + 4).trim();
-	const vars = varsPart.split(",").map((v) => v.trim());
-	const itemVar = vars[0];
-	const indexVar = vars.length > 1 ? vars[1] : null;
-	if (!itemVar.startsWith("@")) throw new Error(`{for} loop variable must use @ prefix: got "${itemVar}"`);
-	if (indexVar && !indexVar.startsWith("@")) throw new Error(`{for} index variable must use @ prefix: got "${indexVar}"`);
-	checkVariableName(itemVar.slice(1), itemVar);
-	if (indexVar) checkVariableName(indexVar.slice(1), indexVar);
-	return {
-		itemVar: itemVar.slice(1),
-		indexVar: indexVar ? indexVar.slice(1) : null,
-		listExpr
-	};
-}
-function ForIteration({ parentValues, itemVar, itemValue, indexVar, indexValue, children }) {
-	const [localMutations, setLocalMutations] = useState(() => ({}));
-	const ownKeys = useMemo(() => ({
-		[itemVar]: itemValue,
-		...indexVar ? { [indexVar]: indexValue } : void 0
-	}), [
-		itemVar,
-		itemValue,
-		indexVar,
-		indexValue
-	]);
-	const localState = useMemo(() => createNamespace(parentValues, ownKeys, localMutations), [
-		parentValues,
-		ownKeys,
-		localMutations
-	]);
-	const valuesRef = useRef(localState);
-	valuesRef.current = localState;
-	const getValues = useCallback(() => valuesRef.current, []);
-	const update = useCallback((key, value) => {
-		checkVariableName(key, `@${key}`);
-		valuesRef.current = withEntry(valuesRef.current, key, value);
-		setLocalMutations((prev) => ({
-			...prev,
-			[key]: value
-		}));
-	}, []);
-	const updater = useMemo(() => ({
-		update,
-		getValues
-	}), [update, getValues]);
-	const nobr = useContext(NobrContext);
-	const inline = useContext(InlineContext);
-	const raw = useContext(RawTextContext);
-	return /* @__PURE__ */ jsx(LocalsUpdateContext.Provider, {
-		value: updater,
-		children: /* @__PURE__ */ jsx(LocalsValuesContext.Provider, {
-			value: localState,
-			children: renderNodes(children, {
-				nobr,
-				inline,
-				raw,
-				locals: localState
-			})
-		})
+		const record = obj;
+		const body = Object.keys(record).map((k) => `${JSON.stringify(k)}:${keyOf(record[k], ancestors)}`).join(",");
+		const className = registeredClassName(obj);
+		return className === void 0 ? `{${body}}` : `Class(${JSON.stringify(className)}){${body}}`;
+	} finally {
+		ancestors.pop();
+	}
+}
+//#endregion
+//#region src/components/macros/For.tsx
+/**
+* Check the arguments of "@item, @i of $list" or "@item of $list".
+*/
+function loopArgs(rawArgs, args) {
+	if (!args.of) throw new Error(`{for} requires "of" keyword: {for ${rawArgs}}`);
+	const [itemVar = "", indexVar = null] = args.variables ?? [];
+	const listExpr = args.list ?? "";
+	if (!itemVar.startsWith("@")) throw new Error(`{for} loop variable must use @ prefix: got "${itemVar}"`);
+	if (indexVar && !indexVar.startsWith("@")) throw new Error(`{for} index variable must use @ prefix: got "${indexVar}"`);
+	checkVariableName(itemVar.slice(1), itemVar);
+	if (indexVar) checkVariableName(indexVar.slice(1), indexVar);
+	return {
+		itemVar: itemVar.slice(1),
+		indexVar: indexVar ? indexVar.slice(1) : null,
+		listExpr
+	};
+}
+function ForIteration({ parentValues, itemVar, itemValue, indexVar, indexValue, children }) {
+	return /* @__PURE__ */ jsx(LocalsScope, {
+		body: children,
+		parentValues,
+		ownKeys: useMemo(() => ({
+			[itemVar]: itemValue,
+			...indexVar ? { [indexVar]: indexValue } : void 0
+		}), [
+			itemVar,
+			itemValue,
+			indexVar,
+			indexValue
+		])
 	});
 }
 defineMacro({
@@ -8781,21 +8870,29 @@ defineMacro({
 	block: true,
 	interpolate: true,
 	merged: true,
+	parameters: [
+		{
+			name: "variables",
+			type: "names",
+			required: true
+		},
+		{
+			name: "of",
+			type: "separator"
+		},
+		{
+			name: "list",
+			type: "expression",
+			required: true
+		}
+	],
 	render({ rawArgs, children = [] }, ctx) {
 		const parentValues = useContext(LocalsValuesContext);
-		let parsed;
-		try {
-			parsed = parseForArgs(rawArgs);
-		} catch (err) {
-			return /* @__PURE__ */ jsx(MacroError, {
-				macro: "for",
-				error: err
-			});
-		}
-		const { itemVar, indexVar, listExpr } = parsed;
+		let loop;
 		let list;
 		try {
-			const result = ctx.evaluate(listExpr);
+			loop = loopArgs(rawArgs, ctx.args);
+			const result = ctx.evaluate(loop.listExpr);
 			if (!Array.isArray(result)) return /* @__PURE__ */ jsx("span", {
 				class: "error",
 				children: `{for error: expression did not evaluate to an array}`
@@ -8807,6 +8904,7 @@ defineMacro({
 				error: err
 			});
 		}
+		const { itemVar, indexVar } = loop;
 		const content = list.map((item, i) => /* @__PURE__ */ jsx(ForIteration, {
 			parentValues,
 			itemVar,
@@ -8818,7 +8916,7 @@ defineMacro({
 		return ctx.wrap(content);
 	},
 	text({ rawArgs, children = [] }, ctx) {
-		const { itemVar, indexVar, listExpr } = parseForArgs(rawArgs);
+		const { itemVar, indexVar, listExpr } = loopArgs(rawArgs, ctx.args);
 		const list = ctx.evaluate(listExpr);
 		if (!Array.isArray(list)) throw new Error("expression did not evaluate to an array");
 		return list.map((item, i) => ctx.renderText(children, {
@@ -8838,7 +8936,7 @@ defineMacro({
 			try {
 				ctx.mutate(code);
 			} catch (err) {
-				console.error(`spindle: Error in {do}${ctx.sourceLocation()}:`, err);
+				logMacroError("do", err);
 			}
 		}, []);
 		return null;
@@ -8857,7 +8955,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);
@@ -8869,27 +8967,20 @@ function liveLocalsView(getValues) {
 	});
 }
 //#endregion
-//#region src/utils/parse-delay.ts
-/**
-* Parse a delay string into milliseconds.
-* Supports: "2s" → 2000, "500ms" → 500, bare number → ms
-*/
-function parseDelay(str) {
-	const trimmed = str.trim();
-	if (trimmed.endsWith("ms")) return parseFloat(trimmed.slice(0, -2));
-	if (trimmed.endsWith("s")) return parseFloat(trimmed.slice(0, -1)) * 1e3;
-	return parseFloat(trimmed);
-}
-//#endregion
 //#region src/components/macros/Repeat.tsx
 var RepeatContext = createContext({ stop: () => {} });
 defineMacro({
 	name: "repeat",
 	block: true,
 	interpolate: true,
-	render({ rawArgs, children = [] }, ctx) {
+	parameters: [{
+		name: "delay",
+		type: "delay",
+		required: true
+	}],
+	render({ children = [] }, ctx) {
 		const { useState, useEffect, useCallback } = ctx.hooks;
-		const delay = parseDelay(rawArgs);
+		const delay = ctx.args.delay ?? 0;
 		const [count, setCount] = useState(0);
 		const [stopped, setStopped] = useState(false);
 		const stop = useCallback(() => setStopped(true), []);
@@ -8936,8 +9027,7 @@ defineMacro({
 */
 function useDetachedBody() {
 	const updater = useContext(LocalsUpdateContext);
-	const nobr = useContext(NobrContext);
-	const inline = useContext(InlineContext);
+	const { nobr, inline } = useRenderOptions();
 	const widgetChildren = useContext(WidgetChildrenContext);
 	const repeat = useContext(RepeatContext);
 	const closeDialog = useContext(DialogCloseContext);
@@ -8980,9 +9070,13 @@ defineMacro({
 	name: "button",
 	block: true,
 	interpolate: true,
+	parameters: [{
+		name: "label",
+		type: "text",
+		required: true
+	}],
 	render({ rawArgs, children = [] }, ctx) {
-		const text = readWholeQuoted(rawArgs.trim()) ?? rawArgs.replace(/^["']|["']$/g, "");
-		const label = ctx.resolve?.(text) ?? rawArgs;
+		const label = ctx.resolve?.(ctx.args.label ?? "") ?? rawArgs;
 		const runBody = useDetachedBody();
 		const handleClick = () => runBody(children);
 		ctx.useAction({
@@ -9002,30 +9096,22 @@ defineMacro({
 });
 //#endregion
 //#region src/components/macros/MacroLink.tsx
-function parseLinkArgs(rawArgs) {
-	const parts = [];
-	const re = /(["'])((?:\\[^]|(?!\1)[^\\])*)\1/g;
-	let m;
-	while ((m = re.exec(rawArgs)) !== null) parts.push(unescapeQuoted(m[2]));
-	if (parts.length >= 2) return {
-		display: parts[0],
-		passage: parts[1]
-	};
-	if (parts.length === 1) return {
-		display: parts[0],
-		passage: null
-	};
-	return {
-		display: rawArgs.trim(),
-		passage: null
-	};
-}
 defineMacro({
 	name: "link",
 	block: true,
 	interpolate: true,
+	parameters: [{
+		name: "text",
+		type: "string",
+		required: true
+	}, {
+		name: "passage",
+		type: "string"
+	}],
 	render({ rawArgs, children = [] }, ctx) {
-		const { display, passage } = parseLinkArgs(rawArgs);
+		const { text } = ctx.args;
+		const display = text ?? rawArgs.trim();
+		const passage = text === void 0 ? null : ctx.args.passage ?? null;
 		const runBody = useDetachedBody();
 		const perform = () => {
 			runBody(children);
@@ -9054,9 +9140,27 @@ defineMacro({
 });
 //#endregion
 //#region src/components/macros/Switch.tsx
+/**
+* The first {case} branch whose value equals `value`, else the {default}
+* branch, else null. Throws what a case expression throws.
+*/
+function selectBranch(value, branches, evaluate) {
+	let defaultBranch = null;
+	for (let i = 1; i < branches.length; i++) {
+		const branch = branches[i];
+		if (branch.rawArgs === "") defaultBranch = branch;
+		else if (value === evaluate(branch.rawArgs)) return branch;
+	}
+	return defaultBranch;
+}
 defineMacro({
 	name: "switch",
 	subMacros: ["case", "default"],
+	parameters: [{
+		name: "expression",
+		type: "expression",
+		required: true
+	}],
 	merged: true,
 	render({ rawArgs, branches = [] }, ctx) {
 		let switchValue;
@@ -9068,35 +9172,20 @@ defineMacro({
 				error: err
 			});
 		}
-		let defaultBranch = null;
-		for (let i = 1; i < branches.length; i++) {
-			const branch = branches[i];
-			if (branch.rawArgs === "") {
-				defaultBranch = branch;
-				continue;
-			}
-			try {
-				const caseValue = ctx.evaluate(branch.rawArgs);
-				if (switchValue === caseValue) return /* @__PURE__ */ jsx(Fragment$1, { children: ctx.renderNodes(branch.children) });
-			} catch (err) {
-				return /* @__PURE__ */ jsx(MacroError, {
-					macro: "case",
-					error: err
-				});
-			}
+		let branch;
+		try {
+			branch = selectBranch(switchValue, branches, ctx.evaluate);
+		} catch (err) {
+			return /* @__PURE__ */ jsx(MacroError, {
+				macro: "case",
+				error: err
+			});
 		}
-		if (defaultBranch) return /* @__PURE__ */ jsx(Fragment$1, { children: ctx.renderNodes(defaultBranch.children) });
-		return null;
+		return branch && /* @__PURE__ */ jsx(Fragment$1, { children: ctx.renderNodes(branch.children) });
 	},
 	text({ rawArgs, branches = [] }, ctx) {
-		const switchValue = ctx.evaluate(rawArgs);
-		let defaultBranch = null;
-		for (let i = 1; i < branches.length; i++) {
-			const branch = branches[i];
-			if (branch.rawArgs === "") defaultBranch = branch;
-			else if (switchValue === ctx.evaluate(branch.rawArgs)) return ctx.renderText(branch.children);
-		}
-		return defaultBranch ? ctx.renderText(defaultBranch.children) : "";
+		const branch = selectBranch(ctx.evaluate(rawArgs), branches, ctx.evaluate);
+		return branch ? ctx.renderText(branch.children) : "";
 	}
 });
 //#endregion
@@ -9156,9 +9245,14 @@ defineMacro({
 	name: "type",
 	block: true,
 	interpolate: true,
-	render({ rawArgs, children = [] }, ctx) {
+	parameters: [{
+		name: "delay",
+		type: "delay",
+		required: true
+	}],
+	render({ children = [] }, ctx) {
 		const { useState, useEffect, useRef } = ctx.hooks;
-		const speed = parseDelay(rawArgs);
+		const speed = ctx.args.delay ?? 0;
 		const containerRef = useRef(null);
 		const [totalChars, setTotalChars] = useState(0);
 		const [visibleChars, setVisibleChars] = useState(0);
@@ -9339,11 +9433,18 @@ defineMacro({
 	name: "dialog",
 	block: true,
 	interpolate: true,
-	render({ rawArgs, children = [] }, ctx) {
+	parameters: [{
+		name: "label",
+		type: "text",
+		required: true
+	}, {
+		name: "noclose",
+		type: "flag"
+	}],
+	render({ children = [] }, ctx) {
 		const [open, setOpen] = ctx.hooks.useState(false);
-		const noclose = /\bnoclose\s*$/.test(rawArgs);
-		const labelRaw = rawArgs.replace(/\bnoclose\s*$/, "").trim();
-		const label = ctx.resolve?.(readWholeQuoted(labelRaw) ?? labelRaw.replace(/^["']|["']$/g, "")) ?? labelRaw;
+		const { noclose } = ctx.args;
+		const label = ctx.resolve(ctx.args.label ?? "");
 		const passageName = ctx.collectText(children).trim().replace(/^["']|["']$/g, "");
 		return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("button", {
 			id: ctx.id,
@@ -9750,59 +9851,22 @@ defineMacro({
 });
 //#endregion
 //#region src/components/macros/Include.tsx
-var FLAG = "inline";
-/**
-* Split a standalone `inline` flag off the start or end of the include
-* arguments. The flag only counts outside quotes, brackets, parentheses and
-* braces, separated by whitespace from the target expression, so passage
-* names and expressions containing the word stay intact (#201).
-*/
-function parseIncludeArgs(rawArgs) {
-	const trimmed = rawArgs.trim();
-	const spaces = topLevelIndices(trimmed, isWhitespace);
-	let first = null;
-	let last = null;
-	if (spaces.length > 0) {
-		let s = 0;
-		while (s + 1 < spaces.length && spaces[s + 1] === spaces[s] + 1) s++;
-		first = [spaces[0], spaces[s] + 1];
-		let e = spaces.length - 1;
-		while (e > 0 && spaces[e - 1] === spaces[e] - 1) e--;
-		last = [spaces[e], spaces[spaces.length - 1] + 1];
-	}
-	if (last && last[1] === trimmed.length - 6 && trimmed.endsWith(FLAG)) {
-		const rest = trimmed.slice(0, last[0]);
-		if (!endsWithOperator(rest)) return {
-			nameExpr: rest,
-			inline: true
-		};
-	}
-	if (first && first[0] === 6 && trimmed.startsWith(FLAG)) {
-		const rest = trimmed.slice(first[1]);
-		if (!/^(?:[-+*/&|^=<>?:,.]|%(?![A-Za-z_]))/.test(rest)) return {
-			nameExpr: rest,
-			inline: true
-		};
-	}
-	return {
-		nameExpr: trimmed,
-		inline: false
-	};
-}
 defineMacro({
 	name: "include",
 	interpolate: true,
 	merged: true,
-	render({ rawArgs }, ctx) {
+	parameters: [{
+		name: "inline",
+		type: "flag"
+	}, {
+		name: "passage",
+		type: "expression",
+		required: true
+	}],
+	render(_props, ctx) {
 		const storyData = useStoryStore((s) => s.storyData);
-		const { nameExpr, inline } = parseIncludeArgs(rawArgs);
-		let passageName;
-		try {
-			const result = ctx.evaluate(nameExpr);
-			passageName = String(result);
-		} catch {
-			passageName = nameExpr.replace(/^["']|["']$/g, "");
-		}
+		const { inline } = ctx.args;
+		const passageName = evaluatePassageName(ctx.args.passage, ctx.evaluate);
 		const passage = storyData?.passages.get(passageName);
 		const ast = ctx.hooks.useMemo(() => passage ? buildAST(tokenize(passage.content)) : null, [passage]);
 		if (!storyData) return null;
@@ -9832,16 +9896,14 @@ defineMacro({
 defineMacro({
 	name: "goto",
 	merged: true,
-	render({ rawArgs }, ctx) {
+	parameters: [{
+		name: "passage",
+		type: "expression",
+		required: true
+	}],
+	render(_props, ctx) {
 		ctx.hooks.useLayoutEffect(() => {
-			let passageName;
-			try {
-				const result = ctx.evaluate(rawArgs);
-				passageName = String(result);
-			} catch {
-				passageName = rawArgs.replace(/^["']|["']$/g, "");
-			}
-			useStoryStore.getState().navigate(passageName);
+			useStoryStore.getState().navigate(evaluatePassageName(ctx.args.passage, ctx.evaluate));
 		}, []);
 		return null;
 	}
@@ -9850,124 +9912,90 @@ defineMacro({
 //#region src/components/macros/Unset.tsx
 defineMacro({
 	name: "unset",
+	parameters: [{
+		name: "variable",
+		type: "variable",
+		required: true
+	}],
 	render({ rawArgs }, ctx) {
-		const ran = ctx.hooks.useRef(false);
-		const failure = ctx.hooks.useRef(null);
-		if (!ran.current) {
-			ran.current = true;
+		return useRunOnce("unset", rawArgs, () => {
 			const state = useStoryStore.getState();
-			const name = rawArgs.trim();
-			try {
-				if (name.startsWith("$")) state.deleteVariable(name.slice(1));
-				else if (name.startsWith("_")) state.deleteTemporary(name.slice(1));
-				else if (name.startsWith("%")) state.deleteTransient(name.slice(1));
-				else if (name.startsWith("@")) ctx.update(name.slice(1), void 0);
-				else throw new Error(`{unset} expects a variable ($name, _name, %name, or @name), got "${name}"`);
-			} catch (err) {
-				failure.current = { error: err };
-				console.error(`spindle: Error in {unset ${rawArgs}}${ctx.sourceLocation()}:`, err);
-			}
-		}
-		if (failure.current) return /* @__PURE__ */ jsx(MacroError, {
-			macro: "unset",
-			error: failure.current.error
+			const name = ctx.args.variable ?? "";
+			if (name.startsWith("$")) state.deleteVariable(name.slice(1));
+			else if (name.startsWith("_")) state.deleteTemporary(name.slice(1));
+			else if (name.startsWith("%")) state.deleteTransient(name.slice(1));
+			else if (name.startsWith("@")) ctx.update(name.slice(1), void 0);
+			else throw new Error(`{unset} expects a variable ($name, _name, %name, or @name), got "${name}"`);
 		});
-		return null;
 	}
 });
 //#endregion
+//#region src/components/macros/input-macro.ts
+/**
+* Define a text input macro, `{name $var "placeholder"}`: an `<input>` of
+* `type` (or, without one, a `<textarea>`) bound to the story variable.
+* `toValue` turns what the reader types, or an automation action's value
+* (`undefined` when it has none), into the variable's value: by default,
+* the text.
+*/
+function defineInputMacro(name, type, toValue = (input) => input !== void 0 ? String(input) : "") {
+	defineMacro({
+		name,
+		storeVar: true,
+		parameters: [{
+			name: "variable",
+			type: "variable",
+			required: true
+		}, {
+			name: "placeholder",
+			type: "string"
+		}],
+		render(_props, ctx) {
+			const placeholder = ctx.args.placeholder ?? "";
+			ctx.useAction({
+				type: name,
+				key: `$${ctx.varName}`,
+				authorId: ctx.id,
+				label: placeholder || ctx.varName,
+				variable: ctx.varName,
+				value: ctx.value,
+				perform: (v) => ctx.setValue(toValue(v))
+			});
+			return h(type ? "input" : "textarea", {
+				type,
+				id: ctx.id,
+				class: ctx.cls,
+				value: ctx.value == null ? "" : String(ctx.value),
+				placeholder,
+				onInput: (e) => ctx.setValue(toValue(e.target.value))
+			});
+		}
+	});
+}
+//#endregion
 //#region src/components/macros/Textbox.tsx
-defineMacro({
-	name: "textbox",
-	storeVar: true,
-	render({ rawArgs }, ctx) {
-		const { placeholder } = ctx.parseVarArgs(rawArgs);
-		ctx.useAction({
-			type: "textbox",
-			key: `$${ctx.varName}`,
-			authorId: ctx.id,
-			label: placeholder || ctx.varName,
-			variable: ctx.varName,
-			value: ctx.value,
-			perform: (v) => ctx.setValue(v !== void 0 ? String(v) : "")
-		});
-		return /* @__PURE__ */ jsx("input", {
-			type: "text",
-			id: ctx.id,
-			class: ctx.cls,
-			value: ctx.value == null ? "" : String(ctx.value),
-			placeholder,
-			onInput: (e) => ctx.setValue(e.target.value)
-		});
-	}
-});
+defineInputMacro("textbox", "text");
 //#endregion
 //#region src/components/macros/Numberbox.tsx
-defineMacro({
-	name: "numberbox",
-	storeVar: true,
-	render({ rawArgs }, ctx) {
-		const { placeholder } = ctx.parseVarArgs(rawArgs);
-		ctx.useAction({
-			type: "numberbox",
-			key: `$${ctx.varName}`,
-			authorId: ctx.id,
-			label: placeholder || ctx.varName,
-			variable: ctx.varName,
-			value: ctx.value,
-			perform: (v) => ctx.setValue(v !== void 0 ? Number(v) : 0)
-		});
-		return /* @__PURE__ */ jsx("input", {
-			type: "number",
-			id: ctx.id,
-			class: ctx.cls,
-			value: ctx.value == null ? "" : String(ctx.value),
-			placeholder,
-			onInput: (e) => {
-				const val = e.target.value;
-				ctx.setValue(val === "" ? 0 : Number(val));
-			}
-		});
-	}
-});
+defineInputMacro("numberbox", "number", (v) => v !== void 0 ? Number(v) : 0);
 //#endregion
 //#region src/components/macros/Textarea.tsx
-defineMacro({
-	name: "textarea",
-	storeVar: true,
-	render({ rawArgs }, ctx) {
-		const { placeholder } = ctx.parseVarArgs(rawArgs);
-		ctx.useAction({
-			type: "textarea",
-			key: `$${ctx.varName}`,
-			authorId: ctx.id,
-			label: placeholder || ctx.varName,
-			variable: ctx.varName,
-			value: ctx.value,
-			perform: (v) => ctx.setValue(v !== void 0 ? String(v) : "")
-		});
-		return /* @__PURE__ */ jsx("textarea", {
-			id: ctx.id,
-			class: ctx.cls,
-			value: ctx.value == null ? "" : String(ctx.value),
-			placeholder,
-			onInput: (e) => ctx.setValue(e.target.value)
-		});
-	}
-});
+defineInputMacro("textarea");
 //#endregion
 //#region src/components/macros/Checkbox.tsx
-function parseCheckboxLabel(rawArgs) {
-	const match = rawArgs.match(/^\s*["']?\$?[\w.]+["']?\s+(.+)$/s);
-	if (!match) return "";
-	const rest = match[1].trimEnd() || match[1];
-	return readWholeQuoted(rest) ?? stripLooseQuotes(rest);
-}
 defineMacro({
 	name: "checkbox",
 	storeVar: true,
-	render({ rawArgs }, ctx) {
-		const label = parseCheckboxLabel(rawArgs);
+	parameters: [{
+		name: "variable",
+		type: "variable",
+		required: true
+	}, {
+		name: "label",
+		type: "text"
+	}],
+	render(_props, ctx) {
+		const label = ctx.args.label ?? "";
 		ctx.useAction({
 			type: "checkbox",
 			key: `$${ctx.varName}`,
@@ -9990,38 +10018,28 @@ defineMacro({
 });
 //#endregion
 //#region src/components/macros/Radiobutton.tsx
-function parseRadioArgs(rawArgs) {
-	const head = rawArgs.match(/^\s*["']?\$?[\w.]+["']?\s+/);
-	if (head) {
-		const rest = rawArgs.slice(head[0].length).trim();
-		const value = readQuoted(rest, 0);
-		if (value && (value.end === rest.length || isWhitespace(rest[value.end]))) {
-			const labelRaw = rest.slice(value.end).trim();
-			const label = readWholeQuoted(labelRaw) ?? stripLooseQuotes(labelRaw);
-			return {
-				value: value.value,
-				label
-			};
-		}
-	}
-	const match = rawArgs.match(/^\s*["']?\$?[\w.]+["']?\s+["'](.+?)["']\s+["']?(.+?)["']?\s*$/s);
-	if (!match) {
-		const parts = rawArgs.trim().split(/\s+/).slice(1);
-		return {
-			value: parts[0] ?? "",
-			label: parts.slice(1).join(" ")
-		};
-	}
-	return {
-		value: match[1],
-		label: match[2]
-	};
-}
 defineMacro({
 	name: "radiobutton",
 	storeVar: true,
-	render({ rawArgs }, ctx) {
-		const { value: radioValue, label } = parseRadioArgs(rawArgs);
+	parameters: [
+		{
+			name: "variable",
+			type: "variable",
+			required: true
+		},
+		{
+			name: "value",
+			type: "text",
+			required: true
+		},
+		{
+			name: "label",
+			type: "text"
+		}
+	],
+	render(_props, ctx) {
+		const radioValue = ctx.args.value ?? "";
+		const label = ctx.args.label ?? "";
 		ctx.useAction({
 			type: "radiobutton",
 			key: `$${ctx.varName}:${radioValue}`,
@@ -10049,6 +10067,11 @@ defineMacro({
 	name: "listbox",
 	subMacros: ["option"],
 	storeVar: true,
+	parameters: [{
+		name: "variable",
+		type: "variable",
+		required: true
+	}],
 	render({ children = [] }, ctx) {
 		const options = ctx.extractOptions(children);
 		ctx.useAction({
@@ -10081,6 +10104,11 @@ defineMacro({
 	name: "cycle",
 	block: true,
 	storeVar: true,
+	parameters: [{
+		name: "variable",
+		type: "variable",
+		required: true
+	}],
 	render({ children = [] }, ctx) {
 		const options = ctx.extractOptions(children);
 		const handleClick = () => {
@@ -10317,6 +10345,16 @@ function setCSSProperties(el, config) {
 	el.style.setProperty("--passage-pause", `${config.pause / 1e3}s`);
 }
 /**
+* Set up `containerEl` for an outgoing transition and snapshot the passage
+* it shows, or return null if there is no container or passage.
+*/
+function snapshotPassage(containerEl, config) {
+	if (!containerEl) return null;
+	setCSSProperties(containerEl, config);
+	const passageEl = containerEl.querySelector(".passage");
+	return passageEl ? createSnapshot(passageEl, config.type) : null;
+}
+/**
 * Remove all snapshot elements and crossfading class from a container.
 */
 function cleanupSnapshots(containerEl) {
@@ -10384,18 +10422,12 @@ defineMacro({
 				setDisplayedPassage(currentPassage);
 				return;
 			}
+			const snapshot = config.type === "fade-through" || config.type === "crossfade" ? snapshotPassage(containerEl, config) : null;
+			if (!containerEl || !snapshot) {
+				setDisplayedPassage(currentPassage);
+				return;
+			}
 			if (config.type === "fade-through") {
-				if (!containerEl) {
-					setDisplayedPassage(currentPassage);
-					return;
-				}
-				setCSSProperties(containerEl, config);
-				const passageEl = containerEl.querySelector(".passage");
-				if (!passageEl) {
-					setDisplayedPassage(currentPassage);
-					return;
-				}
-				const snapshot = createSnapshot(passageEl, config.type);
 				containerEl.appendChild(snapshot);
 				setDisplayedPassage("");
 				const incomingDelay = config.duration + config.pause;
@@ -10408,27 +10440,12 @@ defineMacro({
 				}, cleanupDelay)];
 				return;
 			}
-			if (config.type === "crossfade") {
-				if (!containerEl) {
-					setDisplayedPassage(currentPassage);
-					return;
-				}
-				setCSSProperties(containerEl, config);
-				const passageEl = containerEl.querySelector(".passage");
-				if (!passageEl) {
-					setDisplayedPassage(currentPassage);
-					return;
-				}
-				const snapshot = createSnapshot(passageEl, config.type);
-				containerEl.classList.add("passage-container--crossfading");
-				containerEl.appendChild(snapshot);
-				setDisplayedPassage(currentPassage);
-				timeoutsRef.current = [setTimeout(() => {
-					cleanupSnapshots(containerEl);
-				}, config.duration)];
-				return;
-			}
+			containerEl.classList.add("passage-container--crossfading");
+			containerEl.appendChild(snapshot);
 			setDisplayedPassage(currentPassage);
+			timeoutsRef.current = [setTimeout(() => {
+				cleanupSnapshots(containerEl);
+			}, config.duration)];
 		}, [navigationId]);
 		const effectivePassage = renderDeferred ? storyData?.passages.get("StoryLoading") ?? null : displayedPassage ? storyData?.passages.get(displayedPassage) : null;
 		if (!effectivePassage && displayedPassage && !renderDeferred) return /* @__PURE__ */ jsxs("div", {
@@ -10460,87 +10477,46 @@ defineMacro({
 });
 //#endregion
 //#region src/components/macros/Watch.tsx
-var WORD_RE = /\w+/y;
-var DIGITS_RE = /\d+/y;
-/** Match the sticky regex `re` at `pos`, returning the matched text. */
-function matchAt(re, src, pos) {
-	re.lastIndex = pos;
-	return re.exec(src)?.[0] ?? null;
-}
-/**
-* Parse `{watch "condition" keyword value …}`: a quoted condition followed
-* by keyword options (`goto "X"`, `dialog "X"`, `run "X"`, `name "X"`,
-* `priority N`, `once`). Quoted strings accept `\"`, `\'` and `\\` escapes.
-* Returns `null` when the arguments do not start with a quoted condition.
-*/
-function parseWatchArgs(rawArgs) {
-	const raw = rawArgs.trim();
-	const cond = readQuoted(raw, 0);
-	if (!cond) return null;
-	const options = {};
-	let i = cond.end;
-	while (i < raw.length) {
-		const key = matchAt(WORD_RE, raw, i);
-		if (!key) {
-			i = readQuoted(raw, i)?.end ?? i + 1;
-			continue;
-		}
-		i += key.length;
-		let val;
-		let j = i;
-		while (j < raw.length && isWhitespace(raw[j])) j++;
-		if (j > i) {
-			const quoted = readQuoted(raw, j);
-			const digits = quoted ? null : matchAt(DIGITS_RE, raw, j);
-			if (quoted) {
-				val = quoted.value;
-				i = quoted.end;
-			} else if (digits) {
-				val = digits;
-				i = j + digits.length;
-			}
-		}
-		switch (key) {
-			case "goto":
-				options.goto = val;
-				break;
-			case "dialog":
-				options.dialog = val;
-				break;
-			case "run":
-				options.run = val;
-				break;
-			case "name":
-				options.name = val;
-				break;
-			case "priority":
-				options.priority = val ? Number(val) : 0;
-				break;
-			case "once":
-				options.once = true;
-				break;
-		}
-	}
-	return {
-		condition: cond.value,
-		options
-	};
-}
-/**
-* Parse the watcher name of `{unwatch "name"}`: a quoted string, with the
-* same escapes as `{watch}`, or a bare name.
-*/
-function parseUnwatchName(rawArgs) {
-	const raw = rawArgs.trim();
-	return readWholeQuoted(raw) ?? raw.replace(/^['"]|['"]$/g, "");
-}
 defineMacro({
 	name: "watch",
-	render(props, ctx) {
+	parameters: [{
+		name: "condition",
+		type: "string",
+		required: true
+	}, {
+		name: "options",
+		type: "options",
+		parameters: [
+			{
+				name: "goto",
+				type: "string"
+			},
+			{
+				name: "dialog",
+				type: "string"
+			},
+			{
+				name: "run",
+				type: "string"
+			},
+			{
+				name: "name",
+				type: "string"
+			},
+			{
+				name: "priority",
+				type: "number"
+			},
+			{
+				name: "once",
+				type: "flag"
+			}
+		]
+	}],
+	render(_props, ctx) {
 		const { hooks } = ctx;
-		const parsed = parseWatchArgs(props.rawArgs);
-		if (!parsed) return null;
-		const { condition, options } = parsed;
+		const { condition, options } = ctx.args;
+		if (condition === void 0) return null;
 		const registered = hooks.useRef(false);
 		if (!registered.current) {
 			registered.current = true;
@@ -10551,8 +10527,13 @@ defineMacro({
 });
 defineMacro({
 	name: "unwatch",
-	render(props, ctx) {
-		const name = parseUnwatchName(props.rawArgs);
+	parameters: [{
+		name: "name",
+		type: "text",
+		required: true
+	}],
+	render(_props, ctx) {
+		const name = ctx.args.name ?? "";
 		const ran = ctx.hooks.useRef(false);
 		if (!ran.current) {
 			ran.current = true;