@rohal12/spindle 0.51.3 → 0.51.4

package/dist/pkg/story-variables.js

@@ -118,8 +118,11 @@ function parseHtmlAttributes(input, j) {
 		while (j < input.length && /[a-zA-Z0-9_\-:@]/.test(input[j])) j++;
 		const attrName = input.slice(attrStart, j);
 		if (!attrName) break;
-		if (input[j] === "=") {
-			j++;
+		let eqIdx = j;
+		while (eqIdx < input.length && /\s/.test(input[eqIdx])) eqIdx++;
+		if (input[eqIdx] === "=") {
+			j = eqIdx + 1;
+			while (j < input.length && /\s/.test(input[j])) j++;
 			if (input[j] === "\"" || input[j] === "'") {
 				const quote = input[j];
 				j++;
@@ -260,16 +263,23 @@ function tokenize(input) {
 		textStart = closeEnd;
 	}
 	while (i < input.length) {
-		if (input[i] === "\\" && (input[i + 1] === "{" || input[i + 1] === "}")) {
-			flushText(i);
-			tokens.push({
-				type: "text",
-				value: input[i + 1],
-				start: i,
-				end: i + 2
-			});
-			i += 2;
-			textStart = i;
+		if (input[i] === "\\") {
+			let k = i + 1;
+			while (input[k] === "\\") k++;
+			const next = input[k];
+			if ((next === "{" || next === "}") && (k - i) % 2 === 1) {
+				flushText(k - 1);
+				tokens.push({
+					type: "text",
+					value: next,
+					start: k - 1,
+					end: k + 1
+				});
+				i = k + 1;
+				textStart = i;
+				continue;
+			}
+			i = k;
 			continue;
 		}
 		if (input[i] === "[" && input[i + 1] === "[") {

package/package.json

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

package/src/class-registry.ts

@@ -313,3 +313,79 @@ export function deserialize<T>(value: T): T {
 
   return deser(value) as T;
 }
+
+// --- Validate ---
+
+function isDataRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Whether `value` is serialized data that deserialize() can restore: every
+ * tagged value has the shape serialize() writes for its tag (a valid ISO
+ * date, a compilable RegExp, Map entries as `[key, value]` pairs, Set
+ * entries as an array, class data as an object), at any depth. Use it on
+ * data from outside the running story, such as an imported save, before
+ * storing it. Tags of unregistered classes pass; they load as plain objects.
+ */
+export function isDeserializable(value: unknown): boolean {
+  // Objects on the current path; JSON can't hold cycles, and deserialize()
+  // can't restore them
+  const path = new Set<object>();
+
+  function check(val: unknown): boolean {
+    if (val === null || typeof val !== 'object') return true;
+    if (path.has(val)) return false;
+    path.add(val);
+    const ok = checkObject(val);
+    path.delete(val);
+    return ok;
+  }
+
+  function checkObject(val: object): boolean {
+    if (Array.isArray(val)) return val.every(check);
+
+    const obj = val as Record<string, unknown>;
+    if (!(CLASS_TAG in obj && DATA_TAG in obj)) {
+      return Object.keys(obj).every((key) => check(obj[key]));
+    }
+
+    const name = obj[CLASS_TAG];
+    const data = obj[DATA_TAG];
+    if (typeof name !== 'string' || !isDataRecord(data)) return false;
+
+    switch (name) {
+      case '__Date__':
+        return (
+          typeof data.iso === 'string' &&
+          !Number.isNaN(new Date(data.iso).getTime())
+        );
+      case '__RegExp__':
+        if (typeof data.source !== 'string' || typeof data.flags !== 'string')
+          return false;
+        try {
+          new RegExp(data.source, data.flags);
+          return true;
+        } catch {
+          return false;
+        }
+      case '__Map__':
+        return (
+          Array.isArray(data.entries) &&
+          data.entries.every(
+            (entry: unknown) =>
+              Array.isArray(entry) &&
+              entry.length === 2 &&
+              check(entry[0]) &&
+              check(entry[1]),
+          )
+        );
+      case '__Set__':
+        return Array.isArray(data.entries) && data.entries.every(check);
+      default:
+        return Object.keys(data).every((key) => check(data[key]));
+    }
+  }
+
+  return check(value);
+}

package/src/components/macros/Button.tsx

@@ -1,6 +1,7 @@
 import { h, render } from 'preact';
 import { useContext } from 'preact/hooks';
 import { defineMacro } from '../../define-macro';
+import { readWholeQuoted } from './arg-utils';
 import {
   renderNodes,
   LocalsUpdateContext,
@@ -14,7 +15,9 @@ defineMacro({
   block: true,
   interpolate: true,
   render({ rawArgs, children = [] }, ctx) {
-    const label = ctx.resolve?.(rawArgs.replace(/^["']|["']$/g, '')) ?? rawArgs;
+    const text =
+      readWholeQuoted(rawArgs.trim()) ?? rawArgs.replace(/^["']|["']$/g, '');
+    const label = ctx.resolve?.(text) ?? rawArgs;
     const nobr = useContext(NobrContext);
 
     const handleClick = () => {

package/src/components/macros/Checkbox.tsx

@@ -1,8 +1,11 @@
 import { defineMacro } from '../../define-macro';
+import { readWholeQuoted, stripLooseQuotes } from './arg-utils';
 
 function parseLabel(rawArgs: string): string {
-  const match = rawArgs.match(/^\s*["']?\$?[\w.]+["']?\s+["']?(.+?)["']?\s*$/);
-  return match?.[1] ?? '';
+  const match = rawArgs.match(/^\s*["']?\$?[\w.]+["']?\s+(.+?)\s*$/);
+  if (!match) return '';
+  const rest = match[1]!;
+  return readWholeQuoted(rest) ?? stripLooseQuotes(rest);
 }
 
 defineMacro({

package/src/components/macros/Dialog.tsx

@@ -1,5 +1,6 @@
 import { defineMacro } from '../../define-macro';
 import { PassageDialog } from '../PassageDialog';
+import { readWholeQuoted } from './arg-utils';
 
 defineMacro({
   name: 'dialog',
@@ -11,7 +12,9 @@ defineMacro({
     const noclose = /\bnoclose\s*$/.test(rawArgs);
     const labelRaw = rawArgs.replace(/\bnoclose\s*$/, '').trim();
     const label =
-      ctx.resolve?.(labelRaw.replace(/^["']|["']$/g, '')) ?? labelRaw;
+      ctx.resolve?.(
+        readWholeQuoted(labelRaw) ?? labelRaw.replace(/^["']|["']$/g, ''),
+      ) ?? labelRaw;
     const passageName = ctx
       .collectText(children)
       .trim()

package/src/components/macros/For.tsx

@@ -9,10 +9,12 @@ import {
   LocalsValuesContext,
   LocalsUpdateContext,
   NobrContext,
+  InlineContext,
   renderNodes,
 } from '../../markup/render';
 import { defineMacro } from '../../define-macro';
 import { MacroError } from './MacroError';
+import { stableKey } from '../../utils/stable-key';
 import type { ASTNode } from '../../markup/ast';
 
 /**
@@ -97,11 +99,12 @@ function ForIteration({
   const updater = useMemo(() => ({ update, getValues }), [update, getValues]);
 
   const nobr = useContext(NobrContext);
+  const inline = useContext(InlineContext);
 
   return (
     <LocalsUpdateContext.Provider value={updater}>
       <LocalsValuesContext.Provider value={localState}>
-        {renderNodes(children, { nobr, locals: localState })}
+        {renderNodes(children, { nobr, inline, locals: localState })}
       </LocalsValuesContext.Provider>
     </LocalsUpdateContext.Provider>
   );
@@ -151,7 +154,7 @@ defineMacro({
 
     const content = list.map((item, i) => (
       <ForIteration
-        key={`${i}-${JSON.stringify(item)}`}
+        key={`${i}-${stableKey(item)}`}
         parentValues={parentValues}
         itemVar={itemVar}
         itemValue={item}

package/src/components/macros/Include.tsx

@@ -3,6 +3,7 @@ import { tokenize } from '../../markup/tokenizer';
 import { buildAST } from '../../markup/ast';
 import { NobrContext } from '../../markup/render';
 import { defineMacro } from '../../define-macro';
+import { isWhitespace, topLevelIndices } from './arg-utils';
 
 const FLAG = 'inline';
 
@@ -19,27 +20,16 @@ function parseIncludeArgs(rawArgs: string): {
   const trimmed = rawArgs.trim();
 
   // First and last whitespace runs at depth 0, as [start, end) offsets.
+  const spaces = topLevelIndices(trimmed, isWhitespace);
   let first: [number, number] | null = null;
   let last: [number, number] | null = null;
-  let depth = 0;
-  let inString: string | null = null;
-  for (let i = 0; i < trimmed.length; i++) {
-    const ch = trimmed[i]!;
-    if (inString) {
-      if (ch === '\\') i++;
-      else if (ch === inString) inString = null;
-      continue;
-    }
-    if (ch === '"' || ch === "'" || ch === '`') inString = ch;
-    else if (ch === '(' || ch === '[' || ch === '{') depth++;
-    else if (ch === ')' || ch === ']' || ch === '}') depth--;
-    else if (depth === 0 && /\s/.test(ch)) {
-      let end = i + 1;
-      while (end < trimmed.length && /\s/.test(trimmed[end]!)) end++;
-      last = [i, end];
-      first ??= last;
-      i = end - 1;
-    }
+  if (spaces.length > 0) {
+    let s = 0;
+    while (s + 1 < spaces.length && spaces[s + 1] === spaces[s]! + 1) s++;
+    first = [spaces[0]!, spaces[s]! + 1];
+    let e = spaces.length - 1;
+    while (e > 0 && spaces[e - 1] === spaces[e]! - 1) e--;
+    last = [spaces[e]!, spaces[spaces.length - 1]! + 1];
   }
 
   // Next to a binary operator the word is an operand (`"a" + inline`).

package/src/components/macros/MacroLink.tsx

@@ -9,6 +9,7 @@ import {
 } from '../../markup/render';
 import { defineMacro } from '../../define-macro';
 import { liveLocalsView } from '../../utils/live-locals';
+import { unescapeQuoted } from './arg-utils';
 
 function parseArgs(rawArgs: string): {
   display: string;
@@ -20,7 +21,7 @@ function parseArgs(rawArgs: string): {
   const re = /(["'])((?:\\[^]|(?!\1)[^\\])*)\1/g;
   let m;
   while ((m = re.exec(rawArgs)) !== null) {
-    parts.push(m[2]!.replace(/\\(["'\\])/g, '$1'));
+    parts.push(unescapeQuoted(m[2]!));
   }
   if (parts.length >= 2) {
     return { display: parts[0]!, passage: parts[1]! };

package/src/components/macros/Meter.tsx

@@ -1,63 +1,41 @@
 import { defineMacro } from '../../define-macro';
 import { MacroError } from './MacroError';
+import { isWhitespace, readWholeQuoted, splitTopLevel } from './arg-utils';
 
-function parseArgs(rawArgs: string): {
+/**
+ * Parse `{meter currentExpr maxExpr ["label"]}`. Arguments are separated by
+ * whitespace outside string and template literals and bracket pairs; a
+ * trailing standalone `"…"` or `'…'` string is the label mode, with `\"`,
+ * `\'` and `\\` escapes.
+ */
+export function parseMeterArgs(rawArgs: string): {
   currentExpr: string;
   maxExpr: string;
   labelMode: string;
 } {
-  const trimmed = rawArgs.trim();
+  const tokens = splitTopLevel(rawArgs.trim(), isWhitespace).filter(Boolean);
 
-  // Extract quoted label mode from the end if present
   let labelMode = '';
-  let rest = trimmed;
-  const quoteMatch = rest.match(/\s+(?:"([^"]*)"|'([^']*)')$/);
-  if (quoteMatch) {
-    labelMode = quoteMatch[1] ?? quoteMatch[2] ?? '';
-    rest = rest.slice(0, quoteMatch.index ?? rest.length).trim();
+  const label =
+    tokens.length >= 2 ? readWholeQuoted(tokens[tokens.length - 1]!) : null;
+  if (label !== null) {
+    labelMode = label;
+    tokens.pop();
   }
 
-  // Split remaining into two expressions.
-  const exprs = splitExpressions(rest);
-  if (exprs.length < 2) {
+  if (tokens.length < 2) {
     throw new Error(
       'meter requires two arguments: {meter currentExpr maxExpr}',
     );
   }
 
   return {
-    currentExpr: exprs[0]!,
-    maxExpr: exprs.slice(1).join(' '),
+    currentExpr: tokens[0]!,
+    maxExpr: tokens.slice(1).join(' '),
     labelMode,
   };
 }
 
-function splitExpressions(input: string): string[] {
-  const result: string[] = [];
-  let current = '';
-  let depth = 0;
-
-  for (let i = 0; i < input.length; i++) {
-    const ch = input[i]!;
-    if (ch === '(' || ch === '[') {
-      depth++;
-      current += ch;
-    } else if (ch === ')' || ch === ']') {
-      depth--;
-      current += ch;
-    } else if (/\s/.test(ch) && depth === 0 && current.length > 0) {
-      result.push(current);
-      current = '';
-      // Skip additional whitespace
-      while (i + 1 < input.length && /\s/.test(input[i + 1]!)) i++;
-    } else {
-      current += ch;
-    }
-  }
-  if (current.length > 0) result.push(current);
-  return result;
-}
-
 function formatLabel(
   current: number,
   max: number,
@@ -76,7 +54,7 @@ defineMacro({
   merged: true,
   render({ rawArgs }, ctx) {
     try {
-      const { currentExpr, maxExpr, labelMode } = parseArgs(rawArgs);
+      const { currentExpr, maxExpr, labelMode } = parseMeterArgs(rawArgs);
       const current = Number(ctx.evaluate!(currentExpr));
       const max = Number(ctx.evaluate!(maxExpr));
       const pct =

package/src/components/macros/Radiobutton.tsx

@@ -1,6 +1,28 @@
 import { defineMacro } from '../../define-macro';
+import {
+  isWhitespace,
+  readQuoted,
+  readWholeQuoted,
+  stripLooseQuotes,
+} from './arg-utils';
 
 function parseRadioArgs(rawArgs: string): { value: string; label: string } {
+  // $var "value" label: a quoted value accepts \" \' and \\ escapes and
+  // may contain the other quote kind.
+  const head = rawArgs.match(/^\s*["']?\$?[\w.]+["']?\s+/);
+  if (head) {
+    const rest = rawArgs.slice(head[0].length).trim();
+    const value = readQuoted(rest, 0);
+    if (
+      value &&
+      (value.end === rest.length || isWhitespace(rest[value.end]!))
+    ) {
+      const labelRaw = rest.slice(value.end).trim();
+      const label = readWholeQuoted(labelRaw) ?? stripLooseQuotes(labelRaw);
+      return { value: value.value, label };
+    }
+  }
+
   const match = rawArgs.match(
     /^\s*["']?\$?[\w.]+["']?\s+["'](.+?)["']\s+["']?(.+?)["']?\s*$/,
   );

package/src/components/macros/SaveManager.tsx

@@ -5,7 +5,7 @@ import {
   useRef,
   useContext,
 } from 'preact/hooks';
-import { useStoryStore } from '../../store';
+import { useStoryStore, resolvePlaythroughId } from '../../store';
 import { isSaveExport, type SaveRecord } from '../../saves/types';
 import {
   getSavesGrouped,
@@ -106,11 +106,16 @@ export function SaveManagerContent() {
 
   // Dialog saves are not slot saves, so the save hooks get no slot.
   const handleNewSave = async () => {
-    if (!ifid || !playthroughId) return;
+    if (!ifid) return;
+    // The playthrough current at the click, which a restart may have
+    // switched since this render
+    const playthrough = resolvePlaythroughId();
     try {
-      await saveWithHooks(undefined, undefined, beginSave, (payload) =>
-        createSave(ifid, playthroughId, payload),
-      );
+      await saveWithHooks(undefined, undefined, beginSave, async (payload) => {
+        const ptId = await playthrough;
+        if (!ptId) throw new Error('No playthrough');
+        return createSave(ifid, ptId, payload);
+      });
       showStatus('Save created');
       await refresh();
     } catch {
@@ -119,9 +124,12 @@ export function SaveManagerContent() {
   };
 
   const handleOverwrite = async (saveId: string) => {
+    const playthrough = resolvePlaythroughId();
     try {
       await saveWithHooks(undefined, undefined, beginSave, async (payload) => {
-        if (!(await overwriteSave(saveId, payload))) {
+        // Only the current playthrough's saves offer "Save Here"
+        const ptId = (await playthrough) || undefined;
+        if (!(await overwriteSave(saveId, payload, undefined, ptId))) {
           throw new Error('Save not found');
         }
       });

package/src/components/macros/Watch.tsx

@@ -1,51 +1,100 @@
 import { defineMacro } from '../../define-macro';
 import { addMacroTrigger, removeTrigger } from '../../triggers';
 import type { WatchOptions } from '../../triggers';
+import { isWhitespace, readQuoted, readWholeQuoted } from './arg-utils';
 
-defineMacro({
-  name: 'watch',
-  render(props, ctx) {
-    const { hooks } = ctx;
+const WORD_RE = /\w+/y;
+const DIGITS_RE = /\d+/y;
 
-    // Parse: condition string + keyword options
-    const raw = props.rawArgs.trim();
-    // First quoted string is the condition
-    const condMatch = raw.match(/^(['"])(.*?)\1\s*/);
-    if (!condMatch) return null;
+/** Match the sticky regex `re` at `pos`, returning the matched text. */
+function matchAt(re: RegExp, src: string, pos: number): string | null {
+  re.lastIndex = pos;
+  return re.exec(src)?.[0] ?? null;
+}
 
-    const condition = condMatch[2]!;
-    const rest = raw.slice(condMatch[0].length);
+/**
+ * Parse `{watch "condition" keyword value …}`: a quoted condition followed
+ * by keyword options (`goto "X"`, `dialog "X"`, `run "X"`, `name "X"`,
+ * `priority N`, `once`). Quoted strings accept `\"`, `\'` and `\\` escapes.
+ * Returns `null` when the arguments do not start with a quoted condition.
+ */
+export function parseWatchArgs(
+  rawArgs: string,
+): { condition: string; options: WatchOptions } | null {
+  const raw = rawArgs.trim();
+  const cond = readQuoted(raw, 0);
+  if (!cond) return null;
 
-    const options: WatchOptions = {};
-    // Parse keyword args: goto "X", dialog "X", run "X", once, name "X", priority N
-    const kwRe = /(\w+)\s+(?:"([^"]*?)"|'([^']*?)'|(\d+))|(\w+)/g;
-    let m: RegExpExecArray | null;
-    while ((m = kwRe.exec(rest)) !== null) {
-      const key = m[1] ?? m[5];
-      const val = m[2] ?? m[3] ?? m[4];
-      if (!key) continue;
-      switch (key) {
-        case 'goto':
-          options.goto = val;
-          break;
-        case 'dialog':
-          options.dialog = val;
-          break;
-        case 'run':
-          options.run = val;
-          break;
-        case 'name':
-          options.name = val;
-          break;
-        case 'priority':
-          options.priority = val ? Number(val) : 0;
-          break;
-        case 'once':
-          options.once = true;
-          break;
+  const options: WatchOptions = {};
+  let i = cond.end;
+  while (i < raw.length) {
+    const key = matchAt(WORD_RE, raw, i);
+    if (!key) {
+      // Skip whitespace and stray characters, or a stray quoted string.
+      i = readQuoted(raw, i)?.end ?? i + 1;
+      continue;
+    }
+    i += key.length;
+
+    // A value is a quoted string or a digit run, after whitespace.
+    let val: string | undefined;
+    let j = i;
+    while (j < raw.length && isWhitespace(raw[j]!)) j++;
+    if (j > i) {
+      const quoted = readQuoted(raw, j);
+      const digits = quoted ? null : matchAt(DIGITS_RE, raw, j);
+      if (quoted) {
+        val = quoted.value;
+        i = quoted.end;
+      } else if (digits) {
+        val = digits;
+        i = j + digits.length;
       }
     }
 
+    switch (key) {
+      case 'goto':
+        options.goto = val;
+        break;
+      case 'dialog':
+        options.dialog = val;
+        break;
+      case 'run':
+        options.run = val;
+        break;
+      case 'name':
+        options.name = val;
+        break;
+      case 'priority':
+        options.priority = val ? Number(val) : 0;
+        break;
+      case 'once':
+        options.once = true;
+        break;
+    }
+  }
+
+  return { condition: cond.value, options };
+}
+
+/**
+ * Parse the watcher name of `{unwatch "name"}`: a quoted string, with the
+ * same escapes as `{watch}`, or a bare name.
+ */
+export function parseUnwatchName(rawArgs: string): string {
+  const raw = rawArgs.trim();
+  return readWholeQuoted(raw) ?? raw.replace(/^['"]|['"]$/g, '');
+}
+
+defineMacro({
+  name: 'watch',
+  render(props, ctx) {
+    const { hooks } = ctx;
+
+    const parsed = parseWatchArgs(props.rawArgs);
+    if (!parsed) return null;
+    const { condition, options } = parsed;
+
     // Register during render (like {set}) — triggers survive navigation
     // and are cleaned up via resetTriggers() on restart or {unwatch}.
     // Remounts (revisits, re-rendered branches) keep the registered watcher.
@@ -62,8 +111,7 @@ defineMacro({
 defineMacro({
   name: 'unwatch',
   render(props, ctx) {
-    const raw = props.rawArgs.trim();
-    const name = raw.replace(/^['"]|['"]$/g, '');
+    const name = parseUnwatchName(props.rawArgs);
 
     const ran = ctx.hooks.useRef(false);
     if (!ran.current) {