@rohal12/spindle 0.59.0 → 0.59.1

package/dist/pkg/headless.js

@@ -13080,7 +13080,15 @@ function createIDBBackend() {
 		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)));
+			const tx = (await openDB()).transaction(name, mode);
+			const result = idbReq(make(tx.objectStore(name)));
+			if (mode === "readonly") return result;
+			const committed = new Promise((resolve, reject) => {
+				tx.oncomplete = () => resolve();
+				tx.onabort = () => reject(tx.error ?? new DOMException("Transaction aborted", "AbortError"));
+			});
+			const [value] = await Promise.all([result, committed]);
+			return value;
 		};
 		return {
 			async get(key) {
@@ -13319,15 +13327,22 @@ var ERROR_HIDDEN_KEYS = [
 	"errors"
 ];
 function deepClone(value, options = {}) {
-	const seen = /* @__PURE__ */ new Map();
+	const seen = options.seen ?? /* @__PURE__ */ new Map();
 	/** Record `copy` as the copy of `obj` before its contents are copied. */
 	const keep = (obj, copy) => {
 		seen.set(obj, copy);
 		return copy;
 	};
-	/** Copy the own (enumerable) keys of `obj` into `copy`. */
+	/**
+	* Copy the own (enumerable) keys of `obj` into `copy`, symbol keys too: a
+	* save refuses them, which a copy must not hide.
+	*/
 	function copyKeys(obj, copy) {
 		for (const key of Object.keys(obj)) setOwn(copy, key, clone(obj[key]));
+		for (const sym of Object.getOwnPropertySymbols(obj)) {
+			if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) continue;
+			copy[sym] = clone(obj[sym]);
+		}
 		return copy;
 	}
 	function cloneBuiltin(val) {
@@ -13410,65 +13425,83 @@ function loosePairs() {
 /**
 * Pairs that also require the same reference structure: each object of one
 * value pairs with exactly one of the other, so shared references and
-* cycles are shared at the same places.
+* cycles are shared at the same places. `ab` and `ba` hold the pairs (and
+* may hold some already); those made are listed in `added`.
 */
-function strictPairs() {
-	const ab = /* @__PURE__ */ new Map();
-	const ba = /* @__PURE__ */ new Map();
-	const pairs = (a, b) => {
+function strictPairs(ab = /* @__PURE__ */ new Map(), ba = /* @__PURE__ */ new Map()) {
+	const added = [];
+	const pairs = ((a, b) => {
 		const known = ab.get(a);
 		if (known !== void 0) return known === b;
 		if (ba.has(b)) return false;
 		ab.set(a, b);
 		ba.set(b, a);
-	};
+		added.push([a, b]);
+	});
 	pairs.strict = true;
+	pairs.added = added;
 	return pairs;
 }
 /**
-* Whether `a` and `b` are equal as deepEqual() has it and also share
-* references at the same places (a save of one loads as the other).
-*/
-function deepEqualStrict(a, b) {
-	return equal(a, b, strictPairs());
-}
-/**
 * `curr` with each part that equals (see deepEqualStrict) the part of
 * `prev` at the same place replaced by `prev`'s: the history moments of a
 * save then share what did not change between them, which a save stores
 * once. Containers on the way to a change are copied; neither value is
-* changed. Shared references and cycles within `curr` stay so.
+* changed. The result has the reference structure of `curr`: what `curr`
+* shares or cycles through stays so, and what it does not share stays
+* apart, whichever parts are reused.
 */
 function shareEqual(prev, curr) {
+	if (!isObjectValue(prev) || !isObjectValue(curr)) return curr;
+	/** The object of the result standing for each object of `curr` met. */
 	const done = /* @__PURE__ */ new Map();
-	function share(p, c) {
-		if (p === c || !isObjectValue(c) || !isObjectValue(p)) return c;
-		if (done.has(c)) return done.get(c);
-		if (deepEqualStrict(p, c)) {
-			done.set(c, p);
-			return p;
+	/** The object of `curr` each object of `prev` in the result stands for. */
+	const used = /* @__PURE__ */ new Map();
+	/** `value` for the result: copied, as far as it is not met already. */
+	const fresh = (value) => isObjectValue(value) ? deepClone(value, {
+		keepUnregistered: true,
+		seen: done
+	}) : value;
+	/**
+	* Whether `p` and `c` are equal and so can stand for each other, which
+	* needs each object in them to stand for one object only, in the whole
+	* result. Then every pair of objects they hold is placed in the result.
+	*/
+	function reuse(p, c) {
+		const pairs = strictPairs(used, done);
+		if (equal(p, c, pairs)) return true;
+		for (const [a, b] of pairs.added) {
+			used.delete(a);
+			done.delete(b);
 		}
+		return false;
+	}
+	function share(p, c) {
+		if (!isObjectValue(c)) return c;
+		const placed = done.get(c);
+		if (placed !== void 0) return placed;
+		if (!isObjectValue(p)) return fresh(c);
+		if (reuse(p, c)) return p;
 		if (c instanceof Map && p instanceof Map) {
 			const out = /* @__PURE__ */ new Map();
 			done.set(c, out);
-			for (const [k, v] of c) out.set(k, p.has(k) ? share(p.get(k), v) : v);
+			for (const [k, v] of c) out.set(fresh(k), share(p.get(k), v));
 			return out;
 		}
 		if (Array.isArray(c) && Array.isArray(p)) {
 			const out = new Array(c.length);
 			done.set(c, out);
-			for (let i = 0; i < c.length; i++) if (i in c) out[i] = i < p.length ? share(p[i], c[i]) : c[i];
+			for (let i = 0; i < c.length; i++) if (i in c) out[i] = share(p[i], c[i]);
 			return out;
 		}
 		if (mergesWith(p, c, false)) {
 			const out = Object.create(Object.getPrototypeOf(c));
 			done.set(c, out);
 			const cr = c;
-			for (const key of Object.keys(cr)) setOwn(out, key, hasOwn(p, key) ? share(p[key], cr[key]) : cr[key]);
+			for (const key of Object.keys(cr)) setOwn(out, key, share(hasOwn(p, key) ? p[key] : void 0, cr[key]));
 			return out;
 		}
-		done.set(c, c);
-		return c;
+		return fresh(c);
 	}
 	return share(prev, curr);
 }
@@ -14942,7 +14975,10 @@ var lastNavigationVars = createNamespace();
 * object) or deleted. A recorded value is a deep copy, so that changing a
 * live value in place (a class instance is not frozen) cannot change
 * history; instances of unregistered classes are kept, as the store keeps
-* them (a save then refuses them).
+* them (a save then refuses them). The copies are made together, so what
+* variables share (an object, a cycle) stays shared in them, and a variable
+* left as it is that shares with a replaced one is recorded again, to share
+* with its copy.
 */
 function computeVarPatches(prev, curr) {
 	const forward = [];
@@ -14950,11 +14986,33 @@ function computeVarPatches(prev, curr) {
 		key,
 		deleted: true
 	});
-	for (const key of Object.keys(curr)) if (!hasOwn(prev, key) || !Object.is(prev[key], curr[key])) forward.push({
+	const seen = /* @__PURE__ */ new Map();
+	const record = (key) => forward.push({
 		key,
 		deleted: false,
-		value: deepClone(curr[key], { keepUnregistered: true })
+		value: deepClone(curr[key], {
+			keepUnregistered: true,
+			seen
+		})
 	});
+	const unchanged = [];
+	for (const key of Object.keys(curr)) if (!hasOwn(prev, key) || !Object.is(prev[key], curr[key])) record(key);
+	else if (typeof curr[key] === "object" && curr[key] !== null) unchanged.push(key);
+	for (let found = seen.size > 0; found;) {
+		found = false;
+		for (const key of unchanged) {
+			const probe = /* @__PURE__ */ new Map();
+			deepClone(curr[key], {
+				keepUnregistered: true,
+				seen: probe
+			});
+			if (![...probe.keys()].some((object) => seen.has(object))) continue;
+			record(key);
+			unchanged.splice(unchanged.indexOf(key), 1);
+			found = true;
+			break;
+		}
+	}
 	return { forward };
 }
 /**
@@ -17364,10 +17422,6 @@ function parameterLookup(macros) {
 }
 /** What a `string` or `text` argument holds when its parameter doesn't say. */
 var holdsByDefault = (interpolate) => interpolate ? "markup" : "text";
-/** Whether a parameter in `params` (options too) holds code in a string. */
-function holdsCode(params) {
-	return params.some((p) => p.holds === "expression" || p.holds === "statements" || !!p.parameters && holdsCode(p.parameters));
-}
 /** The goal of the code an argument of this type holds, if it is code. */
 function codeGoal(param) {
 	if (param.type === "expression" || param.type === "passage") return "expression";
@@ -17564,7 +17618,7 @@ function* argPieces(args, offset, params, macro, label) {
 			};
 		}
 	}
-	yield* visit(params, values);
+	yield* [...visit(params, values)].sort((a, b) => a.offset - b.offset);
 }
 /**
 * Index of `part` in `text` from `from` on, else anywhere, else `from`: the
@@ -17819,7 +17873,6 @@ function declarationRegex(sigil) {
 var VAR_PATH_RE = /\$(\w+(?:\.\w+)*)/y;
 /** Quoted first argument of an input macro naming a story variable. */
 var QUOTED_VAR_ARG_RE = /^["']\$(\w+(?:\.\w+)*)["']?$/;
-var FOR_LOCAL_RE = /\{for\s+@(\w+)(?:\s*,\s*@(\w+))?\s+of\b/g;
 var VALID_VAR_TYPES = new Set([
 	"number",
 	"string",
@@ -17882,30 +17935,14 @@ function parseStoryVariables(content, sigil = "$") {
 	return schema;
 }
 /**
-* Extract for-loop local variable names from passage content.
-* `{for @item of ...}` → "item"
-* `{for @index, @item of ...}` → "index", "item"
-*/
-function extractForLocals(content) {
-	const locals = /* @__PURE__ */ new Set();
-	let match;
-	FOR_LOCAL_RE.lastIndex = 0;
-	while ((match = FOR_LOCAL_RE.exec(content)) !== null) {
-		locals.add(match[1]);
-		if (match[2]) locals.add(match[2]);
-	}
-	return locals;
-}
-/**
 * Validate a single variable reference path (e.g. "player.health") against
 * the schema. Returns an error message or null if valid.
 */
-function validateRef(ref, schema, forLocals) {
+function validateRef(ref, schema) {
 	const parts = ref.split(".");
 	const rootName = parts[0];
 	const nameError = variableNameError(rootName, "$" + rootName);
 	if (nameError) return nameError;
-	if (forLocals.has(rootName)) return null;
 	const rootSchema = schema.get(rootName);
 	if (!rootSchema) return `Undeclared variable: $${ref}`;
 	let current = rootSchema;
@@ -17961,8 +17998,9 @@ function scanInterpolations(text, onRef, storeVarMacros = NO_STORE_VAR_MACROS) {
 * Report `$var` references in JavaScript code, lexed as the expression
 * engine lexes it (`lexJs`): references in code, but none inside string or
 * regex literals or comments, nor property names (`a.$b`, `{ $b: 1 }`).
-* The text of string and template literals is scanned for the markup that
-* labels evaluate (`{$…}`); the `${…}` parts of template literals are code.
+* The text of string and template literals is not scanned: a string in code
+* is literal text unless a macro argument that holds markup is read as such
+* (see scanArgs); the `${…}` parts of template literals are code.
 */
 function scanCode(code, onRef, goal = "expression") {
 	const parsed = parseOrError(code, goal);
@@ -17975,37 +18013,17 @@ function scanCode(code, onRef, goal = "expression") {
 		VAR_PATH_RE.lastIndex = ref.start;
 		onRef(VAR_PATH_RE.exec(code)[1]);
 	}
-	for (const text of parsed.strings) scanInterpolations(text, onRef);
 }
 /** `scanCode` for code acorn can't parse: lexed leniently. */
 function scanCodeLeniently(code, onRef, goal) {
-	/** Open template literals: their text so far, null in an interpolation. */
-	const templates = [];
 	lexJs(code, {
 		variable(sigil, _name, index) {
 			if (sigil !== "$") return;
 			VAR_PATH_RE.lastIndex = index;
 			onRef(VAR_PATH_RE.exec(code)[1]);
 		},
-		literal(text, _index, nesting) {
-			const template = templates[templates.length - 1];
-			if (template?.nesting === nesting) if (template.text === null) template.text = "";
-			else if (text === "`" || text === "${") {
-				scanInterpolations(template.text, onRef);
-				if (text === "`") templates.pop();
-				else template.text = null;
-			} else template.text += text;
-			else if (text === "`") templates.push({
-				nesting,
-				text: ""
-			});
-			else if (text[0] === "\"" || text[0] === "'") {
-				const { closed } = scanStringLiteral(text, 0);
-				scanInterpolations(text.slice(1, closed ? -1 : void 0), onRef);
-			}
-		}
+		literal() {}
 	}, goal);
-	for (const t of templates) if (t.text) scanInterpolations(t.text, onRef);
 }
 /**
 * Report the `$var` references a passage evaluates at runtime: `{$var}`
@@ -18017,14 +18035,23 @@ function collectPassageRefs(content, storeVarMacros, onRef, parametersOf) {
 	withParseCache(() => collectTokenRefs(content, tokensOf(content, false), storeVarMacros, onRef, parametersOf));
 }
 /**
-* Report the references in the code that a macro's quoted arguments hold
-* (see ParameterDef.holds), the condition and `run` action of `{watch}`:
-* the argument scan sees only the strings. Only the macros that declare
-* code in a string have their arguments read.
+* Report the references in the arguments of a macro by what its parameters
+* say each holds (see ParameterDef.holds): code is scanned as code and
+* markup as markup, but literal text (a placeholder, a passage name) holds
+* none. A macro without declared parameters, or arguments that do not
+* parse, are scanned as code.
 */
-function scanStringCode(token, params, onRef) {
-	if (!params || !token.rawArgs || !holdsCode(params)) return;
-	for (const piece of argPieces(token.rawArgs, 0, params, token.name, "")) if (piece.kind === "code" && piece.inString) scanCode(piece.code, onRef, piece.goal);
+function scanArgs(token, params, onRef) {
+	if (!token.rawArgs) return;
+	if (params) {
+		const pieces = [...argPieces(token.rawArgs, 0, params, token.name, "")];
+		if (!pieces.some((piece) => piece.kind === "argument-error")) {
+			for (const piece of pieces) if (piece.kind === "code") scanCode(piece.code, onRef, piece.goal);
+			else if (piece.kind === "text") scanInterpolations(piece.text, onRef);
+			return;
+		}
+	}
+	scanCode(token.rawArgs, onRef);
 }
 /** Report the `$var` references in the tokens of `content`. */
 function collectTokenRefs(content, tokens, storeVarMacros, onRef, parametersOf = () => void 0) {
@@ -18036,12 +18063,12 @@ function collectTokenRefs(content, tokens, storeVarMacros, onRef, parametersOf =
 		else if (token.type === "html") for (const [name, value] of Object.entries(token.attributes)) if (isCodeAttribute(name)) scanSigilReferences(value, onRef);
 		else scanInterpolations(value, onRef, storeVarMacros);
 		else if (token.type === "macro" && !token.isClose) {
-			scanCode(token.rawArgs, onRef);
-			scanStringCode(token, parametersOf(token.name), onRef);
+			scanArgs(token, parametersOf(token.name), onRef);
 			if (storeVarMacros.has(token.name.toLowerCase())) {
 				const first = token.rawArgs.trim().split(/\s+/)[0] ?? "";
 				const quoted = QUOTED_VAR_ARG_RE.exec(first);
 				if (quoted) onRef(quoted[1]);
+				else if (!/^["'`]/.test(first)) scanCode(first, onRef);
 			}
 			if (token.name === "do") {
 				let close = t + 1;
@@ -18071,9 +18098,8 @@ function validatePassages(passages, schema, storeVarMacros = BUILTIN_STORE_VAR_M
 	const storeVarSet = new Set(Array.from(storeVarMacros, (m) => m.toLowerCase()));
 	for (const [name, passage] of passages) {
 		if (NOT_MARKUP.has(name)) continue;
-		const forLocals = extractForLocals(passage.content);
 		collectPassageRefs(passage.content, storeVarSet, (ref) => {
-			const error = validateRef(ref, schema, forLocals);
+			const error = validateRef(ref, schema);
 			if (error) errors.push(`Passage "${name}": ${error}`);
 		}, parametersOf);
 	}
@@ -18336,7 +18362,10 @@ defineMacro({
 	],
 	render(_props, ctx) {
 		try {
-			const { currentExpr, maxExpr, labelMode } = meterArgs(ctx.args);
+			const { currentExpr, maxExpr, labelMode } = meterArgs({
+				...ctx.args,
+				label: ctx.resolve?.(ctx.args.label)
+			});
 			const current = Number(ctx.evaluate(currentExpr));
 			const max = Number(ctx.evaluate(maxExpr));
 			const pct = max === 0 ? 0 : Math.max(0, Math.min(100, current / max * 100));
@@ -18737,7 +18766,7 @@ defineMacro({
 		type: "passage"
 	}],
 	render({ children = [] }, ctx) {
-		const display = ctx.args.text ?? "";
+		const display = ctx.resolve?.(ctx.args.text ?? "") ?? "";
 		let passage = null;
 		let failure;
 		if (ctx.args.passage !== void 0) try {

package/dist/pkg/story-variables.js

@@ -10566,7 +10566,7 @@ function* argPieces(args, offset, params, macro, label) {
 			};
 		}
 	}
-	yield* visit(params, values);
+	yield* [...visit(params, values)].sort((a, b) => a.offset - b.offset);
 }
 /**
 * Index of `part` in `text` from `from` on, else anywhere, else `from`: the

package/package.json

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

package/src/automation/runner.ts

@@ -8,6 +8,7 @@ import type {
 import type { StoryAPI } from '../story-api';
 import type { StoryAction } from '../action-registry';
 import { errorMessage } from '../utils/error-message';
+import { deepEqual } from '../structural';
 
 export interface RunOptions {
   onStep?: (stepIndex: number, step: AutomationStep) => void;
@@ -88,7 +89,7 @@ async function executeStep(
     if (assert.variables) {
       for (const [key, expected] of Object.entries(assert.variables)) {
         const actual = story.get(key);
-        if (actual !== expected) {
+        if (!deepEqual(actual, expected)) {
           errors.push({
             step: index,
             message: `Variable "${key}": expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`,

package/src/code-check.ts

@@ -435,7 +435,8 @@ export function* argPieces(
       }
     }
   }
-  yield* visit(params, values);
+  // Options are visited in metadata order, which is not the order written
+  yield* [...visit(params, values)].sort((a, b) => a.offset - b.offset);
 }
 
 /**

package/src/components/macros/MacroLink.tsx

@@ -16,7 +16,8 @@ defineMacro({
     { name: 'passage', type: 'passage' },
   ],
   render({ children = [] }, ctx) {
-    const display = ctx.args.text ?? '';
+    // The label is markup: resolved once, for the element and its action
+    const display = ctx.resolve?.(ctx.args.text ?? '') ?? '';
     let passage: string | null = null;
     // Boxed: anything can be thrown, including null and other falsy values
     let failure: { error: unknown } | undefined;

package/src/components/macros/Meter.tsx

@@ -44,7 +44,11 @@ defineMacro({
   ],
   render(_props, ctx) {
     try {
-      const { currentExpr, maxExpr, labelMode } = meterArgs(ctx.args);
+      const { currentExpr, maxExpr, labelMode } = meterArgs({
+        ...ctx.args,
+        // The label is markup: resolved before reading none, % or a unit
+        label: ctx.resolve?.(ctx.args.label),
+      });
       const current = Number(ctx.evaluate!(currentExpr));
       const max = Number(ctx.evaluate!(maxExpr));
       const pct =

package/src/saves/storage.ts

@@ -315,7 +315,20 @@ function createIDBBackend(): StorageBackend {
       make: (store: IDBObjectStore) => IDBRequest<R>,
     ): Promise<R> => {
       const db = await openDB();
-      return idbReq(make(db.transaction(name, mode).objectStore(name)));
+      const tx = db.transaction(name, mode);
+      const result = idbReq(make(tx.objectStore(name)));
+      // A request can succeed and its transaction still roll back, so a
+      // write is done only when the transaction completes.
+      if (mode === 'readonly') return result;
+      const committed = new Promise<void>((resolve, reject) => {
+        tx.oncomplete = () => resolve();
+        tx.onabort = () =>
+          reject(
+            tx.error ?? new DOMException('Transaction aborted', 'AbortError'),
+          );
+      });
+      const [value] = await Promise.all([result, committed]);
+      return value;
     };
 
     return {

package/src/store.ts

@@ -120,7 +120,10 @@ let lastNavigationVars: Namespace = createNamespace();
  * object) or deleted. A recorded value is a deep copy, so that changing a
  * live value in place (a class instance is not frozen) cannot change
  * history; instances of unregistered classes are kept, as the store keeps
- * them (a save then refuses them).
+ * them (a save then refuses them). The copies are made together, so what
+ * variables share (an object, a cycle) stays shared in them, and a variable
+ * left as it is that shares with a replaced one is recorded again, to share
+ * with its copy.
  */
 function computeVarPatches(
   prev: Record<string, unknown>,
@@ -132,13 +135,32 @@ function computeVarPatches(
     // whose inherited `constructor` is no variable
     if (!hasOwn(curr, key)) forward.push({ key, deleted: true });
   }
+  const seen = new Map<object, object>();
+  const record = (key: string) =>
+    forward.push({
+      key,
+      deleted: false,
+      value: deepClone(curr[key], { keepUnregistered: true, seen }),
+    });
+  const unchanged: string[] = [];
   for (const key of Object.keys(curr)) {
-    if (!hasOwn(prev, key) || !Object.is(prev[key], curr[key])) {
-      forward.push({
-        key,
-        deleted: false,
-        value: deepClone(curr[key], { keepUnregistered: true }),
-      });
+    if (!hasOwn(prev, key) || !Object.is(prev[key], curr[key])) record(key);
+    else if (typeof curr[key] === 'object' && curr[key] !== null) {
+      unchanged.push(key);
+    }
+  }
+  // Probe an unchanged variable with a copy of its own: it shares with a
+  // recorded one if the copy meets an object already copied
+  for (let found = seen.size > 0; found; ) {
+    found = false;
+    for (const key of unchanged) {
+      const probe = new Map<object, object>();
+      deepClone(curr[key], { keepUnregistered: true, seen: probe });
+      if (![...probe.keys()].some((object) => seen.has(object))) continue;
+      record(key);
+      unchanged.splice(unchanged.indexOf(key), 1);
+      found = true;
+      break;
     }
   }
   return { forward };