@rohal12/spindle 0.59.3 → 0.59.4

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,
@@ -13693,23 +13710,42 @@ function underChange(path, keys) {
 	return false;
 }
 /**
-* Where each object (or array, or other value) of `root` first appears, in
-* depth-first order. Plain objects are entered; arrays and other values are
-* leaves. A path at or below one of `skip` is left out.
+* 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.
 */
-function firstPaths(root, skip = /* @__PURE__ */ new Set()) {
-	const found = /* @__PURE__ */ new Map();
+function objectPaths(root, skip = /* @__PURE__ */ new Set()) {
+	const all = /* @__PURE__ */ new Map();
 	(function walk(node, path) {
 		for (const key of Object.keys(node)) {
 			const value = node[key];
-			if (!isObjectValue(value) || found.has(value)) continue;
+			if (!isObjectValue(value)) continue;
 			const at = [...path, key];
 			if (skip.has(pathKey(at))) continue;
-			found.set(value, at);
-			if (isMergeable(value)) walk(value, at);
+			const known = all.get(value);
+			if (known) {
+				known.push(at);
+				continue;
+			}
+			all.set(value, [at]);
+			if (isMergeable(value) || Array.isArray(value)) walk(value, at);
 		}
 	})(root, []);
-	return found;
+	return all;
+}
+/** Where each object of `root` first appears (see objectPaths). */
+function firstPaths(root, skip) {
+	return new Map([...objectPaths(root, skip)].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);
 }
 /**
 * The paths whose object is another one in the references of `after` than in
@@ -13739,7 +13775,7 @@ 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);
+			if ((isMergeable(x) || Array.isArray(x)) && mergesWith(x, y, true) && pathKey(isAt) === k && pathKey(wasAt) === k) walk(x, y, at);
 		}
 	})(before, after, []);
 	return changes;
@@ -13780,8 +13816,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 +13968,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 +13987,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 +14194,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.
@@ -14597,17 +14634,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 +14744,19 @@ 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 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,23 +14764,48 @@ 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 })
+	};
+}
 /**
 * Commit the property paths each mutation's code changed (work vs base) on
 * top of the current store state, so writes made elsewhere during execution
@@ -14760,9 +14825,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,46 +14838,50 @@ 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']`): 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 the namespaces share is one
+* object, whichever of them it is reached through.
 */
 function changesOf(base, work) {
-	const written = diffPaths(base, work);
+	const before = base;
+	const after = work;
+	const written = diffPaths(before, after);
 	const keys = new Set(written.map((c) => pathKey(c.path)));
 	const aliases = [];
-	for (const change of aliasChanges(base, work)) {
+	for (const change of aliasChanges(before, after)) {
 		if (underChange(change.path, keys)) continue;
 		keys.add(pathKey(change.path));
 		aliases.push(change);
@@ -14853,14 +14922,38 @@ 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 scope = startScope();
+	try {
+		run(scope.work);
+	} 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 {
@@ -17338,6 +17431,12 @@ function createStoryAPI() {
 				const { isTransient, key } = parseName(name);
 				warnIfUndeclared(isTransient, key);
 			}
+			if (entries.some(([k]) => k.includes("."))) {
+				mutateState((work) => {
+					for (const [k, v] of entries) setOne(work, k, v);
+				});
+				return;
+			}
 			useStoryStore.getState().updateVariables((draft) => {
 				for (const [k, v] of entries) setOne(draft, k, v);
 			});
@@ -19729,13 +19828,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.4",
   "type": "module",
   "description": "A Preact-based story format for Twine 2.",
   "license": "Unlicense",

package/src/components/macros/Include.tsx

@@ -38,6 +38,13 @@ defineMacro({
       [passage],
     );
 
+    // Count the inclusion when its content mounts or the passage changes,
+    // not on every render (an unrelated variable update re-renders it)
+    const included = !failure && !!passage;
+    ctx.hooks.useEffect(() => {
+      if (included) useStoryStore.getState().trackRender(passageName);
+    }, [included, passageName]);
+
     if (!storyData) return null;
     if (failure) {
       return (
@@ -49,8 +56,6 @@ defineMacro({
     }
     if (!passage || !ast) return null;
 
-    useStoryStore.getState().trackRender(passageName);
-
     const nobr = passage.tags.includes('nobr');
     const content = inline
       ? ctx.renderInlineNodes(ast)