@rohal12/spindle 0.52.4 → 0.52.5

package/dist/pkg/headless.js

@@ -32,28 +32,192 @@ function create() {
 	return (initializer) => bindPreact(createStore()(initializer));
 }
 //#endregion
-//#region src/class-registry.ts
-var registry$1 = /* @__PURE__ */ new Map();
-var ctorToName = /* @__PURE__ */ new Map();
-function registerClass(name, ctor) {
-	registry$1.set(name, ctor);
-	ctorToName.set(ctor, name);
+//#region src/utils/namespace.ts
+/** The variable name no namespace can hold. */
+var RESERVED_NAME = "__proto__";
+/**
+* Why `name` (without its sigil) cannot be a variable name, or undefined if
+* it can. `label` is the name as the author wrote it (e.g. `$__proto__`).
+*/
+function variableNameError(name, label = name) {
+	return name === "__proto__" ? `"${label}" cannot be used as a variable name (${RESERVED_NAME} is reserved)` : void 0;
+}
+/** Throw a TypeError if `name` cannot be a variable name. */
+function checkVariableName(name, label = name) {
+	const error = variableNameError(name, label);
+	if (error) throw new TypeError(`spindle: ${error}`);
 }
+/** Whether `obj` holds `key` as an own property. */
+var hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+/** `ns[key]` if `ns` holds it as an own property, else undefined. */
+var ownValue = (ns, key) => ns && hasOwn(ns, key) ? ns[key] : void 0;
 /**
-* The registered name of the class `value` is an instance of, or undefined.
-* Looks the constructor up on the prototype, so an own property named
-* "constructor" (plain data) cannot hide or fake the class.
+* A record with no prototype holding the own entries of `sources`, or only
+* those whose value passes `keep`.
 */
-function registeredClassName(value) {
-	const proto = Object.getPrototypeOf(value);
-	return proto === null ? void 0 : ctorToName.get(proto.constructor);
+function ownEntries(sources, keep = () => true) {
+	const record = Object.create(null);
+	for (const source of sources) {
+		if (!source) continue;
+		for (const key of Object.keys(source)) {
+			const value = source[key];
+			if (keep(value)) record[key] = value;
+		}
+	}
+	return record;
 }
-function isPlainObject(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const proto = Object.getPrototypeOf(value);
-	return proto === Object.prototype || proto === null;
+/** A namespace with no prototype holding the own entries of `sources`. */
+var createNamespace = (...sources) => ownEntries(sources);
+/** Whether `value` is an object with no prototype. */
+var isNamespace = (value) => Object.getPrototypeOf(value) === null;
+/** `ns` itself if it has no prototype, else a namespace copy of it. */
+var asNamespace = (ns) => isNamespace(ns) ? ns : createNamespace(ns);
+/** A namespace copy of `ns` with `key` set to `value`. */
+function withEntry(ns, key, value) {
+	const next = createNamespace(ns);
+	next[key] = value;
+	return next;
+}
+/** An empty namespace that cannot change. */
+var EMPTY_NAMESPACE = Object.freeze(createNamespace());
+/** The names whose own entries differ between `a` and `b`, `a`'s first. */
+function changedNames(a, b) {
+	return [...new Set([...Object.keys(a), ...Object.keys(b)])].filter((name) => ownValue(a, name) !== ownValue(b, name));
+}
+var isCount = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
+/** The count of `name` in `counts`: its own entry, or 0. */
+function countOf(counts, name) {
+	const value = ownValue(counts, name);
+	return isCount(value) ? value : 0;
+}
+/**
+* Counters with no prototype holding the own entries of `source` that are
+* counts, with `name` (if given) counted once more. Immer copies the
+* counters on every write anyway, so counting into a fresh copy costs no
+* more than counting in place.
+*/
+function createCounts(source, name) {
+	const counts = ownEntries([source], isCount);
+	if (name !== void 0) counts[name] = countOf(source, name) + 1;
+	return counts;
+}
+//#endregion
+//#region src/utils/object-path.ts
+/**
+* Traverse dot-path segments on an object and return the nested value.
+* Members of Object.prototype (`constructor`, `toString`, `__proto__`, ...)
+* are not story state: unless an object holds one as its own property, it
+* reads as missing, as setByPath() treats it. Other inherited properties
+* (class getters, `size` of a Map) are read.
+*/
+function getByPath(obj, segments) {
+	let current = obj;
+	for (const seg of segments) {
+		if (current == null || typeof current !== "object") return void 0;
+		if (seg in Object.prototype && !hasOwn(current, seg)) return void 0;
+		current = current[seg];
+	}
+	return current;
+}
+/** Array indices ("0", "1", …) and "length": the keys an array holds. */
+var isArrayKey = (key) => key === "length" || /^(0|[1-9]\d*)$/.test(key);
+/**
+* Built-ins whose content is not their properties: a property written into
+* one would be dropped by clones and saves (and by Immer, for Map and Set).
+*/
+var builtinName = (value) => value instanceof Map ? "a Map" : value instanceof Set ? "a Set" : value instanceof Date ? "a Date" : value instanceof RegExp ? "a RegExp" : void 0;
+/**
+* Shallow copy that keeps the prototype, so a registered class instance
+* stays an instance of its class (with the same own keys deepClone copies).
+*/
+function shallowCopy(value) {
+	const copy = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value));
+	for (const key of Object.keys(value)) Object.defineProperty(copy, key, {
+		value: value[key],
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	return copy;
 }
 /**
+* Set a value at dot-path `segments` below `root`.
+*
+* When `root` is an Immer draft, objects Immer does not draft (registered
+* class instances and everything below them) are copied on the way down and
+* the copy is assigned to its parent, so the write produces new references
+* up to the root. Writing into such an object directly would mutate the
+* instance shared with the previous state and with history, and subscribers
+* would see no change. Outside a draft (a private working copy) the path is
+* written in place.
+*
+* The path goes through own properties of plain objects, class instances
+* and arrays (by index); anything else throws a TypeError rather than
+* writing where no clone or save would see it: an inherited property such
+* as a method counts as missing, and Map, Set, Date and RegExp values and
+* other keys of arrays are refused, as is a "__proto__" segment.
+*/
+function setByPath(root, segments, value, options = {}) {
+	const parent = walkToParent(root, segments, options.createMissing ?? false);
+	parent[segments[segments.length - 1]] = value;
+}
+/**
+* Delete the property at dot-path `segments` below `root`, copying
+* undrafted objects on the way down like setByPath(). Does nothing when an
+* intermediate is missing or not an object, or the property is absent (or
+* only inherited).
+*/
+function deleteByPath(root, segments) {
+	const last = segments[segments.length - 1];
+	checkSegments(segments);
+	let holder = root;
+	for (const seg of segments.slice(0, -1)) {
+		if (holder == null || typeof holder !== "object" || !hasOwn(holder, seg)) return;
+		holder = holder[seg];
+	}
+	if (holder == null || typeof holder !== "object" || !hasOwn(holder, last)) return;
+	const parent = walkToParent(root, segments, false);
+	delete parent[last];
+}
+/** Refuse a segment that would reach a prototype instead of story state. */
+function checkSegments(segments) {
+	if (segments.includes("__proto__")) throw new TypeError(`spindle: Cannot use "__proto__" in a variable path ("${segments.join(".")}")`);
+}
+/** Throw unless `holder` can take `key` as story state (see setByPath). */
+function checkHolder(holder, key, segments, depth) {
+	const kind = builtinName(holder) ?? (Array.isArray(holder) && !isArrayKey(key) ? "an array" : "");
+	if (kind) throw new TypeError(`spindle: Cannot set property "${key}" on ${kind} (at "${segments.slice(0, depth).join(".")}")`);
+}
+/**
+* Walk to the object holding the last of `segments`, copying undrafted
+* objects when `root` is an Immer draft (see setByPath). A missing or
+* non-object intermediate is replaced by a plain object when
+* `createMissing` is set, and throws a TypeError otherwise.
+*/
+function walkToParent(root, segments, createMissing) {
+	checkSegments(segments);
+	const copyOnWrite = isDraft(root);
+	let current = root;
+	for (let i = 0; i < segments.length - 1; i++) {
+		const seg = segments[i];
+		checkHolder(current, seg, segments, i);
+		let next = hasOwn(current, seg) ? current[seg] : void 0;
+		if (next == null || typeof next !== "object") {
+			if (!createMissing) throw new TypeError(`spindle: Cannot set property "${segments[i + 1]}" on ${next === null ? "null" : typeof next} (at "${segments.slice(0, i + 1).join(".")}")`);
+			next = {};
+			current[seg] = next;
+		} else if (copyOnWrite && !isDraft(next) && !builtinName(next)) {
+			next = shallowCopy(next);
+			current[seg] = next;
+		}
+		current = next;
+	}
+	checkHolder(current, segments[segments.length - 1], segments, segments.length - 1);
+	return current;
+}
+//#endregion
+//#region src/structural.ts
+/**
 * Set an own enumerable property. A "__proto__" key is defined as an own
 * property (as JSON.parse does) instead of replacing the prototype.
 */
@@ -66,6 +230,11 @@ function setOwn(target, key, value) {
 	});
 	else target[key] = value;
 }
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
 function deepClone(value, options = {}) {
 	const seen = /* @__PURE__ */ new Map();
 	function clone(val) {
@@ -92,15 +261,9 @@ function deepClone(value, options = {}) {
 			for (const v of val) copy.add(clone(v));
 			return copy;
 		}
-		if (registeredClassName(obj) !== void 0) {
-			const copy = Object.create(Object.getPrototypeOf(obj));
-			seen.set(obj, copy);
-			for (const key of Object.keys(obj)) setOwn(copy, key, clone(obj[key]));
-			return copy;
-		}
-		const plain = isPlainObject(val);
-		if (!plain && options.keepUnregistered) return val;
-		const copy = plain ? Object.create(Object.getPrototypeOf(obj)) : {};
+		const keepsProto = registeredClassName(obj) !== void 0 || isPlainObject(val);
+		if (!keepsProto && options.keepUnregistered) return val;
+		const copy = keepsProto ? Object.create(Object.getPrototypeOf(obj)) : {};
 		seen.set(obj, copy);
 		for (const key of Object.keys(obj)) setOwn(copy, key, clone(obj[key]));
 		return copy;
@@ -150,10 +313,156 @@ function equal(a, b, assumed) {
 	const bo = b;
 	const keys = Object.keys(ao);
 	if (keys.length !== Object.keys(bo).length) return false;
-	for (const key of keys) if (!hasOwn$3(bo, key) || !equal(ao[key], bo[key], assumed)) return false;
+	for (const key of keys) if (!hasOwn(bo, key) || !equal(ao[key], bo[key], assumed)) return false;
 	return true;
 }
-var hasOwn$3 = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
+/**
+* Objects merged property by property: plain objects and (registered)
+* class instances. Arrays, Map, Set, Date and RegExp are values that are
+* replaced as a whole, since their elements have no stable identity to
+* merge by (a shift moves every index).
+*/
+function isMergeable(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Map) && !(value instanceof Set) && !(value instanceof Date) && !(value instanceof RegExp);
+}
+/**
+* Whether changes between `a` and `b` merge key by key: both are objects of
+* one class (see isMergeable), or, with `arrays`, both are arrays.
+*/
+function mergesWith(a, b, arrays) {
+	if (arrays && (Array.isArray(a) || Array.isArray(b))) return Array.isArray(a) && Array.isArray(b);
+	return isMergeable(a) && isMergeable(b) && Object.getPrototypeOf(a) === Object.getPrototypeOf(b);
+}
+/**
+* The keys at which `after` differs from `before`, two values that merge
+* (see mergesWith): keys added, deleted, or holding another value. Store
+* updates are immutable, so a value that kept its identity is no change,
+* and one rebuilt with equal content (mutation code commits whole values)
+* is none either. Values that merge are reported as 'nested', to be
+* compared key by key; they may still be equal. With `arrays`, arrays
+* merge too: elements at the indices both hold are compared, and the
+* elements one has beyond the other's length are added or deleted.
+*/
+function keyChanges(before, after, arrays) {
+	const changes = [];
+	const compare = (key, b, a) => {
+		if (Object.is(b, a)) return;
+		if (mergesWith(b, a, arrays)) changes.push({
+			key,
+			kind: "nested",
+			before: b,
+			after: a
+		});
+		else if (!deepEqual(b, a)) changes.push({
+			key,
+			kind: "changed",
+			after: a
+		});
+	};
+	if (Array.isArray(after)) {
+		const b = before;
+		const a = after;
+		for (let i = 0; i < Math.min(b.length, a.length); i++) compare(String(i), b[i], a[i]);
+		for (let i = b.length; i < a.length; i++) changes.push({
+			key: String(i),
+			kind: "added",
+			after: a[i]
+		});
+		for (let i = a.length; i < b.length; i++) changes.push({
+			key: String(i),
+			kind: "deleted"
+		});
+		return changes;
+	}
+	for (const key of Object.keys(after)) if (hasOwn(before, key)) compare(key, before[key], after[key]);
+	else changes.push({
+		key,
+		kind: "added",
+		after: after[key]
+	});
+	for (const key of Object.keys(before)) if (!hasOwn(after, key)) changes.push({
+		key,
+		kind: "deleted"
+	});
+	return changes;
+}
+/**
+* The property paths where `after` differs from `before`, two objects of
+* one class: objects that merge (see isMergeable) are compared property by
+* property, any other value as a whole.
+*/
+function diffPaths(before, after) {
+	const changes = [];
+	const ancestors = /* @__PURE__ */ new Set();
+	(function walk(b, a, path) {
+		if (ancestors.has(a)) return;
+		ancestors.add(a);
+		for (const change of keyChanges(b, a, false)) {
+			const at = [...path, change.key];
+			if (change.kind === "nested") walk(change.before, change.after, at);
+			else changes.push(change.kind === "deleted" ? {
+				path: at,
+				deleted: true
+			} : {
+				path: at,
+				deleted: false,
+				value: change.after
+			});
+		}
+		ancestors.delete(a);
+	})(before, after, []);
+	return changes;
+}
+/** Whether `target` already holds what `change` would write. */
+function isApplied(target, change) {
+	const parent = getByPath(target, change.path.slice(0, -1));
+	if (parent === null || typeof parent !== "object") return change.deleted;
+	const key = change.path[change.path.length - 1];
+	if (!hasOwn(parent, key)) return change.deleted;
+	return !change.deleted && deepEqual(parent[key], change.value);
+}
+function applyChange(target, change) {
+	if (change.deleted) deleteByPath(target, change.path);
+	else setByPath(target, change.path, change.value);
+}
+/**
+* Write how `after` differs from `before` (see keyChanges; arrays merge by
+* index) into `target`, another version of the same object or array.
+* Values that changed are written whole, as deep copies; for values that
+* merge, `mergeNested` may merge them into `target` instead, returning
+* whether it did. Into an array, elements removed from the end are removed
+* at the same indices and elements added are appended, and changes at
+* indices `target` lacks are dropped: where `target` was resized, its
+* indices do not line up with `before`'s.
+*/
+function mergeKeys(target, before, after, mergeNested) {
+	const list = Array.isArray(target) ? target : void 0;
+	for (const change of keyChanges(before, after, true)) {
+		const { key } = change;
+		if (change.kind === "deleted") if (list) list.length = Math.min(list.length, Number(key));
+		else delete target[key];
+		else if (list && change.kind === "added") list.push(deepClone(change.after));
+		else if (list && Number(key) >= list.length) continue;
+		else if (change.kind !== "nested" || !(mergeNested?.(key, change.before, change.after) || deepEqual(change.before, change.after))) target[key] = deepClone(change.after);
+	}
+}
+//#endregion
+//#region src/class-registry.ts
+var registry$1 = /* @__PURE__ */ new Map();
+var ctorToName = /* @__PURE__ */ new Map();
+function registerClass(name, ctor) {
+	registry$1.set(name, ctor);
+	ctorToName.set(ctor, name);
+}
+/**
+* The registered name of the class `value` is an instance of, or undefined.
+* Looks the constructor up on the prototype, so an own property named
+* "constructor" (plain data) cannot hide or fake the class.
+*/
+function registeredClassName(value) {
+	const proto = Object.getPrototypeOf(value);
+	return proto === null ? void 0 : ctorToName.get(proto.constructor);
+}
 var CLASS_TAG = "__spindle_class__";
 var DATA_TAG = "__spindle_data__";
 /** A tagged value, as serialize() writes and deserialize() reads it. */
@@ -225,7 +534,7 @@ function serialize(value) {
 		const name = registeredClassName(val);
 		if (name !== void 0) return tagged(name, serKeys(val));
 		const data = serKeys(val);
-		return hasOwn$3(val, CLASS_TAG) ? tagged("__Object__", data) : data;
+		return hasOwn(val, CLASS_TAG) ? tagged("__Object__", data) : data;
 	}
 	return ser(value);
 }
@@ -311,7 +620,7 @@ function isDeserializable(value) {
 			case "__Map__": return Array.isArray(data.entries) && Array.from(data.entries).every((entry) => Array.isArray(entry) && entry.length === 2 && check(entry[0]) && check(entry[1]));
 			case "__Set__": return Array.isArray(data.entries) && Array.from(data.entries).every(check);
 			case "__Undefined__": return true;
-			case "__Number__": return typeof data.value === "string" && hasOwn$3(SPECIAL_NUMBERS, data.value);
+			case "__Number__": return typeof data.value === "string" && hasOwn(SPECIAL_NUMBERS, data.value);
 			case "__BigInt__": return typeof data.value === "string" && /^-?\d+$/.test(data.value);
 			default: return checkKeys(data);
 		}
@@ -382,6 +691,10 @@ function isSavePayload(value) {
 	if (typeof obj.historyIndex !== "number") return false;
 	return true;
 }
+/** Estimated byte size of a serialized save payload. */
+function estimatePayloadBytes(payload) {
+	return JSON.stringify(payload).length;
+}
 //#endregion
 //#region src/js-lexer.ts
 /** Transient name after `%`: an identifier, so `%3` is never a reference. */
@@ -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();
@@ -4322,6 +4565,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 +4620,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 +4676,55 @@ function lsIndexAdd(key, entry) {
 		lsSet(key, arr);
 	}
 }
+/** Remove an ID from an index; an index left empty is removed. */
 function lsIndexRemove(key, entry) {
-	lsSet(key, lsIndex(key).filter((e) => e !== entry));
+	const arr = lsIndex(key).filter((e) => e !== entry);
+	if (arr.length > 0) lsSet(key, arr);
+	else lsDel(key);
 }
+/** The keys of every stored item that start with `prefix`. */
+var lsKeys = (prefix) => Object.keys(localStorage).filter((key) => key.startsWith(prefix));
 function createLocalStorageBackend() {
-	return {
-		type: "localstorage",
-		async putSave(record) {
-			const id = record.meta.id;
-			const previous = lsGet(`${LS_SAVE_PREFIX}${id}`);
-			if (previous && previous.meta.playthroughId !== record.meta.playthroughId) lsIndexRemove(`${LS_IDX_SAVES_PT_PREFIX}${previous.meta.playthroughId}`, id);
-			lsSet(`${LS_SAVE_PREFIX}${id}`, record);
-			lsIndexAdd(`${LS_IDX_SAVES_PREFIX}${record.meta.ifid}`, id);
-			lsIndexAdd(`${LS_IDX_SAVES_PT_PREFIX}${record.meta.playthroughId}`, id);
-		},
-		async getSave(id) {
-			return lsGet(`${LS_SAVE_PREFIX}${id}`);
-		},
-		async deleteSave(id) {
-			const record = lsGet(`${LS_SAVE_PREFIX}${id}`);
-			if (record) {
-				lsIndexRemove(`${LS_IDX_SAVES_PREFIX}${record.meta.ifid}`, id);
-				lsIndexRemove(`${LS_IDX_SAVES_PT_PREFIX}${record.meta.playthroughId}`, id);
-			}
-			lsDel(`${LS_SAVE_PREFIX}${id}`);
-		},
-		async getSavesByIfid(ifid) {
-			const ids = lsIndex(`${LS_IDX_SAVES_PREFIX}${ifid}`);
-			const results = [];
-			for (const id of ids) {
-				const record = lsGet(`${LS_SAVE_PREFIX}${id}`);
-				if (record) results.push(record);
-			}
-			return results;
-		},
-		async deleteSavesByIfid(ifid) {
-			const ids = lsIndex(`${LS_IDX_SAVES_PREFIX}${ifid}`);
-			for (const id of ids) {
-				const record = lsGet(`${LS_SAVE_PREFIX}${id}`);
-				if (record) lsIndexRemove(`${LS_IDX_SAVES_PT_PREFIX}${record.meta.playthroughId}`, id);
-				lsDel(`${LS_SAVE_PREFIX}${id}`);
-			}
-			lsDel(`${LS_IDX_SAVES_PREFIX}${ifid}`);
-		},
-		async deleteSavesByPlaythrough(playthroughId) {
-			const ids = lsIndex(`${LS_IDX_SAVES_PT_PREFIX}${playthroughId}`);
-			for (const id of ids) {
-				const record = lsGet(`${LS_SAVE_PREFIX}${id}`);
-				if (record) lsIndexRemove(`${LS_IDX_SAVES_PREFIX}${record.meta.ifid}`, id);
-				lsDel(`${LS_SAVE_PREFIX}${id}`);
-			}
-			lsDel(`${LS_IDX_SAVES_PT_PREFIX}${playthroughId}`);
-			return ids;
-		},
-		async putPlaythrough(record) {
-			lsSet(`${LS_PT_PREFIX}${record.id}`, record);
-			lsIndexAdd(`${LS_IDX_PT_PREFIX}${record.ifid}`, record.id);
-		},
-		async getPlaythroughsByIfid(ifid) {
-			const ids = lsIndex(`${LS_IDX_PT_PREFIX}${ifid}`);
-			const results = [];
-			for (const id of ids) {
-				const record = lsGet(`${LS_PT_PREFIX}${id}`);
-				if (record) results.push(record);
-			}
-			return results;
-		},
-		async deletePlaythroughsByIfid(ifid) {
-			const ids = lsIndex(`${LS_IDX_PT_PREFIX}${ifid}`);
-			for (const id of ids) lsDel(`${LS_PT_PREFIX}${id}`);
-			lsDel(`${LS_IDX_PT_PREFIX}${ifid}`);
-		},
-		async deletePlaythroughById(id) {
-			const record = lsGet(`${LS_PT_PREFIX}${id}`);
-			if (record) lsIndexRemove(`${LS_IDX_PT_PREFIX}${record.ifid}`, id);
-			lsDel(`${LS_PT_PREFIX}${id}`);
-		},
-		async getMeta(key) {
-			return lsGet(`${LS_META_PREFIX}${key}`);
-		},
-		async setMeta(key, value) {
-			lsSet(`${LS_META_PREFIX}${key}`, value);
-		},
-		async deleteMeta(key) {
-			lsDel(`${LS_META_PREFIX}${key}`);
-		},
-		async deleteMetaByPrefix(prefix) {
-			const fullPrefix = `${LS_META_PREFIX}${prefix}`;
-			for (const key of Object.keys(localStorage)) if (key.startsWith(fullPrefix)) localStorage.removeItem(key);
-		},
-		async deleteMetaByIfid(ifid) {
-			for (const key of Object.keys(localStorage)) if (key.startsWith(LS_META_PREFIX) && key.includes(ifid)) localStorage.removeItem(key);
-		},
-		async getAllMetaKeys() {
-			const keys = [];
-			for (const key of Object.keys(localStorage)) if (key.startsWith(LS_META_PREFIX)) keys.push(key.slice(13));
-			return keys;
-		},
-		async destroy() {
-			for (const key of Object.keys(localStorage)) if (key.startsWith("spindle.")) localStorage.removeItem(key);
-		}
-	};
+	function table(name, fields) {
+		const prefix = LS_PREFIXES[name];
+		const indexes = Object.entries(fields).map(([field, read]) => ({
+			field,
+			read,
+			prefix: LS_INDEX_PREFIXES[`${name}.${field}`]
+		}));
+		/** The index lists `record` is in. */
+		const listsOf = (record) => indexes.map((index) => `${index.prefix}${index.read(record)}`);
+		return {
+			get: async (key) => lsGet(`${prefix}${key}`),
+			async put(key, value) {
+				const previous = lsGet(`${prefix}${key}`);
+				const lists = listsOf(value);
+				if (previous !== void 0) {
+					for (const list of listsOf(previous)) if (!lists.includes(list)) lsIndexRemove(list, key);
+				}
+				lsSet(`${prefix}${key}`, value);
+				for (const list of lists) lsIndexAdd(list, key);
+			},
+			async delete(key) {
+				const record = lsGet(`${prefix}${key}`);
+				if (record !== void 0) for (const list of listsOf(record)) lsIndexRemove(list, key);
+				lsDel(`${prefix}${key}`);
+			},
+			async find(field, value) {
+				const index = indexes.find((i) => i.field === field);
+				const results = [];
+				for (const id of lsIndex(`${index.prefix}${value}`)) {
+					const record = lsGet(`${prefix}${id}`);
+					if (record !== void 0) results.push(record);
+				}
+				return results;
+			},
+			keys: async () => lsKeys(prefix).map((key) => key.slice(prefix.length))
+		};
+	}
+	return createBackend("localstorage", makeTables(table), async () => {
+		for (const key of lsKeys("spindle.")) lsDel(key);
+	});
 }
 var IDB_DB_NAME = "spindle";
 var IDB_DB_VERSION = 1;
@@ -4560,95 +4749,51 @@ function createIDBBackend() {
 		});
 		return dbPromise;
 	}
-	function tx(storeName, mode) {
-		return openDB().then((db) => db.transaction(storeName, mode).objectStore(storeName));
-	}
 	function idbReq(req) {
 		return new Promise((resolve, reject) => {
 			req.onsuccess = () => resolve(req.result);
 			req.onerror = () => reject(req.error);
 		});
 	}
-	async function getAllFromIndex(storeName, indexName, value) {
-		return await idbReq((await tx(storeName, "readonly")).index(indexName).getAll(value)) ?? [];
+	/**
+	* An object store. Records hold their own key (keyPath); meta values are
+	* stored as `{ key, value }` rows.
+	*/
+	function table(name) {
+		const rows = name === "meta";
+		/** Run one request in a transaction of its own. */
+		const request = async (mode, make) => {
+			return idbReq(make((await openDB()).transaction(name, mode).objectStore(name)));
+		};
+		return {
+			async get(key) {
+				const result = await request("readonly", (s) => s.get(key));
+				return rows ? result?.value : result;
+			},
+			async put(key, value) {
+				await request("readwrite", (s) => s.put(rows ? {
+					key,
+					value
+				} : value));
+			},
+			async delete(key) {
+				await request("readwrite", (s) => s.delete(key));
+			},
+			async find(field, value) {
+				return await request("readonly", (s) => s.index(field).getAll(value)) ?? [];
+			},
+			keys: async () => await request("readonly", (s) => s.getAllKeys())
+		};
 	}
-	return {
-		type: "indexeddb",
-		async putSave(record) {
-			await idbReq((await tx("saves", "readwrite")).put(record));
-		},
-		async getSave(id) {
-			return await idbReq((await tx("saves", "readonly")).get(id)) ?? void 0;
-		},
-		async deleteSave(id) {
-			await idbReq((await tx("saves", "readwrite")).delete(id));
-		},
-		async getSavesByIfid(ifid) {
-			return getAllFromIndex("saves", "ifid", ifid);
-		},
-		async deleteSavesByIfid(ifid) {
-			const records = await getAllFromIndex("saves", "ifid", ifid);
-			const store = await tx("saves", "readwrite");
-			for (const r of records) await idbReq(store.delete(r.meta.id));
-		},
-		async deleteSavesByPlaythrough(playthroughId) {
-			const records = await getAllFromIndex("saves", "playthroughId", playthroughId);
-			const store = await tx("saves", "readwrite");
-			const ids = [];
-			for (const r of records) {
-				await idbReq(store.delete(r.meta.id));
-				ids.push(r.meta.id);
-			}
-			return ids;
-		},
-		async putPlaythrough(record) {
-			await idbReq((await tx("playthroughs", "readwrite")).put(record));
-		},
-		async getPlaythroughsByIfid(ifid) {
-			return getAllFromIndex("playthroughs", "ifid", ifid);
-		},
-		async deletePlaythroughsByIfid(ifid) {
-			const records = await getAllFromIndex("playthroughs", "ifid", ifid);
-			const store = await tx("playthroughs", "readwrite");
-			for (const r of records) await idbReq(store.delete(r.id));
-		},
-		async deletePlaythroughById(id) {
-			await idbReq((await tx("playthroughs", "readwrite")).delete(id));
-		},
-		async getMeta(key) {
-			const row = await idbReq((await tx("meta", "readonly")).get(key));
-			return row ? row.value : void 0;
-		},
-		async setMeta(key, value) {
-			await idbReq((await tx("meta", "readwrite")).put({
-				key,
-				value
-			}));
-		},
-		async deleteMeta(key) {
-			await idbReq((await tx("meta", "readwrite")).delete(key));
-		},
-		async deleteMetaByPrefix(prefix) {
-			const allRows = await idbReq((await tx("meta", "readwrite")).getAll());
-			for (const row of allRows) if (row.key.startsWith(prefix)) await idbReq((await tx("meta", "readwrite")).delete(row.key));
-		},
-		async deleteMetaByIfid(ifid) {
-			const allRows = await idbReq((await tx("meta", "readwrite")).getAll());
-			for (const row of allRows) if (row.key.includes(ifid)) await idbReq((await tx("meta", "readwrite")).delete(row.key));
-		},
-		async getAllMetaKeys() {
-			return (await idbReq((await tx("meta", "readonly")).getAll())).map((r) => r.key);
-		},
-		async destroy() {
-			(await openDB()).close();
-			dbPromise = null;
-			await new Promise((resolve, reject) => {
-				const req = indexedDB.deleteDatabase(IDB_DB_NAME);
-				req.onsuccess = () => resolve();
-				req.onerror = () => reject(req.error);
-			});
-		}
-	};
+	return createBackend("indexeddb", makeTables(table), async () => {
+		(await openDB()).close();
+		dbPromise = null;
+		await new Promise((resolve, reject) => {
+			const req = indexedDB.deleteDatabase(IDB_DB_NAME);
+			req.onsuccess = () => resolve();
+			req.onerror = () => reject(req.error);
+		});
+	});
 }
 var _backend = null;
 async function detectBackend() {
@@ -4797,15 +4942,17 @@ function inOrder(op) {
 	operationQueue = run.catch(() => {});
 	return run;
 }
+/** `op` (a `...Now` helper) as an operation that queues itself. */
+function queued(op) {
+	return (...args) => inOrder(() => op(...args));
+}
 /**
 * Store a new playthrough and make it the story's current one. Pass `id` when
 * the caller has already switched to the playthrough (restart() does, so
 * saves issued before this resolves are tagged with it).
 */
-function startNewPlaythrough(ifid, id = crypto.randomUUID()) {
-	return inOrder(() => startNewPlaythroughNow(ifid, id));
-}
-async function startNewPlaythroughNow(ifid, id) {
+var startNewPlaythrough = queued(startNewPlaythroughNow);
+async function startNewPlaythroughNow(ifid, id = crypto.randomUUID()) {
 	const backend = await getBackend();
 	const num = await nextPlaythroughNumber(ifid);
 	const record = {
@@ -4850,19 +4997,26 @@ function currentPlaythroughKey(ifid) {
 * recorded again as "Imported", as importing the save would: it was not
 * started here, so it takes no number.
 */
-function adoptPlaythrough(ifid, id) {
-	return inOrder(() => adoptPlaythroughNow(ifid, id));
-}
+var adoptPlaythrough = queued(adoptPlaythroughNow);
 async function adoptPlaythroughNow(ifid, id) {
+	const backend = await getBackend();
+	await ensurePlaythrough(ifid, id, (/* @__PURE__ */ new Date()).toISOString());
+	const key = currentPlaythroughKey(ifid);
+	if (await backend.getMeta(key) !== id) await backend.setMeta(key, id);
+}
+/**
+* Record the playthrough `id` of the story as "Imported", created at
+* `createdAt`, unless it has a record: a playthrough not started here takes
+* no number.
+*/
+async function ensurePlaythrough(ifid, id, createdAt) {
 	const backend = await getBackend();
 	if (!(await backend.getPlaythroughsByIfid(ifid)).some((p) => p.id === id)) await backend.putPlaythrough({
 		id,
 		ifid,
-		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		createdAt,
 		label: "Imported"
 	});
-	const key = currentPlaythroughKey(ifid);
-	if (await backend.getMeta(key) !== id) await backend.setMeta(key, id);
 }
 /**
 * Set up the save system for a story that boots: the story's current
@@ -4872,7 +5026,7 @@ async function adoptPlaythroughNow(ifid, id) {
 function establishPlaythrough(ifid) {
 	return inOrder(async () => {
 		return {
-			id: await (await getBackend()).getMeta(currentPlaythroughKey(ifid)) ?? await startNewPlaythroughNow(ifid, crypto.randomUUID()),
+			id: await (await getBackend()).getMeta(currentPlaythroughKey(ifid)) ?? await startNewPlaythroughNow(ifid),
 			knownSaves: await populateKnownSavesNow(ifid)
 		};
 	});
@@ -4907,12 +5061,35 @@ function saveWithHooks(slot, custom, beginCapture, write) {
 		return Promise.reject(err);
 	}
 }
-function createSave(ifid, playthroughId, payload, custom = {}) {
-	return inOrder(() => createSaveNow(ifid, playthroughId, payload, custom));
+/**
+* `payload` with `convert` applied to its live variables and to those of
+* every history moment.
+*/
+function mapVariables(payload, convert) {
+	return {
+		...payload,
+		variables: convert(payload.variables),
+		history: payload.history.map((m) => ({
+			...m,
+			variables: convert(m.variables)
+		}))
+	};
+}
+/** The record to store for a save: `payload` serialized, and its size. */
+function storedRecord(meta, payload) {
+	const serialized = mapVariables(deepClone(payload), serialize);
+	return {
+		meta: {
+			...meta,
+			estimatedBytes: estimatePayloadBytes(serialized)
+		},
+		payload: serialized
+	};
 }
-async function createSaveNow(ifid, playthroughId, payload, custom) {
+var createSave = queued(createSaveNow);
+async function createSaveNow(ifid, playthroughId, payload, custom = {}) {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const meta = {
+	const record = storedRecord({
 		id: crypto.randomUUID(),
 		ifid,
 		playthroughId,
@@ -4921,18 +5098,7 @@ async function createSaveNow(ifid, playthroughId, payload, custom) {
 		title: generateTitle(payload),
 		passage: payload.passage,
 		custom
-	};
-	const serializedPayload = deepClone(payload);
-	serializedPayload.variables = serialize(serializedPayload.variables);
-	serializedPayload.history = serializedPayload.history.map((m) => ({
-		...m,
-		variables: serialize(m.variables)
-	}));
-	const record = {
-		meta,
-		payload: serializedPayload
-	};
-	record.meta.estimatedBytes = JSON.stringify(serializedPayload).length;
+	}, payload);
 	await (await getBackend()).putSave(record);
 	return record;
 }
@@ -4951,34 +5117,22 @@ async function createSaveNow(ifid, playthroughId, payload, custom) {
 * save itself rather than describing its content. `custom` is merged, as
 * before, so slot keys and metadata not passed again are kept.
 */
-function overwriteSave(saveId, payload, custom, playthroughId) {
-	return inOrder(() => overwriteSaveNow(saveId, payload, custom, playthroughId));
-}
+var overwriteSave = queued(overwriteSaveNow);
 async function overwriteSaveNow(saveId, payload, custom, playthroughId) {
 	const backend = await getBackend();
 	const existing = await backend.getSave(saveId);
 	if (!existing) return void 0;
-	const serializedPayload = deepClone(payload);
-	serializedPayload.variables = serialize(serializedPayload.variables);
-	serializedPayload.history = serializedPayload.history.map((m) => ({
-		...m,
-		variables: serialize(m.variables)
-	}));
-	const updated = {
-		meta: {
-			...existing.meta,
-			...playthroughId ? { playthroughId } : {},
-			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			title: existing.meta.userTitle === true ? existing.meta.title : generateTitle(payload),
-			passage: payload.passage,
-			...custom != null ? { custom: {
-				...existing.meta.custom,
-				...custom
-			} } : {}
-		},
-		payload: serializedPayload
-	};
-	updated.meta.estimatedBytes = JSON.stringify(serializedPayload).length;
+	const updated = storedRecord({
+		...existing.meta,
+		...playthroughId ? { playthroughId } : {},
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		title: existing.meta.userTitle === true ? existing.meta.title : generateTitle(payload),
+		passage: payload.passage,
+		...custom != null ? { custom: {
+			...existing.meta.custom,
+			...custom
+		} } : {}
+	}, payload);
 	await backend.putSave(updated);
 	return updated;
 }
@@ -4988,15 +5142,11 @@ async function overwriteSaveNow(saveId, payload, custom, playthroughId) {
 * untouched. Payloads handed to the store's `loadFromPayload()` must be live.
 */
 function deserializePayload(payload) {
-	return {
-		...payload,
-		variables: deserialize(payload.variables),
-		history: payload.history.map((m) => ({
-			...m,
-			variables: deserialize(m.variables)
-		}))
-	};
+	return mapVariables(payload, deserialize);
 }
+/** The live payload of a stored save, if there is one. */
+var livePayload = (record) => record && deserializePayload(record.payload);
+queued(async (saveId) => livePayload(await (await getBackend()).getSave(saveId)));
 /**
 * Delete a save record. If the default slot or a named slot holds it, that
 * slot is cleared as well (pointer and slot index), as `deleteSlotSave` would.
@@ -5007,14 +5157,7 @@ function deleteSaveById(saveId) {
 		const record = await backend.getSave(saveId);
 		await backend.deleteSave(saveId);
 		if (!record) return;
-		const ifid = record.meta.ifid;
-		const slots = [void 0, ...await getIndexedSlots(ifid)];
-		for (const slot of slots) {
-			const metaKey = slotMetaKey(ifid, slot);
-			if (await backend.getMeta(metaKey) !== saveId) continue;
-			await backend.deleteMeta(metaKey);
-			await removeFromSlotIndex(ifid, slot);
-		}
+		await emptySlotsHolding(record.meta.ifid, (id) => id === saveId);
 	});
 }
 function renameSave(saveId, newTitle) {
@@ -5034,10 +5177,7 @@ function renameSave(saveId, newTitle) {
 		await backend.putSave(updated);
 	});
 }
-function getSavesGrouped(ifid) {
-	return inOrder(() => getSavesGroupedNow(ifid));
-}
-async function getSavesGroupedNow(ifid) {
+var getSavesGrouped = queued(async function getSavesGroupedNow(ifid) {
 	const backend = await getBackend();
 	const [allSaves, allPlaythroughs] = await Promise.all([backend.getSavesByIfid(ifid), backend.getPlaythroughsByIfid(ifid)]);
 	const ptMap = /* @__PURE__ */ new Map();
@@ -5069,7 +5209,7 @@ async function getSavesGroupedNow(ifid) {
 		saves
 	});
 	return result;
-}
+});
 var AUTOSAVE_KEY_PREFIX = "autosave.";
 var SLOT_KEY_PREFIX = "slot.";
 var SLOT_INDEX_KEY_PREFIX = "slotIndex.";
@@ -5083,29 +5223,49 @@ function isNamedSlot(slot) {
 function slotMetaKey(ifid, slot) {
 	return isNamedSlot(slot) ? `${SLOT_KEY_PREFIX}${slot}.${ifid}` : `${AUTOSAVE_KEY_PREFIX}${ifid}`;
 }
+var slotIndexKey = (ifid) => `${SLOT_INDEX_KEY_PREFIX}${ifid}`;
 /** Read-modify-write the per-story slot index. */
 async function updateSlotIndex(ifid, update) {
 	const backend = await getBackend();
-	const indexKey = `${SLOT_INDEX_KEY_PREFIX}${ifid}`;
-	const existing = await backend.getMeta(indexKey) ?? [];
+	const existing = await backend.getMeta(slotIndexKey(ifid)) ?? [];
 	const updated = update(existing);
-	if (updated !== existing) await backend.setMeta(indexKey, updated);
-}
-/** Record a named slot in the per-story slot index (no-op for the default slot). */
-function addToSlotIndex(ifid, slot) {
-	if (!isNamedSlot(slot)) return Promise.resolve();
-	return updateSlotIndex(ifid, (slots) => slots.includes(slot) ? slots : [...slots, slot]);
-}
-/** Remove a named slot from the per-story slot index (no-op for the default slot). */
-function removeFromSlotIndex(ifid, slot) {
-	if (!isNamedSlot(slot)) return Promise.resolve();
-	return updateSlotIndex(ifid, (slots) => slots.filter((s) => s !== slot));
-}
-/** Named slots in the per-story slot index. */
-async function getIndexedSlots(ifid) {
-	const indexKey = `${SLOT_INDEX_KEY_PREFIX}${ifid}`;
-	return (await (await getBackend()).getMeta(indexKey) ?? []).filter(isNamedSlot);
-}
+	if (updated !== existing) await backend.setMeta(slotIndexKey(ifid), updated);
+}
+/** Every slot: the default one (undefined), then those in the slot index. */
+async function allSlots(ifid) {
+	return [void 0, ...(await (await getBackend()).getMeta(slotIndexKey(ifid)) ?? []).filter(isNamedSlot)];
+}
+/** The ID of the save a slot holds, if any. */
+async function slotSaveId(ifid, slot) {
+	return (await getBackend()).getMeta(slotMetaKey(ifid, slot));
+}
+/** The record of the save a slot holds, if there is one. */
+async function slotRecord(ifid, slot) {
+	const id = await slotSaveId(ifid, slot);
+	return id ? (await getBackend()).getSave(id) : void 0;
+}
+/** Make a slot hold the save `saveId`: its pointer, and the slot index. */
+async function fillSlot(ifid, slot, saveId) {
+	await (await getBackend()).setMeta(slotMetaKey(ifid, slot), saveId);
+	if (isNamedSlot(slot)) await updateSlotIndex(ifid, (slots) => slots.includes(slot) ? slots : [...slots, slot]);
+}
+/** Clear a slot: its pointer, and its entry in the slot index. */
+async function emptySlot(ifid, slot) {
+	await (await getBackend()).deleteMeta(slotMetaKey(ifid, slot));
+	if (isNamedSlot(slot)) await updateSlotIndex(ifid, (slots) => slots.filter((s) => s !== slot));
+}
+/** Clear every slot holding a save whose ID passes `test`. */
+async function emptySlotsHolding(ifid, test) {
+	for (const slot of await allSlots(ifid)) {
+		const id = await slotSaveId(ifid, slot);
+		if (id && test(id)) await emptySlot(ifid, slot);
+	}
+}
+/** The `custom` keys that say which slot a save lives in. */
+var slotCustom = (slot) => ({
+	isAutosave: !isNamedSlot(slot),
+	...isNamedSlot(slot) ? { slot } : {}
+});
 function toSaveInfo(record, slot) {
 	return {
 		slot: isNamedSlot(slot) ? slot : "",
@@ -5123,32 +5283,26 @@ function toSaveInfo(record, slot) {
 * place in the order of operations when it is called.
 */
 function quickSave(ifid, playthroughId, payload, slot, custom) {
-	const metaKey = slotMetaKey(ifid, slot);
 	return inOrder(async () => {
 		const ptId = await playthroughId;
-		const backend = await getBackend();
-		const existingId = await backend.getMeta(metaKey);
+		const existingId = await slotSaveId(ifid, slot);
 		if (existingId) {
 			const updated = await overwriteSaveNow(existingId, payload, custom, ptId);
 			if (updated) return updated;
 		}
 		const record = await createSaveNow(ifid, ptId, payload, {
-			isAutosave: !isNamedSlot(slot),
-			...isNamedSlot(slot) ? { slot } : {},
+			...slotCustom(slot),
 			...custom
 		});
-		await backend.setMeta(metaKey, record.meta.id);
-		await addToSlotIndex(ifid, slot);
+		await fillSlot(ifid, slot, record.meta.id);
 		return record;
 	});
 }
+queued(hasQuickSaveNow);
 async function hasQuickSaveNow(ifid, slot) {
-	const backend = await getBackend();
-	const metaKey = slotMetaKey(ifid, slot);
-	const existingId = await backend.getMeta(metaKey);
-	if (!existingId) return false;
-	return await backend.getSave(existingId) !== void 0;
+	return await slotRecord(ifid, slot) !== void 0;
 }
+queued(async (ifid, slot) => livePayload(await slotRecord(ifid, slot)));
 /**
 * Read the save held in a slot (the default slot when `slot` is omitted) for
 * the running game to load, and make its playthrough the story's current one
@@ -5157,12 +5311,8 @@ async function hasQuickSaveNow(ifid, slot) {
 * and its playthrough, or undefined if the slot is empty.
 */
 function loadSlotSave(ifid, slot) {
-	const metaKey = slotMetaKey(ifid, slot);
 	return inOrder(async () => {
-		const backend = await getBackend();
-		const existingId = await backend.getMeta(metaKey);
-		if (!existingId) return void 0;
-		const record = await backend.getSave(existingId);
+		const record = await slotRecord(ifid, slot);
 		if (!record) return void 0;
 		const payload = deserializePayload(record.payload);
 		const { playthroughId } = record.meta;
@@ -5177,60 +5327,41 @@ function loadSlotSave(ifid, slot) {
 * Check storage for all known saves and return a map of slot keys to true.
 * The default (autosave) slot uses empty string as key.
 */
-function populateKnownSaves(ifid) {
-	return inOrder(() => populateKnownSavesNow(ifid));
-}
+var populateKnownSaves = queued(populateKnownSavesNow);
 async function populateKnownSavesNow(ifid) {
 	const result = Object.create(null);
-	if (await hasQuickSaveNow(ifid)) result[""] = true;
-	for (const slot of await getIndexedSlots(ifid)) if (await hasQuickSaveNow(ifid, slot)) result[slot] = true;
+	for (const slot of await allSlots(ifid)) if (await hasQuickSaveNow(ifid, slot)) result[slot ?? ""] = true;
 	return result;
 }
 /**
 * Get metadata for a specific save slot.
 * Returns null if no save exists for that slot.
 */
-function getSlotSaveInfo(ifid, slot) {
-	return inOrder(() => getSlotSaveInfoNow(ifid, slot));
-}
+var getSlotSaveInfo = queued(getSlotSaveInfoNow);
 async function getSlotSaveInfoNow(ifid, slot) {
-	const backend = await getBackend();
-	const metaKey = slotMetaKey(ifid, slot);
-	const existingId = await backend.getMeta(metaKey);
-	if (!existingId) return null;
-	const record = await backend.getSave(existingId);
-	if (!record) return null;
-	return toSaveInfo(record, slot);
+	const record = await slotRecord(ifid, slot);
+	return record ? toSaveInfo(record, slot) : null;
 }
 /**
 * List metadata for all known save slots (default + named).
 */
-function listSlotSaves(ifid) {
-	return inOrder(async () => {
-		const result = [];
-		const defaultInfo = await getSlotSaveInfoNow(ifid);
-		if (defaultInfo) result.push(defaultInfo);
-		for (const slot of await getIndexedSlots(ifid)) {
-			const info = await getSlotSaveInfoNow(ifid, slot);
-			if (info) result.push(info);
-		}
-		return result;
-	});
-}
+var listSlotSaves = queued(async (ifid) => {
+	const result = [];
+	for (const slot of await allSlots(ifid)) {
+		const info = await getSlotSaveInfoNow(ifid, slot);
+		if (info) result.push(info);
+	}
+	return result;
+});
 /**
 * Delete a save by slot name. Removes from slot index if named.
 */
-function deleteSlotSave(ifid, slot) {
-	const metaKey = slotMetaKey(ifid, slot);
-	return inOrder(async () => {
-		const backend = await getBackend();
-		const existingId = await backend.getMeta(metaKey);
-		if (!existingId) return;
-		await backend.deleteSave(existingId);
-		await backend.deleteMeta(metaKey);
-		await removeFromSlotIndex(ifid, slot);
-	});
-}
+var deleteSlotSave = queued(async (ifid, slot) => {
+	const existingId = await slotSaveId(ifid, slot);
+	if (!existingId) return;
+	await (await getBackend()).deleteSave(existingId);
+	await emptySlot(ifid, slot);
+});
 var SESSION_KEY_PREFIX = "spindle.session.";
 /**
 * Write a pre-serialized session payload to sessionStorage.
@@ -5257,11 +5388,8 @@ function clearSession(ifid) {
 		sessionStorage.removeItem(`${SESSION_KEY_PREFIX}${ifid}`);
 	} catch {}
 }
-function exportSave(saveId) {
-	return inOrder(() => exportSaveNow(saveId));
-}
-async function exportSaveNow(saveId) {
-	const record = await (await getBackend()).getSave(saveId);
+/** The export of a stored save, if there is one. */
+function toExport(record) {
 	if (!record) return void 0;
 	return {
 		version: 1,
@@ -5270,6 +5398,7 @@ async function exportSaveNow(saveId) {
 		save: record
 	};
 }
+var exportSave = queued(async (saveId) => toExport(await (await getBackend()).getSave(saveId)));
 /**
 * Validate an export against the running story and build the record to store:
 * a fresh save ID, and the playthrough record created if it doesn't exist yet.
@@ -5279,20 +5408,11 @@ async function prepareImport(data, ifid) {
 	if (data.version !== 1) throw new Error(`Unsupported save version: ${data.version}`);
 	if (data.ifid !== ifid) throw new Error(`Save is from a different story (expected IFID ${ifid}, got ${data.ifid})`);
 	if (!isSaveExport(data)) throw new Error("Invalid save file format");
-	const backend = await getBackend();
 	const record = deepClone(data.save);
 	record.meta.id = crypto.randomUUID();
 	record.meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
 	record.meta.ifid = ifid;
-	if (!(await backend.getPlaythroughsByIfid(ifid)).some((p) => p.id === record.meta.playthroughId)) {
-		const pt = {
-			id: record.meta.playthroughId,
-			ifid,
-			createdAt: record.meta.createdAt,
-			label: "Imported"
-		};
-		await backend.putPlaythrough(pt);
-	}
+	await ensurePlaythrough(ifid, record.meta.playthroughId, record.meta.createdAt);
 	return record;
 }
 function importSave(data, ifid) {
@@ -5306,13 +5426,7 @@ function importSave(data, ifid) {
 * Export the save held in a slot (default autosave slot when `slot` is omitted).
 * Returns undefined if the slot is empty.
 */
-function exportSlotSave(ifid, slot) {
-	return inOrder(async () => {
-		const saveId = await (await getBackend()).getMeta(slotMetaKey(ifid, slot));
-		if (!saveId) return void 0;
-		return exportSaveNow(saveId);
-	});
-}
+var exportSlotSave = queued(async (ifid, slot) => toExport(await slotRecord(ifid, slot)));
 /**
 * Import an exported save into a slot (default autosave slot when `slot` is
 * omitted), replacing any save already in that slot. Applies the same
@@ -5320,35 +5434,29 @@ function exportSlotSave(ifid, slot) {
 * and slot index consistent.
 */
 function importSlotSave(data, ifid, slot) {
-	const metaKey = slotMetaKey(ifid, slot);
 	return inOrder(async () => {
 		const record = await prepareImport(data, ifid);
 		const { slot: _exportedSlot, ...custom } = record.meta.custom ?? {};
 		record.meta.custom = {
 			...custom,
-			isAutosave: !isNamedSlot(slot),
-			...isNamedSlot(slot) ? { slot } : {}
+			...slotCustom(slot)
 		};
 		const backend = await getBackend();
-		const previousId = await backend.getMeta(metaKey);
+		const previousId = await slotSaveId(ifid, slot);
 		await backend.putSave(record);
-		await backend.setMeta(metaKey, record.meta.id);
-		await addToSlotIndex(ifid, slot);
+		await fillSlot(ifid, slot, record.meta.id);
 		if (previousId) await backend.deleteSave(previousId);
 		return toSaveInfo(record, slot);
 	});
 }
-function getStorageInfo(ifid) {
-	return inOrder(() => getStorageInfoNow(ifid));
-}
-async function getStorageInfoNow(ifid) {
+var getStorageInfo = queued(async function getStorageInfoNow(ifid) {
 	const backend = await getBackend();
 	const saves = await backend.getSavesByIfid(ifid);
 	const playthroughs = await backend.getPlaythroughsByIfid(ifid);
 	let totalBytes = 0;
 	for (const save of saves) if (save.meta.estimatedBytes != null) totalBytes += save.meta.estimatedBytes;
 	else {
-		const bytes = JSON.stringify(save.payload).length;
+		const bytes = estimatePayloadBytes(save.payload);
 		save.meta.estimatedBytes = bytes;
 		await backend.putSave(save);
 		totalBytes += bytes;
@@ -5359,7 +5467,7 @@ async function getStorageInfoNow(ifid) {
 		totalBytes,
 		backend: backend.type
 	};
-}
+});
 function clearGameData(ifid) {
 	return inOrder(async () => {
 		const backend = await getBackend();
@@ -5369,9 +5477,7 @@ function clearGameData(ifid) {
 		clearSession(ifid);
 	});
 }
-function clearAllData() {
-	return inOrder(clearAllDataNow);
-}
+var clearAllData = queued(clearAllDataNow);
 async function clearAllDataNow() {
 	await (await getBackend()).destroy();
 	resetBackend();
@@ -5399,14 +5505,7 @@ function deletePlaythroughData(ifid, playthroughId, replacement) {
 		const deletedSaveIds = await backend.deleteSavesByPlaythrough(playthroughId);
 		await backend.deletePlaythroughById(playthroughId);
 		const deletedSet = new Set(deletedSaveIds);
-		for (const slot of [void 0, ...await getIndexedSlots(ifid)]) {
-			const metaKey = slotMetaKey(ifid, slot);
-			const value = await backend.getMeta(metaKey);
-			if (value && deletedSet.has(value)) {
-				await backend.deleteMeta(metaKey);
-				await removeFromSlotIndex(ifid, slot);
-			}
-		}
+		await emptySlotsHolding(ifid, (id) => deletedSet.has(id));
 		if (replacement && await replacement.current === playthroughId) {
 			await startNewPlaythroughNow(ifid, replacement.id);
 			return true;
@@ -5467,120 +5566,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 +5607,6 @@ function frozenCopy(value) {
 	return freeze(cloneValue(value), true);
 }
 /**
-* Objects merged property by property: plain objects and (registered)
-* class instances. Arrays, Map, Set, Date and RegExp are values that are
-* replaced as a whole, since their elements have no stable identity to
-* merge by (a shift moves every index).
-*/
-function isMergeable(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Map) && !(value instanceof Set) && !(value instanceof Date) && !(value instanceof RegExp);
-}
-var hasOwn$1 = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-/** Collect the property paths where `work` differs from `base`. */
-function diff(base, work, path, changes, ancestors) {
-	if (ancestors.has(work)) return;
-	ancestors.add(work);
-	for (const key of Object.keys(work)) {
-		const b = base[key];
-		const w = work[key];
-		if (!hasOwn$1(base, key)) changes.push({
-			path: [...path, key],
-			deleted: false,
-			value: w
-		});
-		else if (Object.is(b, w)) continue;
-		else if (isMergeable(b) && isMergeable(w) && Object.getPrototypeOf(b) === Object.getPrototypeOf(w)) diff(b, w, [...path, key], changes, ancestors);
-		else if (!deepEqual(b, w)) changes.push({
-			path: [...path, key],
-			deleted: false,
-			value: w
-		});
-	}
-	for (const key of Object.keys(base)) if (!hasOwn$1(work, key)) changes.push({
-		path: [...path, key],
-		deleted: true
-	});
-	ancestors.delete(work);
-}
-/** Whether `ns` already holds what `change` would write. */
-function isApplied(ns, change) {
-	const parent = getByPath(ns, change.path.slice(0, -1));
-	if (parent === null || typeof parent !== "object") return change.deleted;
-	const key = change.path[change.path.length - 1];
-	if (!hasOwn$1(parent, key)) return change.deleted;
-	return !change.deleted && deepEqual(parent[key], change.value);
-}
-function applyChange(ns, change) {
-	if (change.deleted) deleteByPath(ns, change.path);
-	else setByPath(ns, change.path, change.value);
-}
-/**
 * Apply a write that reached the store while mutations execute to their
 * `work` and `base` copies (see MutationScope), so the code sees it and
 * its commit neither drops it nor reverts it. Called from inside the store
@@ -5687,7 +5624,7 @@ function mirror(draft, ns, change, scopes = activeScopes) {
 		});
 	} catch {
 		const stored = draft[ns][root];
-		if (hasOwn$1(draft[ns], root)) copy[root] = cloneValue(isDraft(stored) ? current(stored) : stored);
+		if (hasOwn(draft[ns], root)) copy[root] = cloneValue(isDraft(stored) ? current(stored) : stored);
 		else delete copy[root];
 	}
 }
@@ -5711,7 +5648,7 @@ function changedPath(ns, segments) {
 		if (!isMergeable(node)) break;
 		const key = String(segment);
 		path.push(key);
-		node = hasOwn$1(node, key) ? node[key] : void 0;
+		node = hasOwn(node, key) ? node[key] : void 0;
 	}
 	return path;
 }
@@ -5719,7 +5656,7 @@ function changedPath(ns, segments) {
 function changeTo(ns, path) {
 	const parent = getByPath(ns, path.slice(0, -1));
 	const key = path[path.length - 1];
-	return isMergeable(parent) && hasOwn$1(parent, key) ? {
+	return isMergeable(parent) && hasOwn(parent, key) ? {
 		path,
 		deleted: false,
 		value: parent[key]
@@ -5735,7 +5672,7 @@ function changeTo(ns, path) {
 * replaces exactly what it replaced in program order.
 */
 function writtenPaths(before, after, patches) {
-	if (patches.some((p) => p.path.length === 1)) return [...new Set([...Object.keys(before), ...Object.keys(after)])].filter((root) => !hasOwn$1(before, root) || before[root] !== after[root]).map((root) => changeTo(after, [root]));
+	if (patches.some((p) => p.path.length === 1)) return [...new Set([...Object.keys(before), ...Object.keys(after)])].filter((root) => !hasOwn(before, root) || before[root] !== after[root]).map((root) => changeTo(after, [root]));
 	const seen = /* @__PURE__ */ new Set();
 	const changes = [];
 	for (const patch of patches) {
@@ -5807,7 +5744,7 @@ function routeStoreUpdate(recipe) {
 			try {
 				applyChange(namespaces[ns], owned(change));
 			} catch {
-				if (hasOwn$1(inner.work[ns], root)) namespaces[ns][root] = cloneValue(inner.work[ns][root]);
+				if (hasOwn(inner.work[ns], root)) namespaces[ns][root] = cloneValue(inner.work[ns][root]);
 				else delete namespaces[ns][root];
 			}
 			mirror(namespaces, ns, change);
@@ -5838,11 +5775,7 @@ function commitScopes(commits) {
 	const all = commits.map(({ scope, keepRunning }) => ({
 		scope,
 		keepRunning,
-		changes: NAMESPACES.map((ns) => {
-			const list = [];
-			diff(scope.base[ns], scope.work[ns], [], list, /* @__PURE__ */ new Set());
-			return [ns, list];
-		})
+		changes: NAMESPACES.map((ns) => [ns, diffPaths(scope.base[ns], scope.work[ns])])
 	}));
 	const changed = all.filter(({ changes }) => changes.some(([, list]) => list.length > 0));
 	if (changed.length === 0) return;
@@ -5890,12 +5823,7 @@ var running = () => activeScopes.map((scope) => ({
 */
 function resync(scope) {
 	const state = useStoryStore.getState();
-	for (const ns of NAMESPACES) {
-		const work = scope.work[ns];
-		const stored = state[ns];
-		for (const key of Object.keys(work)) if (!hasOwn$1(stored, key)) delete work[key];
-		for (const key of Object.keys(stored)) if (!hasOwn$1(work, key) || !deepEqual(work[key], stored[key])) work[key] = deepClone(stored[key]);
-	}
+	for (const ns of NAMESPACES) mergeKeys(scope.work[ns], scope.work[ns], state[ns]);
 	scope.base = cloneNamespaces(state);
 }
 /**
@@ -5934,7 +5862,7 @@ function executeMutation(code, mergedLocals, scopeUpdate) {
 		keepRunning: false
 	}]);
 	for (const key of Object.keys(localsClone)) if (!deepEqual(localsClone[key], mergedLocals[key])) scopeUpdate(key, localsClone[key]);
-	for (const key of Object.keys(mergedLocals)) if (!hasOwn$1(localsClone, key)) scopeUpdate(key, void 0);
+	for (const key of Object.keys(mergedLocals)) if (!hasOwn(localsClone, key)) scopeUpdate(key, void 0);
 }
 //#endregion
 //#region src/triggers.ts
@@ -6164,7 +6092,7 @@ function clonePatches(patches) {
 function computeVarPatches(prev, curr) {
 	const [, forward, inverse] = produceWithPatches(prev, (draft) => {
 		const d = draft;
-		for (const key of Object.keys(d)) if (!Object.prototype.hasOwnProperty.call(curr, key)) delete d[key];
+		for (const key of Object.keys(d)) if (!hasOwn(curr, key)) delete d[key];
 		for (const [key, val] of Object.entries(curr)) d[key] = val;
 	});
 	return {
@@ -6181,6 +6109,26 @@ function rerecordNewestMoment(vars) {
 	if (last < 0) variableBase = vars;
 	else patchEntries[last] = computeVarPatches(reconstructVarsAt(last), vars);
 }
+/**
+* Call `fn` with the variables recorded for each of the first `count`
+* history moments, replaying the patches once.
+*/
+function forEachRecorded(count, fn) {
+	let vars = variableBase;
+	for (let i = 0; i < count; i++) {
+		if (i > 0) vars = applyPatches(vars, patchEntries[i - 1].forward);
+		fn(vars, i);
+	}
+}
+/** A history moment as saves and the session hold it, with its variables. */
+function savedMoment(moment, variables) {
+	return {
+		passage: moment.passage,
+		variables,
+		timestamp: moment.timestamp,
+		prng: moment.prng
+	};
+}
 /** Reconstruct variables at a given history moment by replaying patches. */
 function reconstructVarsAt(index) {
 	let vars = variableBase;
@@ -6194,24 +6142,10 @@ function persistSession(get) {
 	if (serializedHistory.length > history.length) serializedHistory.length = history.length;
 	if (serializedHistory.length < history.length) if (history.length - serializedHistory.length === 1) {
 		const i = history.length - 1;
-		serializedHistory[i] = {
-			passage: history[i].passage,
-			variables: serialize(variables),
-			timestamp: history[i].timestamp,
-			prng: history[i].prng
-		};
-	} else {
-		let vars = variableBase;
-		for (let i = 0; i < history.length; i++) {
-			if (i > 0) vars = applyPatches(vars, patchEntries[i - 1].forward);
-			if (i >= serializedHistory.length) serializedHistory[i] = {
-				passage: history[i].passage,
-				variables: serialize(vars),
-				timestamp: history[i].timestamp,
-				prng: history[i].prng
-			};
-		}
-	}
+		serializedHistory[i] = savedMoment(history[i], serialize(variables));
+	} else forEachRecorded(history.length, (vars, i) => {
+		if (i >= serializedHistory.length) serializedHistory[i] = savedMoment(history[i], serialize(vars));
+	});
 	saveSession(storyData.ifid, {
 		passage: currentPassage,
 		variables: serialize(variables),
@@ -6283,6 +6217,58 @@ function resetModuleState(base) {
 	serializedHistory = [];
 }
 /**
+* Fresh variables from `defaults` for a game that starts over (init,
+* restart), recorded as the history base.
+*/
+function startVariables(defaults) {
+	const initialVars = createNamespace(deepClone(defaults));
+	resetModuleState(deepClone(initialVars));
+	return initialVars;
+}
+/**
+* Enter the start passage with `variables`, as the only history moment
+* (init, restart). Call it inside a store update.
+*/
+function enterStart(state, passage, variables, transientDefaults) {
+	state.currentPassage = passage;
+	state.navigationId++;
+	state.variables = variables;
+	state.transient = createNamespace(deepClone(transientDefaults));
+	state.temporary = createNamespace();
+	state.history = [{
+		passage,
+		timestamp: Date.now()
+	}];
+	state.historyIndex = 0;
+}
+/**
+* Move through history by `step` moments (back or forward), restoring the
+* snapshot recorded for the moment moved to: live variables may hold edits
+* made since the current moment was recorded.
+*/
+function moveInHistory(get, set, step) {
+	const { historyIndex, history } = get();
+	const target = historyIndex + step;
+	if (target < 0 || target >= history.length) return;
+	finishEnteredMoment(get, set);
+	const previousPassage = get().currentPassage;
+	const targetPassage = history[target].passage;
+	emit("beforenavigate", targetPassage);
+	const restoredVars = deepClone(reconstructVarsAt(target));
+	set((state) => {
+		state.historyIndex += step;
+		state.currentPassage = state.history[state.historyIndex].passage;
+		state.navigationId++;
+		state.variables = restoredVars;
+		state.temporary = createNamespace();
+	});
+	reinitTriggerState();
+	lastNavigationVars = get().variables;
+	restorePRNGFromMoment(get().history[get().historyIndex]);
+	persistSession(get);
+	emit("afternavigate", targetPassage, previousPassage);
+}
+/**
 * Record the state StoryInit left behind as the start moment: its variable
 * snapshot (the history base) and PRNG state. Called by executeStoryInit()
 * after the StoryInit passage has rendered, and again after the `storyinit`
@@ -6293,10 +6279,7 @@ function resetModuleState(base) {
 function recordStoryInitState() {
 	const { history, historyIndex, variables } = useStoryStore.getState();
 	if (history.length !== 1 || historyIndex !== 0) return;
-	variableBase = variables;
-	patchEntries = [];
-	lastNavigationVars = variables;
-	serializedHistory = [];
+	resetModuleState(variables);
 	const prng = snapshotPRNG();
 	useStoryStore.setState((state) => {
 		state.history[0].prng = prng;
@@ -6466,56 +6449,31 @@ function keepHookWrites(payload, before, after) {
 	if (!moment) return;
 	mergeHookWrites(moment.variables, before, after, /* @__PURE__ */ new Set());
 }
-var hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-/**
-* Whether changes between `a` and `b` merge key by key: both are arrays,
-* or both are objects of one class (see isMergeable).
-*/
-function mergeable(a, b) {
-	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b);
-	return isMergeable(a) && isMergeable(b) && Object.getPrototypeOf(a) === Object.getPrototypeOf(b);
-}
-/**
-* Apply the hooks' change of a value, from `before` to `after`, to the
-* snapshot's copy of it, `target[key]`. Store updates are immutable, so a
-* value no hook touched keeps its identity; one rebuilt with equal content
-* (mutation code commits whole values) is no change either. Where `target`
-* lacks the key or holds another kind of value (the passage created or
-* replaced it), the hooks' whole value is written.
-*/
-function mergeHookWrite(target, key, before, after, ancestors) {
-	if (Object.is(before, after)) return;
-	if (mergeable(before, after) && hasOwn(target, key) && mergeable(after, target[key]) && !ancestors.has(after)) mergeHookWrites(target[key], before, after, ancestors);
-	else if (!deepEqual(before, after)) target[key] = deepClone(after);
-}
 /**
-* Apply the changes between `before` and `after`, two objects or two arrays
-* (see mergeable()), to the snapshot's `target`. Array elements merge by
-* index. Elements the hooks removed from an array's end are removed from
-* the snapshot's array at the same indices, and elements they added are
-* appended to it: where the passage resized the array, its indices do not
-* line up with the snapshot's, and the passage resizes it again on load.
+* Apply the hooks' changes between `before` and `after`, two objects or two
+* arrays, to the snapshot's copy of them, `target` (see mergeKeys: array
+* elements merge by index). A changed value is merged key by key where the
+* snapshot holds the same kind of value. Where it lacks the key or holds
+* another kind (the passage created or replaced it), the hooks' whole value
+* is written.
 */
 function mergeHookWrites(target, before, after, ancestors) {
 	ancestors.add(after);
-	if (Array.isArray(target)) {
-		const b = before;
-		const a = after;
-		const shared = Math.min(b.length, a.length, target.length);
-		for (let i = 0; i < shared; i++) mergeHookWrite(target, String(i), b[i], a[i], ancestors);
-		if (a.length < b.length) target.length = Math.min(target.length, a.length);
-		for (let i = b.length; i < a.length; i++) target.push(deepClone(a[i]));
-	} else {
-		for (const key of Object.keys(before)) if (!hasOwn(after, key)) delete target[key];
-		for (const key of Object.keys(after)) if (hasOwn(before, key)) mergeHookWrite(target, key, before[key], after[key], ancestors);
-		else target[key] = deepClone(after[key]);
-	}
+	mergeKeys(target, before, after, (key, b, a) => {
+		if (!hasOwn(target, key) || !mergesWith(a, target[key], true) || ancestors.has(a)) return false;
+		mergeHookWrites(target[key], b, a, ancestors);
+		return true;
+	});
 	ancestors.delete(after);
 }
+/** Restore the PRNG from a snapshot, or reset it without one. */
+function restorePRNGFrom(prng) {
+	if (prng) restorePRNG(prng.seed, prng.pull);
+	else resetPRNG();
+}
 /** Restore or reset PRNG from a history moment's snapshot. */
 function restorePRNGFromMoment(moment) {
-	if (moment?.prng) restorePRNG(moment.prng.seed, moment.prng.pull);
-	else if (moment) resetPRNG();
+	if (moment) restorePRNGFrom(moment.prng);
 }
 var NAMESPACE_KEYS = [
 	"variables",
@@ -6598,6 +6556,46 @@ function handled(p) {
 	p.catch(() => {});
 	return p;
 }
+/**
+* `p` with its failure logged under `message` and passed to `onError`, and
+* still rejecting; marked as handled (see handled()).
+*/
+function reported(p, message, onError) {
+	return handled(p.catch((err) => {
+		console.error(message, err);
+		onError?.(err);
+		throw err;
+	}));
+}
+/** Record in the slot cache whether `slot` holds a save. */
+function recordKnownSave(set, slot, known) {
+	set((state) => {
+		const key = slot ?? "";
+		if (known) state.knownSaves = {
+			...state.knownSaves,
+			[key]: true
+		};
+		else {
+			const { [key]: _, ...rest } = state.knownSaves;
+			state.knownSaves = rest;
+		}
+	});
+}
+/**
+* Queue the clearing of saved data, then restart now: the new playthrough
+* is stored after it, and operations issued from here on belong to the new
+* game. The slot cache empties once the clearing is done, after operations
+* issued before it have updated it.
+*/
+function clearAndRestart(get, set, clearing, message) {
+	const cleared = clearing.then(() => {
+		set((state) => {
+			state.knownSaves = {};
+		});
+	});
+	get().restart();
+	return reported(cleared, message);
+}
 var useStoryStore = create()(storyStore((set, get) => ({
 	storyData: null,
 	currentPassage: "",
@@ -6643,23 +6641,13 @@ var useStoryStore = create()(storyStore((set, get) => ({
 	init: (storyData, variableDefaults = {}, transientDefaults = {}) => {
 		const startPassage = storyData.passagesById.get(storyData.startNode);
 		if (!startPassage) throw new Error(`spindle: Start passage (pid=${storyData.startNode}) not found.`);
-		const initialVars = createNamespace(deepClone(variableDefaults));
-		resetModuleState(deepClone(initialVars));
+		const initialVars = startVariables(variableDefaults);
 		set((state) => {
 			state.storyData = storyData;
 			state.playthroughId = "";
-			state.currentPassage = startPassage.name;
-			state.navigationId++;
-			state.variables = initialVars;
 			state.variableDefaults = variableDefaults;
-			state.transient = createNamespace(deepClone(transientDefaults));
 			state.transientDefaults = transientDefaults;
-			state.temporary = createNamespace();
-			state.history = [{
-				passage: startPassage.name,
-				timestamp: Date.now()
-			}];
-			state.historyIndex = 0;
+			enterStart(state, startPassage.name, initialVars, transientDefaults);
 			state.visitCounts = createCounts(null, startPassage.name);
 			state.renderCounts = createCounts(null, startPassage.name);
 		});
@@ -6728,48 +6716,8 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		emit("afternavigate", passageName, previousPassage);
 		for (const next of deferred) get().navigate(next);
 	},
-	goBack: () => {
-		const { historyIndex } = get();
-		if (historyIndex <= 0) return;
-		finishEnteredMoment(get, set);
-		const previousPassage = get().currentPassage;
-		const targetPassage = get().history[historyIndex - 1].passage;
-		emit("beforenavigate", targetPassage);
-		const restoredVars = deepClone(reconstructVarsAt(historyIndex - 1));
-		set((state) => {
-			state.historyIndex--;
-			state.currentPassage = state.history[state.historyIndex].passage;
-			state.navigationId++;
-			state.variables = restoredVars;
-			state.temporary = createNamespace();
-		});
-		reinitTriggerState();
-		lastNavigationVars = get().variables;
-		restorePRNGFromMoment(get().history[get().historyIndex]);
-		persistSession(get);
-		emit("afternavigate", targetPassage, previousPassage);
-	},
-	goForward: () => {
-		const { historyIndex, history: hist } = get();
-		if (historyIndex >= hist.length - 1) return;
-		finishEnteredMoment(get, set);
-		const previousPassage = get().currentPassage;
-		const targetPassage = hist[historyIndex + 1].passage;
-		emit("beforenavigate", targetPassage);
-		const restoredVars = deepClone(reconstructVarsAt(historyIndex + 1));
-		set((state) => {
-			state.historyIndex++;
-			state.currentPassage = state.history[state.historyIndex].passage;
-			state.navigationId++;
-			state.variables = restoredVars;
-			state.temporary = createNamespace();
-		});
-		reinitTriggerState();
-		lastNavigationVars = get().variables;
-		restorePRNGFromMoment(get().history[get().historyIndex]);
-		persistSession(get);
-		emit("afternavigate", targetPassage, previousPassage);
-	},
+	goBack: () => moveInHistory(get, set, -1),
+	goForward: () => moveInHistory(get, set, 1),
 	setVariable: (name, value) => {
 		set((state) => {
 			checkVariableName(name, `$${name}`);
@@ -6831,19 +6779,9 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		cleanupRuntimeHandlers();
 		resetPRNG();
 		resetTriggers();
-		const initialVars = createNamespace(deepClone(variableDefaults));
-		resetModuleState(deepClone(initialVars));
+		const initialVars = startVariables(variableDefaults);
 		set((state) => {
-			state.currentPassage = startPassage.name;
-			state.navigationId++;
-			state.variables = initialVars;
-			state.transient = createNamespace(deepClone(transientDefaults));
-			state.temporary = createNamespace();
-			state.history = [{
-				passage: startPassage.name,
-				timestamp: Date.now()
-			}];
-			state.historyIndex = 0;
+			enterStart(state, startPassage.name, initialVars, transientDefaults);
 			state.visitCounts = createCounts(null, startPassage.name);
 			state.renderCounts = createCounts(null, startPassage.name);
 			if (!keepDeferred) state.renderDeferred = false;
@@ -6859,23 +6797,14 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		const { storyData } = get();
 		if (!storyData) return Promise.resolve();
 		const playthrough = resolvePlaythroughId();
-		return handled(saveWithHooks(slot, custom, get().beginSave, async (payload) => {
+		return reported(saveWithHooks(slot, custom, get().beginSave, async (payload) => {
 			set((state) => {
 				state.saveError = null;
 			});
 			await quickSave(storyData.ifid, playthrough, payload, slot, custom);
-			set((state) => {
-				state.knownSaves = {
-					...state.knownSaves,
-					[slot ?? ""]: true
-				};
-			});
-		}).catch((err) => {
-			console.error("spindle: failed to save", err);
-			set((state) => {
-				state.saveError = errorMessage(err, "Failed to save");
-			});
-			throw err;
+			recordKnownSave(set, slot, true);
+		}), "spindle: failed to save", (err) => set((state) => {
+			state.saveError = errorMessage(err, "Failed to save");
 		}));
 	},
 	load: (slot) => {
@@ -6888,24 +6817,20 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		const read = loadSlotSave(storyData.ifid, slot);
 		const switched = switchToLookedUpPlaythrough(Promise.all([previous, read.catch(() => void 0)]).then(([prev, loaded]) => loaded?.playthroughId || prev));
 		const replacement = ++stateReplacementsIssued;
-		return handled(read.then(async (loaded) => {
+		return reported(read.then(async (loaded) => {
 			await switched;
 			if (!loaded) return;
 			if (latestStateApplied > replacement) return;
 			slotLoadApplying = replacement;
 			get().loadFromPayload(loaded.payload, slot);
-		}).catch((err) => {
-			console.error("spindle: failed to load save", err);
-			set((state) => {
-				state.loadError = errorMessage(err, "Failed to load");
-			});
-			throw err;
+		}), "spindle: failed to load save", (err) => set((state) => {
+			state.loadError = errorMessage(err, "Failed to load");
 		}));
 	},
 	hasSave: (slot) => {
 		const { storyData, knownSaves } = get();
 		if (!storyData) return false;
-		return Object.prototype.hasOwnProperty.call(knownSaves, slot ?? "");
+		return hasOwn(knownSaves, slot ?? "");
 	},
 	getSaveInfo: async (slot) => {
 		const { storyData } = get();
@@ -6920,16 +6845,7 @@ var useStoryStore = create()(storyStore((set, get) => ({
 	deleteSave: (slot) => {
 		const { storyData } = get();
 		if (!storyData) return Promise.resolve();
-		return handled(deleteSlotSave(storyData.ifid, slot).then(() => {
-			set((state) => {
-				const key = slot ?? "";
-				const { [key]: _, ...rest } = state.knownSaves;
-				state.knownSaves = rest;
-			});
-		}).catch((err) => {
-			console.error("spindle: failed to delete save", err);
-			throw err;
-		}));
+		return reported(deleteSlotSave(storyData.ifid, slot).then(() => recordKnownSave(set, slot, false)), "spindle: failed to delete save");
 	},
 	exportSave: async (slot) => {
 		const { storyData } = get();
@@ -6941,40 +6857,15 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		if (!storyData) throw new Error("spindle: Story is not initialized.");
 		if (!isSaveExport(data)) throw new Error("Invalid save file format");
 		const info = await importSlotSave(data, storyData.ifid, slot);
-		set((state) => {
-			state.knownSaves = {
-				...state.knownSaves,
-				[slot ?? ""]: true
-			};
-		});
+		recordKnownSave(set, slot, true);
 		return info;
 	},
 	clearGameData: () => {
 		const { storyData } = get();
 		if (!storyData) return Promise.resolve();
-		const cleared = clearGameData(storyData.ifid).then(() => {
-			set((state) => {
-				state.knownSaves = {};
-			});
-		});
-		get().restart();
-		return handled(cleared.catch((err) => {
-			console.error("spindle: failed to clear game data", err);
-			throw err;
-		}));
-	},
-	clearAllData: () => {
-		const cleared = clearAllData().then(() => {
-			set((state) => {
-				state.knownSaves = {};
-			});
-		});
-		get().restart();
-		return handled(cleared.catch((err) => {
-			console.error("spindle: failed to clear all data", err);
-			throw err;
-		}));
+		return clearAndRestart(get, set, clearGameData(storyData.ifid), "spindle: failed to clear game data");
 	},
+	clearAllData: () => clearAndRestart(get, set, clearAllData(), "spindle: failed to clear all data"),
 	deletePlaythrough: (playthroughId) => {
 		const { storyData } = get();
 		if (!storyData) return Promise.resolve();
@@ -6988,29 +6879,19 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		});
 		if (playthroughId !== "" && playthroughId === current) switchToPlaythrough(replacementId, deletion);
 		else if (current === "") switchToLookedUpPlaythrough(deletion.then((replaced) => replaced ? replacementId : established, () => established));
-		return handled(deletion.then(async () => {
+		return reported(deletion.then(async () => {
 			const known = await populateKnownSaves(storyData.ifid);
 			set((state) => {
 				state.knownSaves = known;
 			});
-		}).catch((err) => {
-			console.error("spindle: failed to delete playthrough", err);
-			throw err;
-		}));
+		}), "spindle: failed to delete playthrough");
 	},
 	getSavePayload: () => {
 		const { currentPassage, variables, history, historyIndex, visitCounts, renderCounts } = get();
 		const saveHistory = [];
-		let vars = variableBase;
-		for (let i = 0; i < history.length; i++) {
-			if (i > 0) vars = applyPatches(vars, patchEntries[i - 1].forward);
-			saveHistory.push({
-				passage: history[i].passage,
-				variables: plainCopy(vars),
-				timestamp: history[i].timestamp,
-				prng: history[i].prng
-			});
-		}
+		forEachRecorded(history.length, (vars, i) => {
+			saveHistory.push(savedMoment(history[i], plainCopy(vars)));
+		});
 		return {
 			passage: currentPassage,
 			variables: plainCopy(variables),
@@ -7051,12 +6932,7 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		}
 		variableBase = deepClone(base);
 		patchEntries = newPatchEntries;
-		serializedHistory = payload.history.map((m) => ({
-			passage: m.passage,
-			variables: serialize(m.variables),
-			timestamp: m.timestamp,
-			prng: m.prng
-		}));
+		serializedHistory = payload.history.map((m) => savedMoment(m, serialize(m.variables)));
 		set((state) => {
 			state.currentPassage = payload.passage;
 			state.navigationId++;
@@ -7075,9 +6951,7 @@ var useStoryStore = create()(storyStore((set, get) => ({
 		});
 		reinitTriggerState();
 		lastNavigationVars = reconstructVarsAt(get().historyIndex);
-		const prng = entry?.prng !== void 0 ? entry.prng : payload.prng;
-		if (prng) restorePRNG(prng.seed, prng.pull);
-		else resetPRNG();
+		restorePRNGFrom(entry?.prng !== void 0 ? entry.prng : payload.prng);
 		persistSession(get);
 		withoutDraws(() => emit("afterload", slot));
 	},
@@ -7443,7 +7317,7 @@ function loadFromStorage() {
 /** Register a setting, starting from its default unless it has a value. */
 function define(name, def) {
 	definitions.set(name, def);
-	if (!hasOwn$2(values, name)) values[name] = def.config.default;
+	if (!hasOwn(values, name)) values[name] = def.config.default;
 	loadFromStorage();
 }
 /** The value of setting `name` if it has the type of `fallback`, else that. */
@@ -8857,7 +8731,7 @@ defineMacro({
 function liveLocalsView(getValues) {
 	return new Proxy(createNamespace(), {
 		get: (_, key) => typeof key === "string" ? ownValue(getValues(), key) : void 0,
-		has: (_, key) => typeof key === "string" && hasOwn$2(getValues(), key),
+		has: (_, key) => typeof key === "string" && hasOwn(getValues(), key),
 		ownKeys: () => Reflect.ownKeys(getValues()),
 		getOwnPropertyDescriptor: (_, key) => {
 			const desc = Object.getOwnPropertyDescriptor(getValues(), key);