@rohal12/spindle 0.59.3 → 0.59.5

package/dist/pkg/headless.js

@@ -12897,6 +12897,23 @@ function makeTables(table) {
 		meta: table("meta", {})
 	};
 }
+/**
+* The meta keys a story owns, in one place: save-manager builds them,
+* deleteMetaByIfid() matches them. A story's key is its prefix followed by
+* its IFID, except a named slot's pointer, `slot.<name>.<IFID>`.
+*/
+var META_PREFIXES = {
+	autosave: "autosave.",
+	slot: "slot.",
+	slotIndex: "slotIndex.",
+	playthroughCount: "playthroughCount.",
+	currentPlaythrough: "currentPlaythroughId."
+};
+/** Whether the meta `key` belongs to the story `ifid` (and no other). */
+function isMetaKeyOf(key, ifid) {
+	const { slot, ...others } = META_PREFIXES;
+	return Object.values(others).some((prefix) => key === prefix + ifid) || key.startsWith(slot) && key.endsWith(`.${ifid}`);
+}
 function createBackend(type, { saves, playthroughs, meta }, destroy) {
 	/** Delete the records `field` finds, resolving to their keys. */
 	async function deleteFound(table, keyOf, field, value) {
@@ -12929,7 +12946,7 @@ function createBackend(type, { saves, playthroughs, meta }, destroy) {
 		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)),
+		deleteMetaByIfid: (ifid) => deleteMetaWhere((key) => isMetaKeyOf(key, ifid)),
 		getAllMetaKeys: () => meta.keys(),
 		destroy
 	};
@@ -13250,7 +13267,7 @@ var builtinName = atomicName;
 * 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));
+	const copy = Array.isArray(value) ? new Array(value.length) : Object.create(Object.getPrototypeOf(value));
 	for (const key of Object.keys(value)) Object.defineProperty(copy, key, {
 		value: value[key],
 		enumerable: true,
@@ -13409,7 +13426,11 @@ function deepClone(value, options = {}) {
 		}
 		if (val instanceof Map) {
 			const copy = keep(obj, /* @__PURE__ */ new Map());
-			for (const [k, v] of val) copy.set(clone(k), clone(v));
+			for (const [k, v] of val) {
+				const key = clone(k);
+				const settle = options.mapKey;
+				copy.set(settle && isObjectValue(key) && isObjectValue(k) ? settle(key, k) : key, clone(v));
+			}
 			return copy;
 		}
 		if (val instanceof Set) {
@@ -13662,15 +13683,16 @@ function keyChanges(before, after, arrays) {
 /**
 * 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.
+* property, any other value as a whole; with `arrays`, arrays are compared
+* by index too (see keyChanges).
 */
-function diffPaths(before, after) {
+function diffPaths(before, after, arrays = false) {
 	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)) {
+		for (const change of keyChanges(b, a, arrays)) {
 			const at = [...path, change.key];
 			if (change.kind === "nested") walk(change.before, change.after, at);
 			else changes.push(change.kind === "deleted" ? {
@@ -13679,7 +13701,8 @@ function diffPaths(before, after) {
 			} : {
 				path: at,
 				deleted: false,
-				value: change.after
+				value: change.after,
+				...change.kind === "added" && Array.isArray(a) ? { appended: true } : {}
 			});
 		}
 		ancestors.delete(a);
@@ -13692,24 +13715,85 @@ function underChange(path, keys) {
 	for (let n = 1; n <= path.length; n++) if (keys.has(pathKey(path.slice(0, n)))) return true;
 	return false;
 }
+/** The segment standing for the entry `index` of a Map or Set in a path. */
+var entryKey = (kind, index) => `\0${kind}${index}`;
 /**
-* Where each object (or array, or other value) of `root` first appears, in
-* depth-first order. Plain objects are entered; arrays and other values are
-* leaves. A path at or below one of `skip` is left out.
-*/
-function firstPaths(root, skip = /* @__PURE__ */ new Set()) {
-	const found = /* @__PURE__ */ new Map();
-	(function walk(node, path) {
+* Every path each object (or array, or other value) of `root` is at, the
+* first appearance first, in depth-first order. Plain objects and arrays are
+* entered, where first met only (an object held in an array is one object,
+* however it was reached); other values are leaves. A path at or below one
+* of `skip` is left out.
+*
+* With `entries`, the objects held in a Map or Set (as key, value or member)
+* are placed too, after everything else: one met nowhere else is at the path
+* of its Map or Set and the entry's segment (see entryKey), which is no path
+* a value can be read at, so only to tell where an object is from.
+*/
+function objectPaths(root, skip = /* @__PURE__ */ new Set(), entries = false) {
+	const all = /* @__PURE__ */ new Map();
+	const collections = [];
+	function place(value, at) {
+		const known = all.get(value);
+		if (known) {
+			known.push(at);
+			return;
+		}
+		all.set(value, [at]);
+		if (isMergeable(value) || Array.isArray(value)) walk(value, at);
+		else if (entries && (value instanceof Map || value instanceof Set)) collections.push([value, at]);
+	}
+	function walk(node, path) {
 		for (const key of Object.keys(node)) {
 			const value = node[key];
-			if (!isObjectValue(value) || found.has(value)) continue;
+			if (!isObjectValue(value)) continue;
 			const at = [...path, key];
 			if (skip.has(pathKey(at))) continue;
-			found.set(value, at);
-			if (isMergeable(value)) walk(value, at);
+			place(value, at);
+		}
+	}
+	walk(root, []);
+	for (const [collection, path] of collections) {
+		let index = 0;
+		for (const entry of collection.entries()) {
+			const [k, v] = entry;
+			const parts = collection instanceof Set ? [[k, entryKey("s", index)]] : [[k, entryKey("k", index)], [v, entryKey("v", index)]];
+			for (const [value, segment] of parts) if (isObjectValue(value) && !all.has(value)) place(value, [...path, segment]);
+			index++;
 		}
-	})(root, []);
-	return found;
+	}
+	return all;
+}
+/** Where each object of `root` first appears (see objectPaths). */
+function firstPaths(root, skip, entries) {
+	return new Map([...objectPaths(root, skip, entries)].map(([object, paths]) => [object, paths[0]]));
+}
+/**
+* The objects `root` holds at more than one path (an object two variables
+* refer to, or one that refers to itself), with every path they are at,
+* parents before children.
+*/
+function sharedPaths(root) {
+	return [...objectPaths(root).values()].filter((paths) => paths.length > 1);
+}
+/**
+* Whether the Map or Set `y` holds, at the position of an entry of `x`, another
+* object than `x` did (as to where its first appearance is, see aliasChanges):
+* `$map.set("k", $a)` over an equal object. Entries are compared by position,
+* and only when both hold as many; other differences are changes of content.
+*/
+function entryAliasChanged(x, y, earlier, later) {
+	const isSet = x instanceof Set && y instanceof Set;
+	if (!isSet && !(x instanceof Map && y instanceof Map)) return false;
+	if (Object.getPrototypeOf(x) !== Object.getPrototypeOf(y)) return false;
+	if (x.size !== y.size) return false;
+	const moved = (a, b) => isObjectValue(a) && isObjectValue(b) && pathKey(earlier.get(a)) !== pathKey(later.get(b));
+	const ys = [...y.entries()];
+	let index = 0;
+	for (const [k, v] of x.entries()) {
+		const [k2, v2] = ys[index++];
+		if (moved(k, k2) || !isSet && moved(v, v2)) return true;
+	}
+	return false;
 }
 /**
 * The paths whose object is another one in the references of `after` than in
@@ -13720,8 +13804,8 @@ function firstPaths(root, skip = /* @__PURE__ */ new Set()) {
 * `after` holds.
 */
 function aliasChanges(before, after) {
-	const earlier = firstPaths(before);
-	const later = firstPaths(after);
+	const earlier = firstPaths(before, void 0, true);
+	const later = firstPaths(after, void 0, true);
 	const changes = [];
 	(function walk(b, a, path) {
 		for (const key of Object.keys(a)) {
@@ -13739,12 +13823,36 @@ function aliasChanges(before, after) {
 				value: y,
 				alias: true
 			});
-			if (isMergeable(x) && mergesWith(x, y, false) && pathKey(isAt) === k && pathKey(wasAt) === k) walk(x, y, at);
+			else if (pathKey(isAt) === k && entryAliasChanged(x, y, earlier, later)) changes.push({
+				path: at,
+				deleted: false,
+				value: y,
+				alias: true
+			});
+			if ((isMergeable(x) || Array.isArray(x)) && mergesWith(x, y, true) && pathKey(isAt) === k && pathKey(wasAt) === k) walk(x, y, at);
 		}
 	})(before, after, []);
 	return changes;
 }
 /**
+* The changes from `before` to `after`, as paths below them: the property
+* paths that differ (see diffPaths), and those that hold equal content but
+* another object than they did (see aliasChanges), those first. Compared as
+* one object, so an object that two of their keys share is one object,
+* whichever of them it is reached through.
+*/
+function changesBetween(before, after, arrays = false) {
+	const written = diffPaths(before, after, arrays);
+	const keys = new Set(written.map((c) => pathKey(c.path)));
+	const aliases = [];
+	for (const change of aliasChanges(before, after)) {
+		if (underChange(change.path, keys)) continue;
+		keys.add(pathKey(change.path));
+		aliases.push(change);
+	}
+	return [...aliases, ...written];
+}
+/**
 * Where the objects of `source` are, other than at or below the paths of
 * `changes` (which write something new there), for `existingObjects`.
 */
@@ -13780,8 +13888,9 @@ function isApplied(target, change) {
 	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);
+	const root = target;
+	if (change.deleted) deleteByPath(root, change.path);
+	else setByPath(root, change.path, change.value);
 }
 /**
 * Write how `after` differs from `before` (see keyChanges; arrays merge by
@@ -13931,7 +14040,7 @@ async function startNewPlaythroughNow(ifid, id = randomUUID()) {
 }
 var PLAYTHROUGH_LABEL = /^Playthrough (\d+)$/;
 function playthroughCountKey(ifid) {
-	return `playthroughCount.${ifid}`;
+	return `${META_PREFIXES.playthroughCount}${ifid}`;
 }
 /**
 * The number of the next playthrough the story starts: one past the highest
@@ -13950,7 +14059,7 @@ async function nextPlaythroughNumber(ifid) {
 	return highest + 1;
 }
 function currentPlaythroughKey(ifid) {
-	return `currentPlaythroughId.${ifid}`;
+	return `${META_PREFIXES.currentPlaythrough}${ifid}`;
 }
 /**
 * Make `id` the story's current playthrough: the playthrough of a save the
@@ -14157,9 +14266,9 @@ var getSavesGrouped = queued(async function getSavesGroupedNow(ifid) {
 	});
 	return result;
 });
-var AUTOSAVE_KEY_PREFIX = "autosave.";
-var SLOT_KEY_PREFIX = "slot.";
-var SLOT_INDEX_KEY_PREFIX = "slotIndex.";
+var AUTOSAVE_KEY_PREFIX = META_PREFIXES.autosave;
+var SLOT_KEY_PREFIX = META_PREFIXES.slot;
+var SLOT_INDEX_KEY_PREFIX = META_PREFIXES.slotIndex;
 /**
 * Whether `slot` names a slot. The default (autosave) slot is addressed by
 * omitting `slot` or by `''`, the identifier its SaveInfo reports.
@@ -14563,9 +14672,18 @@ var cloneValue = (value) => deepClone(value, { keepUnregistered: true });
 */
 function clonerFor(target, paths) {
 	const seen = paths ? existingObjects(paths, target) : /* @__PURE__ */ new Map();
+	const mapKey = (copy, original) => {
+		const path = paths?.get(original);
+		if (!path || !isDraft(copy)) return copy;
+		const plain = current(copy);
+		setByPath(target, path, plain);
+		seen.set(original, plain);
+		return plain;
+	};
 	return (value) => deepClone(value, {
 		keepUnregistered: true,
-		seen
+		seen,
+		mapKey
 	});
 }
 /** One cloner per target copy, made when first used. */
@@ -14597,17 +14715,17 @@ function frozenCopy(value) {
 * path (the code replaced or deleted an intermediate object), its root is
 * replaced with the store's root as written.
 */
-function mirror(draft, ns, change, scopes = activeScopes, cloner = clonerOf) {
-	const root = change.path[0];
-	for (const scope of scopes) for (const copy of [scope.work[ns], scope.base[ns]]) try {
+function mirror(draft, change, scopes = activeScopes, cloner = clonerOf) {
+	const [ns, root] = change.path;
+	for (const scope of scopes) for (const copy of [scope.work, scope.base]) try {
 		applyChange(copy, change.deleted ? change : {
 			...change,
 			value: cloner(copy)(change.value)
 		});
 	} catch {
 		const stored = draft[ns][root];
-		if (hasOwn(draft[ns], root)) copy[root] = cloneValue(isDraft(stored) ? current(stored) : stored);
-		else delete copy[root];
+		if (hasOwn(draft[ns], root)) copy[ns][root] = cloneValue(isDraft(stored) ? current(stored) : stored);
+		else delete copy[ns][root];
 	}
 }
 /** A cloner of a copy of its own (no references shared with others). */
@@ -14707,16 +14825,20 @@ function routeStoreUpdate(recipe) {
 		transient: inner.work.transient
 	};
 	const [next, patches] = scratch.produceWithPatches(view, recipe);
-	const changes = NAMESPACES.map((ns) => {
+	const changes = NAMESPACES.flatMap((ns) => {
 		const own = patches.filter((p) => p.path[0] === ns);
-		return [ns, own.length ? writtenPaths(view[ns], next[ns], own) : []];
+		return own.length ? writtenPaths(view[ns], next[ns], own).map((change) => ({
+			...change,
+			path: [ns, ...change.path]
+		})) : [];
 	});
-	const cloners = clonersFor();
+	const held = locateObjects(namespacesOf(inner.work), changes);
+	const cloners = clonersFor(() => held);
 	const owned = (change, target) => change.deleted ? change : {
 		...change,
 		value: cloners(target)(change.value)
 	};
-	for (const [ns, list] of changes) for (const change of list) applyChange(inner.work[ns], owned(change, inner.work[ns]));
+	for (const change of changes) applyChange(inner.work, owned(change, inner.work));
 	return (draft) => {
 		const target = draft;
 		for (const key of Object.keys(next)) {
@@ -14724,22 +14846,53 @@ function routeStoreUpdate(recipe) {
 			if (!NAMESPACE_KEYS$1.has(key) && value !== view[key]) target[key] = value;
 		}
 		const namespaces = draft;
-		for (const [ns, list] of changes) for (const change of list) {
-			const root = change.path[0];
+		for (const change of changes) {
+			const [ns, root] = change.path;
 			try {
-				applyChange(namespaces[ns], owned(change, namespaces[ns]));
+				applyChange(namespaces, owned(change, namespaces));
 			} catch {
 				if (hasOwn(inner.work[ns], root)) namespaces[ns][root] = cloneValue(inner.work[ns][root]);
 				else delete namespaces[ns][root];
 			}
-			mirror(namespaces, ns, change, activeScopes, cloners);
+			mirror(namespaces, change, activeScopes, cloners);
 		}
 	};
 }
-var cloneNamespaces = (from) => ({
-	variables: deepClone(from.variables),
-	temporary: deepClone(from.temporary),
-	transient: deepClone(from.transient)
+/**
+* Make the objects `work` holds at several paths one object in `draft`
+* again where `changes` wrote below one of them: a write through one path
+* of a draft gives that path a new object, and the other paths would go on
+* referring to the old one (`$a.n = 2` with `$b` the same object as `$a`).
+*/
+function relink(draft, work, changes) {
+	const written = changes.map((c) => pathKey(c.path).slice(0, -1));
+	for (const [first, ...others] of sharedPaths(work)) {
+		const prefixes = [first, ...others].map((p) => pathKey(p).slice(0, -1));
+		if (!written.some((w) => prefixes.some((p) => w.startsWith(p)))) continue;
+		try {
+			const object = getByPath(draft, first);
+			if (object === null || typeof object !== "object") continue;
+			for (const path of others) setByPath(draft, path, object);
+		} catch {}
+	}
+}
+/**
+* Copies of the namespaces that keep their references to each other: an
+* object held in two of them (`%copy = $a`) is one object in the copies too.
+*/
+function cloneNamespaces(from) {
+	const seen = /* @__PURE__ */ new Map();
+	return {
+		variables: deepClone(from.variables, { seen }),
+		temporary: deepClone(from.temporary, { seen }),
+		transient: deepClone(from.transient, { seen })
+	};
+}
+/** The three variable namespaces of `state`, as an object to walk. */
+var namespacesOf = (state) => ({
+	variables: state.variables,
+	temporary: state.temporary,
+	transient: state.transient
 });
 /**
 * Commit the property paths each mutation's code changed (work vs base) on
@@ -14760,9 +14913,9 @@ function commitScopes(commits) {
 	const all = commits.map(({ scope, keepRunning }) => ({
 		scope,
 		keepRunning,
-		changes: NAMESPACES.map((ns) => [ns, changesOf(scope.base[ns], scope.work[ns])])
+		changes: changesOf(scope.base, scope.work)
 	}));
-	const changed = all.filter(({ changes }) => changes.some(([, list]) => list.length > 0));
+	const changed = all.filter(({ changes }) => changes.length > 0);
 	if (changed.length === 0) return;
 	for (const { scope, keepRunning } of changed) if (keepRunning) scope.base = cloneNamespaces(scope.work);
 	committing = true;
@@ -14773,52 +14926,41 @@ function commitScopes(commits) {
 	}
 	function commitRecipe(draft) {
 		all.forEach(({ scope, changes }, i) => {
-			const paths = new Map(changes.map(([ns, list]) => [ns, locateObjects(scope.work[ns], list)]));
-			const own = new Map(changes.map(([ns]) => [ns, clonerFor(draft[ns], paths.get(ns))]));
+			const paths = locateObjects(scope.work, changes);
+			const own = clonerFor(draft, paths);
 			const enclosing = all.slice(0, i).map((c) => c.scope);
-			const enclosingCloners = new Map(changes.map(([ns]) => [ns, clonersFor(() => paths.get(ns))]));
-			for (const [ns, list] of changes) {
-				const replaced = /* @__PURE__ */ new Set();
-				for (const change of list) {
-					const root = change.path[0];
-					if (replaced.has(root)) continue;
-					try {
-						if (change.deleted) {
-							if (!isApplied(draft[ns], change)) applyChange(draft[ns], change);
-							continue;
-						}
-						const value = change.alias ? own.get(ns)(change.value) : void 0;
-						if (change.alias ? Object.is(getByPath(draft[ns], change.path), value) : isApplied(draft[ns], change)) continue;
-						applyChange(draft[ns], {
-							...change,
-							value: change.alias ? value : own.get(ns)(change.value)
-						});
-					} catch {
-						draft[ns][root] = own.get(ns)(scope.work[ns][root]);
-						replaced.add(root);
+			const enclosingCloners = clonersFor(() => paths);
+			const replaced = /* @__PURE__ */ new Set();
+			for (const change of changes) {
+				const [ns, root] = change.path;
+				const rootKey = pathKey([ns, root]);
+				if (replaced.has(rootKey)) continue;
+				try {
+					if (change.deleted) {
+						if (!isApplied(draft, change)) applyChange(draft, change);
+						continue;
 					}
+					const value = change.alias ? own(change.value) : void 0;
+					if (change.alias ? Object.is(getByPath(draft, change.path), value) : isApplied(draft, change)) continue;
+					applyChange(draft, {
+						...change,
+						value: change.alias ? value : own(change.value)
+					});
+				} catch {
+					draft[ns][root] = own(scope.work[ns][root]);
+					replaced.add(rootKey);
 				}
-				for (const change of list) mirror(draft, ns, change, enclosing, enclosingCloners.get(ns));
 			}
+			relink(draft, scope.work, changes);
+			for (const change of changes) mirror(draft, change, enclosing, enclosingCloners);
 		});
 	}
 }
 /**
-* The changes of the code to a namespace: its property paths that differ
-* (see diffPaths), and those that hold equal content but another object
-* than they did (see aliasChanges), those first.
+* The changes of the code to the namespaces, as paths below them (`['variables',
+* 'a']`; see changesBetween).
 */
-function changesOf(base, work) {
-	const written = diffPaths(base, work);
-	const keys = new Set(written.map((c) => pathKey(c.path)));
-	const aliases = [];
-	for (const change of aliasChanges(base, work)) {
-		if (underChange(change.path, keys)) continue;
-		keys.add(pathKey(change.path));
-		aliases.push(change);
-	}
-	return [...aliases, ...written];
-}
+var changesOf = (base, work) => changesBetween(base, work);
 /** Every running mutation, to commit with its code going on. */
 var running = () => activeScopes.map((scope) => ({
 	scope,
@@ -14853,14 +14995,40 @@ function runWithCommittedMutations(action) {
 		for (const scope of suspended) resync(scope);
 	}
 }
-function executeMutation(code, mergedLocals, scopeUpdate) {
+/**
+* Run `run` on working copies of the story state and commit what it changed
+* to the store, as mutation code does (see commitScopes): the references
+* between values are kept, which a store update made on a draft does not do.
+* Nothing is committed when `run` throws.
+*/
+function mutateState(run) {
+	commitScopes(running());
+	const held = locateObjects(namespacesOf(getActiveMutationScope() ?? useStoryStore.getState()), []);
+	const scope = startScope();
+	const adopt = clonerFor(scope.work, held);
+	try {
+		run(scope.work, adopt);
+	} finally {
+		activeScopes.pop();
+	}
+	commitScopes([...running(), {
+		scope,
+		keepRunning: false
+	}]);
+}
+/** Start a mutation, from the pending state of the one it runs inside. */
+function startScope() {
 	const start = getActiveMutationScope() ?? useStoryStore.getState();
 	const scope = {
 		work: cloneNamespaces(start),
 		base: cloneNamespaces(start)
 	};
-	const localsClone = asNamespace(deepClone(mergedLocals, { keepUnregistered: true }));
 	activeScopes.push(scope);
+	return scope;
+}
+function executeMutation(code, mergedLocals, scopeUpdate) {
+	const localsClone = asNamespace(deepClone(mergedLocals, { keepUnregistered: true }));
+	const scope = startScope();
 	try {
 		execute(code, scope.work.variables, scope.work.temporary, localsClone, scope.work.transient);
 	} finally {
@@ -15594,35 +15762,60 @@ function loadedEntryMoment(payload) {
 * the `beforesave` hooks) into the payload's snapshot of the saved moment. A
 * load restores that snapshot, the state on entering the passage, and runs
 * the passage again, so data a hook adds to a save would otherwise be lost
-* on load (#227). Only the property paths the hooks changed are written (into
-* copies of the objects on those paths, the rest staying shared): a
-* whole variable would bring along what the passage did to the rest of it,
-* which the passage then does again on load (#232). Only the payload's copy
-* changes: the live history keeps the recorded snapshot (#159).
+* on load (#227). Only the property paths the hooks changed are written (see
+* changesBetween): a whole variable would bring along what the passage did
+* to the rest of it, which the passage then does again on load (#232). The
+* references the hooks made stay: an object they put in two variables is one
+* object in the snapshot, and one they made another variable refer to is the
+* snapshot's own object of it (#302). Only the payload's copy changes: the
+* live history keeps the recorded snapshot (#159).
 */
 function keepHookWrites(payload, before, after) {
 	const moment = payload.history[payload.historyIndex];
 	if (!moment) return;
-	mergeHookWrites(moment.variables, before, after, /* @__PURE__ */ new Set());
-}
-/**
-* 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);
-	mergeKeys(target, before, after, (key, b, a) => {
-		if (!hasOwn(target, key) || !mergesWith(a, target[key], true) || ancestors.has(a)) return false;
-		const copy = shallowCopy(target[key]);
-		target[key] = copy;
-		mergeHookWrites(copy, b, a, ancestors);
-		return true;
-	});
-	ancestors.delete(after);
+	const changes = changesBetween(before, after, true);
+	if (changes.length === 0) return;
+	const work = deepClone(moment.variables);
+	const seen = existingObjects(locateObjects(after, changes), work);
+	const own = (value) => deepClone(value, { seen });
+	for (const change of changes) writeHookChange(work, after, change, own);
+	moment.variables = shareEqual(moment.variables, work);
+}
+/**
+* Write `change` (of the hooks, to `after`) into `work`. The value goes in at
+* the first place `work` lacks the objects on the path of one of the kind
+* `after` holds (the passage created or replaced it): there, the hooks' whole
+* value of it is written. Into an array, elements removed from the end are
+* removed at the same indices and elements added are appended; changes at
+* indices the array lacks are dropped (it was resized, so its indices do not
+* line up with the live ones).
+*/
+function writeHookChange(work, after, change, own) {
+	const { path } = change;
+	let holder = work;
+	let depth = 0;
+	for (; depth < path.length - 1; depth++) {
+		const key = path[depth];
+		const child = hasOwn(holder, key) ? holder[key] : void 0;
+		const held = getByPath(after, path.slice(0, depth + 1));
+		if (!mergesWith(child, held, true)) {
+			writeKey(holder, key, false, own(held));
+			return;
+		}
+		holder = child;
+	}
+	const key = path[depth];
+	if (change.deleted) writeKey(holder, key, true, void 0);
+	else writeKey(holder, key, false, own(change.value), change.appended);
+}
+function writeKey(holder, key, deleted, value, appended) {
+	if (Array.isArray(holder)) {
+		const index = Number(key);
+		if (deleted) holder.length = Math.min(holder.length, index);
+		else if (appended) holder.push(value);
+		else if (index < holder.length) holder[index] = value;
+	} else if (deleted) delete holder[key];
+	else setOwn(holder, key, value);
 }
 /** Restore the PRNG from a snapshot, or reset it without one. */
 function restorePRNGFrom(prng) {
@@ -17196,8 +17389,8 @@ function defineMacro(config, source = "builtin") {
 			ctx.value = useStoryStore((s) => getByPath(s.variables, segments));
 			ctx.getValue = () => getByPath(readState().variables, segments);
 			ctx.setValue = (value) => {
-				useStoryStore.setState((state) => {
-					setByPath(state.variables, segments, value, { createMissing: true });
+				mutateState((work, adopt) => {
+					setByPath(work.variables, segments, adopt(value), { createMissing: true });
 				});
 			};
 		}
@@ -17338,6 +17531,12 @@ function createStoryAPI() {
 				const { isTransient, key } = parseName(name);
 				warnIfUndeclared(isTransient, key);
 			}
+			if (entries.some(([k]) => k.includes("."))) {
+				mutateState((work, adopt) => {
+					for (const [k, v] of entries) setOne(work, k, adopt(v));
+				});
+				return;
+			}
 			useStoryStore.getState().updateVariables((draft) => {
 				for (const [k, v] of entries) setOne(draft, k, v);
 			});
@@ -19729,13 +19928,16 @@ defineMacro({
 		}
 		const passage = storyData?.passages.get(passageName);
 		const ast = ctx.hooks.useMemo(() => passage ? parseMarkup(passage.content) : null, [passage]);
+		const included = !failure && !!passage;
+		ctx.hooks.useEffect(() => {
+			if (included) useStoryStore.getState().trackRender(passageName);
+		}, [included, passageName]);
 		if (!storyData) return null;
 		if (failure) return /* @__PURE__ */ jsx(MacroError, {
 			macro: "include",
 			error: failure.error
 		});
 		if (!passage || !ast) return null;
-		useStoryStore.getState().trackRender(passageName);
 		const nobr = passage.tags.includes("nobr");
 		const content = inline ? ctx.renderInlineNodes(ast) : ctx.renderNodes(ast, nobr ? { nobr: true } : void 0);
 		if (nobr) return ctx.wrap(ctx.h(NobrContext.Provider, { value: true }, content));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rohal12/spindle",
-  "version": "0.59.3",
+  "version": "0.59.5",
   "type": "module",
   "description": "A Preact-based story format for Twine 2.",
   "license": "Unlicense",