@rohal12/spindle 0.59.12 → 0.59.14

package/dist/pkg/headless.js

@@ -9893,6 +9893,86 @@ function parseMarkup(source, options = {}) {
 function tokenizeMarkup(source, options = {}) {
 	return run$2(source, "Tokens", options);
 }
+/**
+* `tokenizeMarkup` for half-typed markup: the tokens it can read, and every
+* error, instead of throwing at the first. At a malformed tag, the tokens
+* before it are kept, its first character is read as text and tokenizing
+* resumes after it, so what follows is read as if the tag had not been
+* started. Tokens and errors have offsets in `source`; for well-formed
+* markup the tokens are those of `tokenizeMarkup` and there are no errors.
+*/
+function tokenizeMarkupTolerant(source, options = {}) {
+	const tokens = [];
+	const errors = [];
+	const lastBrace = source.lastIndexOf("}");
+	const { closeBrace } = {
+		...defaultHooks,
+		...options.hooks
+	};
+	/** `text` shifted by `base`, tokenized: the tokens or the error. */
+	const attempt = (text, base) => {
+		const hooks = {
+			...options.hooks,
+			closeBrace: (input, codeStart, lenientStart) => base + Math.min(codeStart, lenientStart) > lastBrace ? -1 : closeBrace(input, codeStart, lenientStart)
+		};
+		try {
+			return tokenizeMarkup(text, {
+				...options,
+				hooks
+			}).map((token) => shift(token, base));
+		} catch (error) {
+			if (!(error instanceof MarkupError)) throw error;
+			return error;
+		}
+	};
+	let base = 0;
+	while (base <= source.length) {
+		const rest = source.slice(base);
+		const result = attempt(rest, base);
+		if (Array.isArray(result)) {
+			tokens.push(...result);
+			break;
+		}
+		const at = base + result.offset;
+		const { line, column } = lineColumn(source, at);
+		errors.push(new MarkupError(result.reason, at, line, column));
+		let cut = result.offset;
+		let prefix = attempt(rest.slice(0, cut), base);
+		while (!Array.isArray(prefix)) {
+			cut = prefix.offset;
+			prefix = attempt(rest.slice(0, cut), base);
+		}
+		tokens.push(...prefix);
+		if (cut < rest.length) {
+			const start = base + cut;
+			tokens.push({
+				type: "text",
+				value: rest[cut],
+				start,
+				end: start + 1
+			});
+		}
+		base += cut + 1;
+	}
+	return {
+		tokens,
+		errors
+	};
+}
+/** `token` with its offsets moved `by` on. */
+function shift(token, by) {
+	if (by === 0) return token;
+	const moved = {
+		...token,
+		start: token.start + by,
+		end: token.end + by
+	};
+	if (moved.type === "link") {
+		moved.targetStart += by;
+		moved.targetEnd += by;
+	}
+	return moved;
+}
 //#endregion
 //#region src/utils/namespace.ts
 /** The variable name no namespace can hold. */
@@ -10567,28 +10647,34 @@ function parseWidgetDef(rawArgs) {
 	return widgetDef(parseMacroArgs(rawArgs, WIDGET_PARAMETERS));
 }
 /**
-* A definition: its arguments (read like a {widget} macro's, see
-* parseWidgetDef) and its body. Macro names are not case-sensitive.
-*/
-var WIDGET_DEFINITION = /\{widget\s+([^}]*)\}([\s\S]*?)\{\/widget\}/gi;
-/** `{@children}`, also with selectors such as `{.highlight @children}`. */
-var CHILDREN_PLACEHOLDER = /\{[^{}]*@children\s*\}/;
-/**
 * The names of the block widgets (those whose body renders `{@children}`)
 * that StoryInit and the passages tagged `widget` define. They must be
 * known as block macros before any passage is parsed, so that passages
 * invoking them nest their content whatever the passage order.
+*
+* The passages are read as flat tokens, which need no block macros to be
+* known, so a `{@children}` in an HTML comment or in a `{do}` body is text
+* here as it is to the parser, and does not make a block widget (#387).
 */
 function blockWidgetNames(passages) {
 	const names = [];
 	for (const passage of passages) {
 		if (passage.name !== "StoryInit" && !passage.tags?.includes("widget")) continue;
-		for (const match of passage.content.matchAll(WIDGET_DEFINITION)) {
-			if (!CHILDREN_PLACEHOLDER.test(match[2])) continue;
+		const open = [];
+		for (const token of tokenizeMarkupTolerant(passage.content).tokens) if (token.type === "macro" && token.name.toLowerCase() === "widget") {
+			if (!token.isClose) {
+				open.push({
+					rawArgs: token.rawArgs,
+					isBlock: false
+				});
+				continue;
+			}
+			const def = open.pop();
+			if (!def?.isBlock) continue;
 			try {
-				names.push(parseWidgetDef(match[1]).name);
+				names.push(parseWidgetDef(def.rawArgs).name);
 			} catch {}
-		}
+		} else if (token.type === "variable" && token.scope === "local" && token.name === "children" && open.length > 0) open[open.length - 1].isBlock = true;
 	}
 	return names;
 }
@@ -11108,6 +11194,13 @@ function wrapContent(className, id, content) {
 function hasInterpolation(s) {
 	return s.includes("{") || s.includes("}");
 }
+/** The children context for an invocation's `children`, or null if none. */
+function widgetChildrenOf(children, outer) {
+	return children?.length ? {
+		nodes: children,
+		outer: outer ?? null
+	} : null;
+}
 var parseCache = /* @__PURE__ */ new Map();
 var PARSE_CACHE_LIMIT = 2e3;
 /**
@@ -11193,7 +11286,7 @@ var TextEvaluator = class {
 				if (node.scope === "local" && node.name === "children") {
 					const children = scope.widgetChildren;
 					if (!children) return "";
-					return this.nested("children", children, scope, depth, { widgetChildren: null });
+					return this.nested("children", children.nodes, scope, depth, { widgetChildren: children.outer });
 				}
 				return this.variable(node.scope, node.name, scope);
 			case "expression": try {
@@ -11256,7 +11349,7 @@ var TextEvaluator = class {
 			}
 			return this.nested(node.name, widget.body, scope, depth, {
 				locals,
-				widgetChildren: node.children.length > 0 ? node.children : null
+				widgetChildren: widgetChildrenOf(node.children, scope.widgetChildren)
 			});
 		}
 		const text = getMacroText(node.name);
@@ -11514,7 +11607,8 @@ function WidgetInvocation(props) {
 function WidgetContent({ body, params, rawArgs, invocationChildren }) {
 	const parentValues = useRenderOptions().locals;
 	const [mergedVars, mergedTemps, mergedLocals, mergedTrans] = useMergedLocals();
-	const childrenValue = invocationChildren?.length ? invocationChildren : null;
+	const outerChildren = useContext(WidgetChildrenContext);
+	const childrenValue = useMemo(() => widgetChildrenOf(invocationChildren, outerChildren), [invocationChildren, outerChildren]);
 	const argExprs = rawArgs ? splitArgs(rawArgs) : [];
 	const values = [];
 	for (let i = 0; i < params.length; i++) {
@@ -11791,7 +11885,7 @@ var InlineContext = createContext(false);
 /**
 * True while rendering inside an element whose content is not markdown: SVG
 * (whose namespace `<p>` wrappers would break) and the preformatted `<pre>`
-* and `<textarea>`, whose text (indentation, `#`, `*`, ...) is literal.
+* `<textarea>` and `<style>`, whose text (indentation, `#`, `*`, ...) is literal.
 * Macro and widget bodies read it so their content stays literal too.
 */
 var RawTextContext = createContext(false);
@@ -11802,7 +11896,11 @@ var RawTextContext = createContext(false);
 var SvgContext = createContext(false);
 var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
 /** Elements whose content is literal text, not markdown. */
-var PREFORMATTED_ELEMENTS = new Set(["pre", "textarea"]);
+var PREFORMATTED_ELEMENTS = new Set([
+	"pre",
+	"textarea",
+	"style"
+]);
 var WidgetChildrenContext = createContext(null);
 function placeholderHtml(nonce, index) {
 	return `<span data-tw=${nonce}:${index}></span>`;
@@ -12021,6 +12119,7 @@ var INLINE_ELEMENTS = new Set([
 	"span",
 	"strong",
 	"sub",
+	"summary",
 	"sup",
 	"time",
 	"u",
@@ -12225,6 +12324,12 @@ function resolveAttributeValue(name, value, scope, errors) {
 	for (const error of result.errors) errors.push([name, error]);
 	return result.text;
 }
+/** The index of the summary element opening `nodes`, or -1 when none does. */
+function leadingSummaryIndex(nodes) {
+	const at = nodes.findIndex((n) => n.type !== "text" || n.value.trim() !== "");
+	const first = nodes[at];
+	return first?.type === "html" && first.tag.toLowerCase() === "summary" ? at : -1;
+}
 function HtmlNodeRenderer({ node }) {
 	const scope = useTextScope();
 	const { nobr, locals, raw: inRaw, inline: parentInline } = useRenderOptions();
@@ -12244,11 +12349,17 @@ function HtmlNodeRenderer({ node }) {
 	let children = void 0;
 	if (node.children.length > 0) if (inRaw || isRawRoot) children = renderInlineNodes(node.children);
 	else {
-		children = renderNodes(node.children, {
+		const summaryAt = tag === "details" ? leadingSummaryIndex(node.children) : -1;
+		const body = (nodes) => renderNodes(nodes, {
 			nobr,
 			locals,
 			inline: isInline
 		});
+		children = summaryAt === -1 ? body(node.children) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			body(node.children.slice(0, summaryAt)),
+			renderSingleNode(node.children[summaryAt]),
+			body(node.children.slice(summaryAt + 1))
+		] });
 		if (isInline !== parentInline) children = /* @__PURE__ */ jsx(InlineContext.Provider, {
 			value: isInline,
 			children
@@ -12265,10 +12376,13 @@ function HtmlNodeRenderer({ node }) {
 	}) : element);
 }
 function ChildrenSlot() {
-	const childrenAST = useContext(WidgetChildrenContext);
+	const children = useContext(WidgetChildrenContext);
 	const renderOptions = useRenderOptions();
-	if (!childrenAST || childrenAST.length === 0) return null;
-	return /* @__PURE__ */ jsx(Fragment$1, { children: renderNodes(childrenAST, renderOptions) });
+	if (!children) return null;
+	return /* @__PURE__ */ jsx(WidgetChildrenContext.Provider, {
+		value: children.outer,
+		children: renderNodes(children.nodes, renderOptions)
+	});
 }
 /**
 * Stable per-node keys. Keying rendered children by AST node identity (not
@@ -13177,6 +13291,39 @@ function stringify_primitive(thing) {
 	return String(thing);
 }
 //#endregion
+//#region src/utils/value-kinds.ts
+var toStringTag = (value) => Object.prototype.toString.call(value).slice(8, -1);
+/** Temporal values are immutable: copies may share them. */
+var isTemporal = (value) => toStringTag(value).startsWith("Temporal.");
+/** new Number(), new String(), new Boolean(), Object(1n). */
+var isBoxed = (value) => value instanceof Number || value instanceof String || value instanceof Boolean || toStringTag(value) === "BigInt";
+/**
+* Values compared and copied as a whole, by their content: they have no
+* own keys to merge by, or their keys are not the data (a property written
+* into one would be dropped by clones and saves, and by Immer for Map and
+* Set).
+*/
+function isAtomic(value) {
+	return value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set || ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof URL || value instanceof URLSearchParams || value instanceof Error || isBoxed(value) || isTemporal(value);
+}
+/** "a Map", "an Error", ... for an atomic value (see isAtomic), else undefined. */
+function atomicName(value) {
+	if (!isAtomic(value)) return void 0;
+	const tag = value instanceof Error ? "Error" : toStringTag(value);
+	return `${/^[AEIOU]/.test(tag) ? "an" : "a"} ${tag}`;
+}
+/** Whether `key` is an index of an array element. */
+var isIndexKey = (key) => key !== "4294967295" && String(Number(key) >>> 0) === key;
+/**
+* The own enumerable string keys of a collection (an Array, Map or Set) that
+* are not its elements: what an instance of a subclass may hold besides
+* them.
+*/
+function extraKeys(collection) {
+	const keys = Object.keys(collection);
+	return Array.isArray(collection) ? keys.filter((k) => !isIndexKey(k)) : keys;
+}
+//#endregion
 //#region src/class-registry.ts
 var registry = /* @__PURE__ */ new Map();
 var ctorToName = /* @__PURE__ */ new Map();
@@ -13216,6 +13363,9 @@ var ERROR_HIDDEN_KEYS$1 = [
 	"errors"
 ];
 var isObject = (v) => typeof v === "object" && v !== null;
+/** Whether `v` is a plain object (as devalue revives one). */
+var isPlainData = (v) => isObject(v) && Object.getPrototypeOf(v) === Object.prototype;
+var malformedClass = (name) => /* @__PURE__ */ new TypeError(`spindle: Malformed data for class "${name}"`);
 var defineData = (target, key, value) => {
 	Object.defineProperty(target, key, {
 		value,
@@ -13235,15 +13385,49 @@ function refuseSymbolKeys(value) {
 * Own enumerable keys of `value`, as a plain object; for an error also its
 * message, cause and (AggregateError) errors, which are not enumerable.
 */
-function ownData(value) {
+function ownData(value, keys = Object.keys(value)) {
 	refuseSymbolKeys(value);
 	const data = {};
 	if (value instanceof Error) {
 		for (const key of ERROR_HIDDEN_KEYS$1) if (hasOwn(value, key)) defineData(data, key, value[key]);
 	}
-	for (const key of Object.keys(value)) defineData(data, key, value[key]);
+	for (const key of keys) defineData(data, key, value[key]);
 	return data;
 }
+/** The kinds of collection a registered class may extend. */
+var COLLECTION_KINDS = {
+	Array,
+	Map,
+	Set
+};
+/**
+* The saved form of a registered class instance: its own data (see
+* ownData), or for a collection its kind, elements and extra keys, read
+* with the built-in methods, which a subclass may override (#391).
+*/
+function classData(value) {
+	const extra = () => ownData(value, extraKeys(value));
+	if (Array.isArray(value)) {
+		const items = new Array(value.length);
+		for (let i = 0; i < value.length; i++) if (i in value) items[i] = value[i];
+		return [
+			"Array",
+			items,
+			extra()
+		];
+	}
+	if (value instanceof Map) return [
+		"Map",
+		Array.from(Map.prototype.entries.call(value)),
+		extra()
+	];
+	if (value instanceof Set) return [
+		"Set",
+		Array.from(Set.prototype.values.call(value)),
+		extra()
+	];
+	return ownData(value);
+}
 /** Make an error's message, cause and errors non-enumerable again. */
 function hideErrorKeys(value) {
 	for (const key of ERROR_HIDDEN_KEYS$1) if (hasOwn(value, key)) Object.defineProperty(value, key, { enumerable: false });
@@ -13252,7 +13436,7 @@ function hideErrorKeys(value) {
 var isEscapedOneCharKey = (key) => key.length === 1 && JSON.stringify(key).length > 3;
 function reducers() {
 	const out = {};
-	for (const [name, ctor] of registry) out[CLASS_PREFIX + name] = (v) => isObject(v) && Object.getPrototypeOf(v) === ctor.prototype && ownData(v);
+	for (const [name, ctor] of registry) out[CLASS_PREFIX + name] = (v) => isObject(v) && Object.getPrototypeOf(v) === ctor.prototype && classData(v);
 	for (const [proto, name] of BUILTIN_ERRORS) out[ERROR_PREFIX + name] = (v) => isObject(v) && Object.getPrototypeOf(v) === proto && ownData(v);
 	out[SYMBOL_TAG] = (v) => {
 		if (typeof v !== "symbol") return false;
@@ -13265,7 +13449,7 @@ function reducers() {
 		v.lastIndex
 	];
 	out[KEYS_TAG] = (v) => {
-		if (!isObject(v) || Object.getPrototypeOf(v) !== Object.prototype) return false;
+		if (!isPlainData(v)) return false;
 		const keys = Object.keys(v);
 		if (!keys.some(isEscapedOneCharKey)) return false;
 		refuseSymbolKeys(v);
@@ -13274,27 +13458,71 @@ function reducers() {
 	};
 	return out;
 }
+/**
+* The collection of a registered class that a `[kind, contents, keys]`
+* list holds (see classData). A cycle through the collection revives it
+* before its list is complete (devalue holds unread parts as holes), so the
+* collection is kept per list and filled with what the list holds so far.
+*/
+var collections = /* @__PURE__ */ new WeakMap();
+function reviveCollection(name, ctor, list) {
+	const [kind, contents, keys] = list;
+	const base = typeof kind === "string" && hasOwn(COLLECTION_KINDS, kind) ? COLLECTION_KINDS[kind] : void 0;
+	if (list.length !== 3 || !base || !(ctor.prototype instanceof base) || hasOwn(list, 1) && !Array.isArray(contents) || hasOwn(list, 2) && !isPlainData(keys)) throw malformedClass(name);
+	let made = collections.get(list);
+	if (!made) {
+		made = Object.setPrototypeOf(new base(), ctor.prototype);
+		collections.set(list, made);
+	}
+	if (Array.isArray(contents)) fillCollection(made, contents);
+	if (isPlainData(keys)) for (const key of Object.keys(keys)) defineData(made, key, keys[key]);
+	return made;
+}
+/** Set the elements of a revived collection, with the built-in methods. */
+function fillCollection(made, contents) {
+	if (Array.isArray(made)) {
+		made.length = contents.length;
+		for (let i = 0; i < contents.length; i++) if (hasOwn(contents, i)) made[i] = contents[i];
+		else delete made[i];
+	} else if (made instanceof Map) {
+		Map.prototype.clear.call(made);
+		for (const entry of contents) {
+			if (!Array.isArray(entry) || entry.length !== 2) throw new TypeError("spindle: Malformed map entries");
+			Map.prototype.set.call(made, entry[0], entry[1]);
+		}
+	} else {
+		Set.prototype.clear.call(made);
+		for (const member of contents) Set.prototype.add.call(made, member);
+	}
+}
 /** Restore a registered class instance in place, so cycles through it hold. */
 function reviveClass(name) {
 	return (data) => {
-		if (!isObject(data) || Object.getPrototypeOf(data) !== Object.prototype) {
+		if (Array.isArray(data)) return reviveCollection(name, registeredCtor(name), data);
+		if (!isPlainData(data)) {
 			if (isObject(data) && registeredClassName(data) === name) return data;
-			throw new TypeError(`spindle: Malformed data for class "${name}"`);
+			throw malformedClass(name);
 		}
-		const ctor = registry.get(name);
-		if (!ctor) throw new TypeError(`spindle: The save holds an instance of class "${name}", which is not registered`);
+		const ctor = registeredCtor(name);
+		if (Object.values(COLLECTION_KINDS).some((c) => ctor.prototype instanceof c)) throw malformedClass(name);
 		Object.setPrototypeOf(data, ctor.prototype);
 		if (data instanceof Error) hideErrorKeys(data);
 		return data;
 	};
 }
+/** The class registered as `name`; throws if there is none. */
+function registeredCtor(name) {
+	const ctor = registry.get(name);
+	if (!ctor) throw new TypeError(`spindle: The save holds an instance of class "${name}", which is not registered`);
+	return ctor;
+}
 /** Restore a built-in error in place, like a class instance. */
 function reviveError(name) {
 	const ctor = ERROR_CTORS.get(name);
 	if (!ctor) return void 0;
 	return (data) => {
 		if (Object.getPrototypeOf(data) === ctor.prototype) return data;
-		if (!isObject(data) || Object.getPrototypeOf(data) !== Object.prototype) throw new TypeError(`spindle: Malformed data for "${name}"`);
+		if (!isPlainData(data)) throw new TypeError(`spindle: Malformed data for "${name}"`);
 		Object.setPrototypeOf(data, ctor.prototype);
 		hideErrorKeys(data);
 		return data;
@@ -13891,28 +14119,6 @@ function getBackendType() {
 	return _backend?.type ?? "memory";
 }
 //#endregion
-//#region src/utils/value-kinds.ts
-var toStringTag = (value) => Object.prototype.toString.call(value).slice(8, -1);
-/** Temporal values are immutable: copies may share them. */
-var isTemporal = (value) => toStringTag(value).startsWith("Temporal.");
-/** new Number(), new String(), new Boolean(), Object(1n). */
-var isBoxed = (value) => value instanceof Number || value instanceof String || value instanceof Boolean || toStringTag(value) === "BigInt";
-/**
-* Values compared and copied as a whole, by their content: they have no
-* own keys to merge by, or their keys are not the data (a property written
-* into one would be dropped by clones and saves, and by Immer for Map and
-* Set).
-*/
-function isAtomic(value) {
-	return value instanceof Date || value instanceof RegExp || value instanceof Map || value instanceof Set || ArrayBuffer.isView(value) || value instanceof ArrayBuffer || value instanceof URL || value instanceof URLSearchParams || value instanceof Error || isBoxed(value) || isTemporal(value);
-}
-/** "a Map", "an Error", ... for an atomic value (see isAtomic), else undefined. */
-function atomicName(value) {
-	if (!isAtomic(value)) return void 0;
-	const tag = value instanceof Error ? "Error" : toStringTag(value);
-	return `${/^[AEIOU]/.test(tag) ? "an" : "a"} ${tag}`;
-}
-//#endregion
 //#region src/utils/object-path.ts
 /**
 * Traverse dot-path segments on an object and return the nested value.
@@ -14041,6 +14247,20 @@ function isPlainObject(value) {
 	const proto = Object.getPrototypeOf(value);
 	return proto === Object.prototype || proto === null;
 }
+/**
+* `empty`, a new collection (Array, Map or Set) standing for `obj`, made
+* like it: an instance of a registered subclass keeps its class and its
+* extra keys (#391), with the values `value` gives for them; other
+* collections are plain. `made` gets it before its keys are filled, so
+* that cycles through it find it.
+*/
+function collectionLike(obj, empty, made, value) {
+	made(empty);
+	if (registeredClassName(obj) === void 0) return empty;
+	Object.setPrototypeOf(empty, Object.getPrototypeOf(obj));
+	for (const key of extraKeys(obj)) setOwn(empty, key, value(key));
+	return empty;
+}
 /** Own keys of an error that are not enumerable but are data. */
 var ERROR_HIDDEN_KEYS = [
 	"message",
@@ -14102,23 +14322,25 @@ function deepClone(value, options = {}) {
 		const settle = options.settle;
 		return settle && isObjectValue(copy) && isObjectValue(original) ? settle(copy, original) : copy;
 	}
+	/** `empty`, made the copy of the collection `obj` (see collectionLike). */
+	const collection = (obj, empty) => collectionLike(obj, empty, (copy) => keep(obj, copy), (key) => clone(obj[key]));
 	function clone(val) {
 		if (val === null || typeof val !== "object") return val;
 		const obj = val;
 		if (seen.has(obj)) return seen.get(obj);
 		if (Array.isArray(val)) {
-			const arr = keep(obj, new Array(val.length));
+			const arr = collection(obj, new Array(val.length));
 			for (let i = 0; i < val.length; i++) if (i in val) arr[i] = clone(val[i]);
 			return arr;
 		}
 		if (val instanceof Map) {
-			const copy = keep(obj, /* @__PURE__ */ new Map());
-			for (const [k, v] of val) copy.set(settled(clone(k), k), clone(v));
+			const copy = collection(obj, /* @__PURE__ */ new Map());
+			for (const [k, v] of val) Map.prototype.set.call(copy, settled(clone(k), k), clone(v));
 			return copy;
 		}
 		if (val instanceof Set) {
-			const copy = keep(obj, /* @__PURE__ */ new Set());
-			for (const v of val) copy.add(settled(clone(v), v));
+			const copy = collection(obj, /* @__PURE__ */ new Set());
+			for (const v of val) Set.prototype.add.call(copy, settled(clone(v), v));
 			return copy;
 		}
 		const builtin = cloneBuiltin(obj);
@@ -14221,23 +14443,26 @@ function shareEqual(prev, curr) {
 		if (placed !== void 0) return placed;
 		if (!isObjectValue(p)) return fresh(c);
 		if (reuse(p, c)) return p;
+		const pr = p;
+		const cr = c;
+		/** What the result holds at `key` of `c`. */
+		const shareKey = (key) => share(hasOwn(pr, key) ? pr[key] : void 0, cr[key]);
+		/** `empty`, made the result for the collection `c` (see collectionLike). */
+		const collection = (empty) => collectionLike(c, empty, (out) => done.set(c, out), shareKey);
 		if (c instanceof Map && p instanceof Map) {
-			const out = /* @__PURE__ */ new Map();
-			done.set(c, out);
-			for (const [k, v] of c) out.set(fresh(k), share(p.get(k), v));
+			const out = collection(/* @__PURE__ */ new Map());
+			for (const [k, v] of c) Map.prototype.set.call(out, 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);
+			const out = collection(new Array(c.length));
 			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, share(hasOwn(p, key) ? p[key] : void 0, cr[key]));
+			for (const key of Object.keys(cr)) setOwn(out, key, shareKey(key));
 			return out;
 		}
 		return fresh(c);
@@ -14266,14 +14491,27 @@ function equalBuiltin(a, b, assumed) {
 	if (isTemporal(a)) return String(a) === String(b);
 	if (a instanceof Error) return ERROR_HIDDEN_KEYS.every((key) => hasOwn(a, key) === hasOwn(b, key) && equal(a[key], b[key], assumed)) && equalKeys(a, b, assumed);
 }
-function equalKeys(a, b, assumed) {
+function equalKeys(a, b, assumed, keysOf = Object.keys) {
 	const ao = a;
 	const bo = b;
-	const keys = Object.keys(ao);
-	if (keys.length !== Object.keys(bo).length) return false;
+	const keys = keysOf(ao);
+	if (keys.length !== keysOf(bo).length) return false;
 	for (const key of keys) if (!hasOwn(bo, key) || !equal(ao[key], bo[key], assumed)) return false;
 	return true;
 }
+/** Built-in collection prototypes, whose instances hold no extra keys. */
+var COLLECTION_PROTOS = new Set([
+	Array.prototype,
+	Map.prototype,
+	Set.prototype
+]);
+/**
+* Equality of the extra keys (see extraKeys) of two collections of one
+* class: those of a subclass instance are part of its value.
+*/
+function equalExtraKeys(a, b, assumed) {
+	return COLLECTION_PROTOS.has(Object.getPrototypeOf(a)) || equalKeys(a, b, assumed, extraKeys);
+}
 /** `assumed` tracks the pairs of objects met (see Pairs). */
 function equal(a, b, assumed) {
 	if (Object.is(a, b) && !(assumed.strict && isObjectValue(a))) return true;
@@ -14287,7 +14525,7 @@ function equal(a, b, assumed) {
 		const ai = a.entries();
 		const bi = bc.entries();
 		for (let x = ai.next(), y = bi.next(); !x.done; x = ai.next(), y = bi.next()) if (!equal(x.value, y.value, assumed)) return false;
-		return true;
+		return equalExtraKeys(a, b, assumed);
 	}
 	const builtin = equalBuiltin(a, b, assumed);
 	if (builtin !== void 0) return builtin;
@@ -14295,7 +14533,7 @@ function equal(a, b, assumed) {
 		const bc = b;
 		if (a.length !== bc.length) return false;
 		for (let i = 0; i < a.length; i++) if (i in a !== i in bc || !equal(a[i], bc[i], assumed)) return false;
-		return true;
+		return equalExtraKeys(a, b, assumed);
 	}
 	return equalKeys(a, b, assumed);
 }
@@ -14314,7 +14552,7 @@ function isMergeable(value) {
 * 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);
+	if (arrays && (Array.isArray(a) || Array.isArray(b))) return Array.isArray(a) && Array.isArray(b) && Object.getPrototypeOf(a) === Object.getPrototypeOf(b);
 	return isMergeable(a) && isMergeable(b) && Object.getPrototypeOf(a) === Object.getPrototypeOf(b);
 }
 /**
@@ -15582,6 +15820,31 @@ var clonersFor = (paths) => {
 function frozenCopy(value) {
 	return freeze(cloneValue(value), true);
 }
+/** Whether `value` and everything it holds is frozen. */
+function deeplyFrozen(value, seen = /* @__PURE__ */ new Set()) {
+	if (typeof value !== "object" || value === null || seen.has(value)) return true;
+	if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return true;
+	if (!Object.isFrozen(value)) return false;
+	seen.add(value);
+	if (value instanceof Map) {
+		for (const [key, entry] of value) if (!deeplyFrozen(key, seen) || !deeplyFrozen(entry, seen)) return false;
+	} else if (value instanceof Set) {
+		for (const member of value) if (!deeplyFrozen(member, seen)) return false;
+	}
+	return Reflect.ownKeys(value).every((key) => {
+		const desc = Object.getOwnPropertyDescriptor(value, key);
+		return !desc || !("value" in desc) || deeplyFrozen(desc.value, seen);
+	});
+}
+/**
+* A value read from the store, made safe to hand out: the store holds plain
+* values frozen, but not registered class instances, whose methods could
+* change the recorded history through the live object. Such a value is
+* returned as a frozen copy, like a read inside mutation code.
+*/
+function readOnlyValue(value) {
+	return deeplyFrozen(value) ? value : frozenCopy(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
@@ -17265,19 +17528,39 @@ var FOCUSABLE = [
 	"select:not([disabled])",
 	"textarea:not([disabled])",
 	"iframe",
-	"[contenteditable=\"true\"]",
+	"summary",
+	"[contenteditable]",
 	"[tabindex]"
 ].join(",");
 /**
+* Whether `el` is in a closed `<details>`, other than in the summary that
+* toggles it: the browser renders none of that content (#389).
+*/
+function inClosedDetails(el) {
+	for (let e = el.parentElement; e; e = e.parentElement) {
+		if (e.localName !== "details" || e.hasAttribute("open")) continue;
+		if (!Array.from(e.children).find((c) => c.localName === "summary")?.contains(el)) return true;
+	}
+	return false;
+}
+/**
 * Whether CSS leaves `el` in the tab sequence: not `visibility: hidden`
-* (inherited, so the computed value covers ancestors) and not inside a
-* `display: none` element.
+* (inherited, so the computed value covers ancestors), not inside a
+* `display: none` element and not in the hidden content of a closed
+* `<details>`.
 */
 function isRendered(el) {
 	const { visibility } = getComputedStyle(el);
 	if (visibility === "hidden" || visibility === "collapse") return false;
 	for (let e = el; e; e = e.parentElement) if (getComputedStyle(e).display === "none") return false;
-	return true;
+	return !inClosedDetails(el);
+}
+/**
+* Whether `el` can be focused at all: shown, rendered, enabled (also by its
+* fieldset) and not inert.
+*/
+function isAvailable(el) {
+	return !el.hidden && !el.closest("[hidden], [inert]") && !el.matches(":disabled") && isRendered(el);
 }
 /** The `tabindex` of `el` as an integer, or null when absent or invalid. */
 function tabIndexAttr(el) {
@@ -17286,15 +17569,21 @@ function tabIndexAttr(el) {
 	return parseInt(raw, 10);
 }
 /**
-* Whether the tab key can reach `el`: a negative tabindex only allows
-* scripted focus, and of a radio group the browser tabs to the checked
-* member only (the first one when none is checked).
+* Whether the tab key can reach `el`, an available element (see
+* isAvailable): a negative tabindex only allows scripted focus, and of a
+* radio group the browser tabs to the checked member only (the first one
+* when none is checked), of the members it can reach.
 */
 function isTabStop(el) {
 	const tabIndex = tabIndexAttr(el);
 	if (tabIndex !== null && tabIndex < 0) return false;
+	if (el.hasAttribute("contenteditable") && !el.matches("a[href], button, input, select, textarea, iframe, summary") && (!el.isContentEditable || el.parentElement?.isContentEditable)) return false;
+	if (el.localName === "summary") {
+		const details = el.parentElement;
+		if (details?.localName !== "details" || Array.from(details.children).find((c) => c.localName === "summary") !== el) return tabIndex !== null;
+	}
 	if (el instanceof HTMLInputElement && el.type === "radio" && el.name) {
-		const group = Array.from((el.form ?? el.getRootNode()).querySelectorAll("input[type=\"radio\"]")).filter((r) => r.name === el.name && r.form === el.form && !r.disabled);
+		const group = Array.from((el.form ?? el.getRootNode()).querySelectorAll("input[type=\"radio\"]")).filter((r) => r.name === el.name && r.form === el.form && (tabIndexAttr(r) ?? 0) >= 0 && isAvailable(r));
 		return el === (group.find((r) => r.checked) ?? group[0]);
 	}
 	return true;
@@ -17304,7 +17593,7 @@ function isTabStop(el) {
 * first, ascending, then the others in document order.
 */
 function focusables(root) {
-	const stops = Array.from(root.querySelectorAll(FOCUSABLE)).filter((el) => !el.hidden && !el.closest("[hidden], [inert]") && !el.matches(":disabled") && isRendered(el) && isTabStop(el));
+	const stops = Array.from(root.querySelectorAll(FOCUSABLE)).filter((el) => isAvailable(el) && isTabStop(el));
 	const positive = (el) => Math.max(tabIndexAttr(el) ?? 0, 0);
 	return [...stops.filter((el) => positive(el) > 0).sort((a, b) => positive(a) - positive(b)), ...stops.filter((el) => positive(el) === 0)];
 }
@@ -17816,18 +18105,38 @@ var settings = {
 //#endregion
 //#region src/utils/control-edits.ts
 /**
-* Counts the edits a reader made through a control bound to a story
+* Records the edits a reader made through a control bound to a story
 * variable (`{textbox}`, `{checkbox}`, ...). {for} tells these apart from a
 * list that is replaced: typing into a control inside an iteration changes
 * its item, but must not remount the iteration and drop the control's focus.
+* An edit is attributed to the variable path it wrote, so a replacement made
+* elsewhere (a watcher reacting to the edit) still remounts.
 */
 var version = 0;
-function noteControlEdit() {
-	version++;
+var MAX_LOG = 256;
+var log = [];
+function noteControlEdit(segments) {
+	log.push({
+		version: ++version,
+		segments
+	});
+	if (log.length > MAX_LOG) log.shift();
 }
 function controlEditVersion() {
 	return version;
 }
+/**
+* Whether an edit since `since` wrote inside `item`, element `index` of
+* `list`: the path leads through the item (compared by reference in
+* `variables`), or, for a primitive item, ends at its slot in the list.
+*/
+function editedItem(since, variables, list, item, index) {
+	return log.some(({ version: v, segments }) => {
+		if (v <= since) return false;
+		if (typeof item === "object" && item !== null) return segments.some((_, n) => getByPath(variables, segments.slice(0, n + 1)) === item);
+		return segments[segments.length - 1] === String(index) && getByPath(variables, segments.slice(0, -1)) === list;
+	});
+}
 //#endregion
 //#region src/action-registry.ts
 /** The fields of a StoryAction that are left out when unset. */
@@ -18073,7 +18382,7 @@ function defineMacro(config, source = "builtin") {
 			ctx.value = useStoryStore((s) => getByPath(s.variables, segments));
 			ctx.getValue = () => getByPath(readState().variables, segments);
 			ctx.setValue = (value) => {
-				noteControlEdit();
+				noteControlEdit(segments);
 				mutateState((work, adopt) => {
 					setByPath(work.variables, segments, adopt(value), { createMissing: true });
 				});
@@ -18208,7 +18517,7 @@ function createStoryAPI() {
 			const source = scope ?? useStoryStore.getState();
 			const namespace = isTransient ? source.transient : source.variables;
 			const value = key.includes(".") ? getByPath(namespace, key.split(".")) : ownValue(namespace, key);
-			return scope ? frozenCopy(value) : value;
+			return scope ? frozenCopy(value) : readOnlyValue(value);
 		},
 		set(nameOrVars, value) {
 			const entries = typeof nameOrVars === "string" ? [[nameOrVars, value]] : Object.entries(nameOrVars);
@@ -18920,7 +19229,8 @@ var PRIMITIVE_SAMPLES = {
 };
 function inferSchema(value) {
 	if (Array.isArray(value)) return { type: "array" };
-	if (value !== null && typeof value === "object") {
+	if (value === null) return { type: "null" };
+	if (typeof value === "object") {
 		const fields = /* @__PURE__ */ new Map();
 		for (const [key, val] of Object.entries(value)) fields.set(key, inferSchema(val));
 		return {
@@ -18983,6 +19293,7 @@ function validateRef(ref, schema) {
 	for (let i = 1; i < parts.length; i++) {
 		const part = parts[i];
 		if (current.type === "array") return null;
+		if (current.type === "null") return null;
 		const sample = PRIMITIVE_SAMPLES[current.type];
 		if (sample && part in sample) {
 			const memberType = typeof sample[part];
@@ -19211,23 +19522,31 @@ function assignmentArgs(rawArgs, args) {
 /**
 * Evaluate `expr` against the current values — the store's state and the
 * enclosing locals scope's live values (`getLocals`) — and write the result
-* to the target if it differs from the previous output (always, the first
+* to the target if it differs from the previous output or the target's value (always, the first
 * time). Reading live values rather than the render's snapshot means the
 * first computation sees a local a preceding {set} just assigned (the scope's
 * context value only catches up on its re-render), and the first computation
 * and later recomputations read the same source.
 */
-function computeAndApply(expr, name, isTemp, isLocal, getLocals, rawArgs, prevRef, localsUpdate) {
+function computeAndApply(expr, name, isTemp, isLocal, getLocals, rawArgs, prevRef, lastNavigation, localsUpdate) {
 	const location = currentSourceLocation();
 	let newValue;
+	let current = prevRef.current;
+	let navigated = false;
+	const { navigationId } = useStoryStore.getState();
 	try {
 		const { variables, temporary, transient } = readState();
+		if (!isLocal) {
+			current = ownValue(isTemp ? temporary : variables, name);
+			navigated = navigationId !== lastNavigation.current;
+		}
 		newValue = evaluate(expr, variables, temporary, getLocals(), transient);
 	} catch (err) {
 		logMacroError(`computed ${rawArgs}`, err, location);
 		return;
 	}
-	if (!deepEqualStrict(prevRef.current, newValue)) {
+	lastNavigation.current = navigationId;
+	if (!deepEqualStrict(prevRef.current, newValue) || navigated && !deepEqualStrict(current, newValue)) {
 		prevRef.current = newValue;
 		if (isLocal) try {
 			localsUpdate(name, newValue);
@@ -19276,7 +19595,8 @@ defineMacro({
 		const name = target.slice(1);
 		const localsUpdate = isLocal ? ctx.update : null;
 		const prevOutput = ctx.hooks.useRef(UNSET);
-		const compute = () => computeAndApply(expr, name, isTemp, isLocal, ctx.getValues, rawArgs, prevOutput, localsUpdate);
+		const lastNavigation = ctx.hooks.useRef(-1);
+		const compute = () => computeAndApply(expr, name, isTemp, isLocal, ctx.getValues, rawArgs, prevOutput, lastNavigation, localsUpdate);
 		const ran = ctx.hooks.useRef(false);
 		if (!ran.current) {
 			ran.current = true;
@@ -19539,11 +19859,12 @@ defineMacro({
 			});
 		}
 		const { itemVar, indexVar } = loop;
-		const edited = controlEditVersion() !== keys.edits;
+		const since = keys.edits;
+		const { variables } = readState();
 		keys.edits = controlEditVersion();
 		const generations = list.map((item, i) => {
 			const contents = stableKey(item);
-			if (keys.generations[i] === void 0 || contents !== keys.contents[i] && !edited) keys.generations[i] = keys.next++;
+			if (keys.generations[i] === void 0 || contents !== keys.contents[i] && !editedItem(since, variables, list, item, i)) keys.generations[i] = keys.next++;
 			keys.contents[i] = contents;
 			return keys.generations[i];
 		});
@@ -19937,12 +20258,13 @@ defineMacro({
 		const containerRef = useRef(null);
 		const innerRef = useRef(null);
 		const [clip, setClip] = useState();
-		const [totalChars, setTotalChars] = useState(0);
+		const [measured, setMeasured] = useState(null);
+		const totalChars = measured ?? 0;
 		const [visibleChars, setVisibleChars] = useState(0);
 		const visibleCharsRef = useRef(0);
 		visibleCharsRef.current = visibleChars;
 		useEffect(() => {
-			if (containerRef.current) setTotalChars((containerRef.current.textContent || "").length);
+			if (containerRef.current) setMeasured((containerRef.current.textContent || "").length);
 		});
 		useEffect(() => {
 			if (totalChars === 0) return;
@@ -19958,7 +20280,7 @@ defineMacro({
 			}, speed);
 			return () => clearInterval(timer);
 		}, [totalChars, speed]);
-		const done = visibleChars >= totalChars && totalChars > 0;
+		const done = measured !== null && visibleChars >= totalChars;
 		useLayoutEffect(() => {
 			const root = containerRef.current;
 			const inner = innerRef.current;
@@ -19989,7 +20311,7 @@ defineMacro({
 				class: "macro-type-inner",
 				style: {
 					display: "inline",
-					visibility: totalChars === 0 ? "hidden" : "visible",
+					visibility: measured === null ? "hidden" : "visible",
 					clipPath: clip
 				},
 				children: ctx.renderInlineNodes(children)