@rohal12/spindle 0.59.14 → 0.59.16

package/src/saves/save-manager.ts

@@ -608,6 +608,7 @@ async function fillSlot(
       slots.includes(slot) ? slots : [...slots, slot],
     );
   }
+  announceSlots(ifid);
 }
 
 /** Clear a slot: its pointer, and its entry in the slot index. */
@@ -616,6 +617,7 @@ async function emptySlot(ifid: string, slot?: string): Promise<void> {
   if (isNamedSlot(slot)) {
     await updateSlotIndex(ifid, (slots) => slots.filter((s) => s !== slot));
   }
+  announceSlots(ifid);
 }
 
 /** Clear every slot holding a save whose ID passes `test`. */
@@ -629,6 +631,65 @@ async function emptySlotsHolding(
   }
 }
 
+// --- Other tabs ---
+
+// The tabs of a story share its storage, but each keeps which slots hold a
+// save (the store's knownSaves, behind hasSave() and QuickLoad). A tab that
+// fills or empties slots tells the others, which look them up again (#404).
+
+const SLOTS_CHANNEL = 'spindle.slots';
+/** Every story's slots: what clearing all data announces. */
+const ALL_STORIES = '*';
+let slotsChannel: BroadcastChannel | null | undefined;
+
+function getSlotsChannel(): BroadcastChannel | null {
+  if (slotsChannel === undefined) {
+    try {
+      slotsChannel = new BroadcastChannel(SLOTS_CHANNEL);
+      // Node (headless runs) would not exit while it is open
+      (slotsChannel as { unref?: () => void }).unref?.();
+    } catch {
+      // No BroadcastChannel: tabs catch up when shown (see watchSlotChanges)
+      slotsChannel = null;
+    }
+  }
+  return slotsChannel;
+}
+
+/** Tell the story's other tabs that its slots changed. */
+function announceSlots(ifid: string): void {
+  try {
+    getSlotsChannel()?.postMessage(ifid);
+  } catch {
+    // A tab that cannot tell the others leaves them to catch up when shown
+  }
+}
+
+/**
+ * Call `onChange` when another tab may have filled or emptied the story's
+ * slots: when it says so, and when this tab is shown again. Returns the
+ * function that stops it.
+ */
+export function watchSlotChanges(
+  ifid: string,
+  onChange: () => void,
+): () => void {
+  const channel = getSlotsChannel();
+  const onMessage = (event: MessageEvent) => {
+    if (event.data === ifid || event.data === ALL_STORIES) onChange();
+  };
+  const onShown = () => {
+    if (document.visibilityState === 'visible') onChange();
+  };
+  const doc = typeof document === 'undefined' ? undefined : document;
+  channel?.addEventListener('message', onMessage);
+  doc?.addEventListener('visibilitychange', onShown);
+  return () => {
+    channel?.removeEventListener('message', onMessage);
+    doc?.removeEventListener('visibilitychange', onShown);
+  };
+}
+
 /** The `custom` keys that say which slot a save lives in. */
 const slotCustom = (slot: string | undefined) => ({
   isAutosave: !isNamedSlot(slot),
@@ -976,6 +1037,7 @@ export function clearGameData(ifid: string): Promise<void> {
     await backend.deletePlaythroughsByIfid(ifid);
     await backend.deleteMetaByIfid(ifid);
     clearSession(ifid);
+    announceSlots(ifid);
   });
 }
 
@@ -997,6 +1059,7 @@ async function clearAllDataNow(): Promise<void> {
   } catch {
     // no sessionStorage (or access denied): nothing to clear
   }
+  announceSlots(ALL_STORIES);
 }
 
 /**

package/src/store.ts

@@ -34,6 +34,7 @@ import {
   loadSlotSave,
   adoptPlaythrough,
   populateKnownSaves,
+  watchSlotChanges,
   getSlotSaveInfo,
   listSlotSaves,
   deleteSlotSave,
@@ -65,6 +66,7 @@ import {
   type PRNGSnapshot,
 } from './prng';
 import { errorMessage } from './utils/error-message';
+import { createListeners } from './utils/listeners';
 import {
   routeStoreUpdate,
   runWithCommittedMutations,
@@ -444,6 +446,16 @@ function startVariables(defaults: Record<string, unknown>): Namespace {
   return initialVars;
 }
 
+/**
+ * Fresh transient variables from their declared defaults (init, restart,
+ * load). Transients are never saved, so an instance of an unregistered
+ * class (an engine, a library object) is kept as it is, as mutation code
+ * keeps it (#321): a copy would lose its class and methods (#398).
+ */
+function freshTransients(defaults: Record<string, unknown>): Namespace {
+  return createNamespace(deepClone(defaults, { keepUnregistered: true }));
+}
+
 /**
  * Enter the start passage with `variables`, as the only history moment
  * (init, restart). Call it inside a store update.
@@ -457,7 +469,7 @@ function enterStart(
   state.currentPassage = passage;
   state.navigationId++;
   state.variables = variables;
-  state.transient = createNamespace(deepClone(transientDefaults));
+  state.transient = freshTransients(transientDefaults);
   state.temporary = createNamespace();
   state.history = [{ passage, timestamp: Date.now() }];
   state.historyIndex = 0;
@@ -652,9 +664,25 @@ let slotLoadApplying: number | null = null;
 
 /** A replacement of the game state applied at its call. */
 function replaceStateNow(): void {
-  latestStateApplied = ++stateReplacementsIssued;
+  applyReplacement(++stateReplacementsIssued);
 }
 
+const replacementListeners = createListeners();
+
+/** Record that replacement `n` is applied, and tell the listeners. */
+function applyReplacement(n: number): void {
+  latestStateApplied = n;
+  replacementListeners.notify();
+}
+
+/**
+ * Call `listener` whenever a boot, restart or load replaces the game state:
+ * work the replaced game started that would write into the new one later (a
+ * click body's timer in the story interface, which stays mounted) is to
+ * stop (#401).
+ */
+export const subscribeStateReplacement = replacementListeners.subscribe;
+
 // ---------------------------------------------------------------------------
 // Runtime handler cleanup (auto-unsub on restart)
 // ---------------------------------------------------------------------------
@@ -1112,6 +1140,18 @@ function recordKnownSave(
   });
 }
 
+/** Look up which slots hold a save again, as an operation queued now. */
+function refreshKnownSaves(set: StoreSet, ifid: string): Promise<void> {
+  return populateKnownSaves(ifid).then((known) => {
+    set((state) => {
+      state.knownSaves = known;
+    });
+  });
+}
+
+/** Stops following the slot changes of other tabs (see init). */
+let stopWatchingSlots: (() => void) | undefined;
+
 /**
  * Queue the clearing of saved data, then restart now: the new playthrough
  * is stored after it, and operations issued from here on belong to the new
@@ -1232,6 +1272,15 @@ export const useStoryStore = create<StoryState>()(
             return '';
           }),
       );
+      // Another tab of the story saving or deleting changes the slots too
+      // (#404). Looked up in an operation queued then, so after those issued
+      // before; operations issued later update the cache after it.
+      stopWatchingSlots?.();
+      stopWatchingSlots = watchSlotChanges(storyData.ifid, () => {
+        refreshKnownSaves(set, storyData.ifid).catch(() => {
+          // The cache keeps what it had; the next change tries again
+        });
+      });
     },
 
     navigate: (passageName: string) => {
@@ -1586,12 +1635,7 @@ export const useStoryStore = create<StoryState>()(
       }
 
       return reported(
-        deletion.then(async () => {
-          const known = await populateKnownSaves(storyData.ifid);
-          set((state) => {
-            state.knownSaves = known;
-          });
-        }),
+        deletion.then(() => refreshKnownSaves(set, storyData.ifid)),
         'spindle: failed to delete playthrough',
       );
     },
@@ -1662,7 +1706,7 @@ export const useStoryStore = create<StoryState>()(
       // Before anything is replaced: an incompatible payload leaves the
       // running game as it is
       assertPassagesExist(get().storyData, payload);
-      latestStateApplied = replacement;
+      applyReplacement(replacement);
 
       emit('beforeload', slot);
 
@@ -1719,7 +1763,7 @@ export const useStoryStore = create<StoryState>()(
         state.visitCounts = createCounts(payload.visitCounts);
         state.renderCounts = createCounts(payload.renderCounts);
         state.temporary = createNamespace();
-        state.transient = createNamespace(deepClone(get().transientDefaults));
+        state.transient = freshTransients(get().transientDefaults);
       });
 
       // The watchers of the loaded game (a payload without any, from an

package/src/story-api.ts

@@ -60,9 +60,10 @@ export type { StoryAction };
 export type { MacroMetadata };
 
 // Deferred-render promise lifecycle.
-// deferRender() creates a promise; ready() resolves it.
+// deferRender() creates a promise; ready() resolves it. A deferRender() while
+// one is pending keeps that promise: boot may already wait on it (#403).
 // index.tsx reads getReadyPromise() AFTER render(), which is after both
-// author JS and storyinit have run, so it always gets the final promise.
+// author JS and storyinit have run.
 let readyResolve: (() => void) | null = null;
 let readyPromise: Promise<void> | null = null;
 
@@ -518,7 +519,7 @@ function createStoryAPI(): StoryAPI {
 
     deferRender(): void {
       useStoryStore.getState().deferRender();
-      readyPromise = new Promise<void>((resolve) => {
+      readyPromise ??= new Promise<void>((resolve) => {
         readyResolve = resolve;
       });
     },

package/src/story-variables.ts

@@ -68,18 +68,30 @@ const PRIMITIVE_SAMPLES: Partial<Record<VarType, object>> = {
   boolean: Object(false),
 };
 
-function inferSchema(value: unknown): FieldSchema {
+/**
+ * The schema of a default value. An object met again (a backreference, a
+ * shared subtree) has the schema made for it the first time, so a cyclic
+ * default gives a schema that refers to itself instead of recursing forever.
+ */
+function inferSchema(
+  value: unknown,
+  seen = new Map<object, FieldSchema>(),
+): FieldSchema {
   if (Array.isArray(value)) {
     return { type: 'array' };
   }
   // A default of null means "nothing yet"; the value may later be anything
   if (value === null) return { type: 'null' };
   if (typeof value === 'object') {
+    const known = seen.get(value);
+    if (known) return known;
     const fields = new Map<string, FieldSchema>();
+    const schema: FieldSchema = { type: 'object', fields };
+    seen.set(value, schema);
     for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
-      fields.set(key, inferSchema(val));
+      fields.set(key, inferSchema(val, seen));
     }
-    return { type: 'object', fields };
+    return schema;
   }
   const jsType = typeof value;
   if (!VALID_VAR_TYPES.has(jsType)) {

package/src/structural.ts

@@ -12,7 +12,17 @@
 import { registeredClassName } from './class-registry';
 import { hasOwn, setOwn } from './utils/namespace';
 import { deleteByPath, getByPath, setByPath } from './utils/object-path';
-import { extraKeys, isAtomic, isBoxed, isTemporal } from './utils/value-kinds';
+import {
+  collectionSize,
+  extraKeys,
+  isAtomic,
+  isBoxed,
+  isTemporal,
+  mapEntries,
+  mapGet,
+  mapSet,
+  setMembers,
+} from './utils/value-kinds';
 
 export { isAtomic };
 
@@ -25,13 +35,13 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
 }
 
 /**
- * `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
+ * `empty`, a new built-in (an Array, Map, Set, Date or RegExp) standing for
+ * `obj`, made like it: an instance of a registered subclass keeps its class
+ * and its extra keys (#391, #393), with the values `value` gives for them;
+ * other built-ins are plain. `made` gets it before its keys are filled, so
  * that cycles through it find it.
  */
-function collectionLike<C extends object>(
+function builtinLike<C extends object>(
   obj: object,
   empty: C,
   made: (copy: C) => void,
@@ -103,11 +113,17 @@ export function deepClone<T>(value: T, options: DeepCloneOptions = {}): T {
   }
 
   function cloneBuiltin(val: object): object | undefined {
-    if (val instanceof Date) return keep(val, new Date(val.getTime()));
+    // Read with the built-in getters: a subclass may override them
+    if (val instanceof Date) {
+      return builtin(val, new Date(Date.prototype.getTime.call(val)));
+    }
     if (val instanceof RegExp) {
-      const copy = new RegExp(val.source, val.flags);
+      const copy = new RegExp(
+        Reflect.get(RegExp.prototype, 'source', val) as string,
+        Reflect.get(RegExp.prototype, 'flags', val) as string,
+      );
       copy.lastIndex = val.lastIndex; // the scanning cursor of g/y patterns
-      return keep(val, copy);
+      return builtin(val, copy);
     }
     if (val instanceof ArrayBuffer) return keep(val, val.slice(0));
     if (ArrayBuffer.isView(val)) {
@@ -151,9 +167,9 @@ export function deepClone<T>(value: T, options: DeepCloneOptions = {}): T {
       : copy;
   }
 
-  /** `empty`, made the copy of the collection `obj` (see collectionLike). */
-  const collection = <C extends object>(obj: object, empty: C): C =>
-    collectionLike(
+  /** `empty`, made the copy of the built-in `obj` (see builtinLike). */
+  const builtin = <C extends object>(obj: object, empty: C): C =>
+    builtinLike(
       obj,
       empty,
       (copy) => keep(obj, copy),
@@ -168,30 +184,33 @@ export function deepClone<T>(value: T, options: DeepCloneOptions = {}): T {
 
     if (Array.isArray(val)) {
       // Holes stay holes
-      const arr = collection(obj, new Array(val.length) as unknown[]);
+      const arr = builtin(obj, new Array(val.length) as unknown[]);
       for (let i = 0; i < val.length; i++) {
         if (i in val) arr[i] = clone(val[i]);
       }
       return arr;
     }
 
-    // Filled with the built-in methods: a subclass may override them
+    // Read and filled with the built-in methods: a subclass may override
+    // them (see mapEntries)
     if (val instanceof Map) {
-      const copy = collection(obj, new Map());
-      for (const [k, v] of val) {
+      const copy = builtin(obj, new Map());
+      for (const [k, v] of mapEntries(val)) {
         Map.prototype.set.call(copy, settled(clone(k), k), clone(v));
       }
       return copy;
     }
 
     if (val instanceof Set) {
-      const copy = collection(obj, new Set());
-      for (const v of val) Set.prototype.add.call(copy, settled(clone(v), v));
+      const copy = builtin(obj, new Set());
+      for (const v of setMembers(val)) {
+        Set.prototype.add.call(copy, settled(clone(v), v));
+      }
       return copy;
     }
 
-    const builtin = cloneBuiltin(obj);
-    if (builtin !== undefined) return builtin;
+    const copied = cloneBuiltin(obj);
+    if (copied !== undefined) return copied;
 
     // A registered class instance keeps its class, and a plain object its
     // prototype (which may be null). An instance of an unregistered class
@@ -332,13 +351,13 @@ export function shareEqual<T>(prev: unknown, curr: T): T {
     /** What the result holds at `key` of `c`. */
     const shareKey = (key: string) =>
       share(hasOwn(pr, key) ? pr[key] : undefined, cr[key]);
-    /** `empty`, made the result for the collection `c` (see collectionLike). */
+    /** `empty`, made the result for the collection `c` (see builtinLike). */
     const collection = <C extends object>(empty: C): C =>
-      collectionLike(c, empty, (out) => done.set(c, out), shareKey);
+      builtinLike(c, empty, (out) => done.set(c, out), shareKey);
     if (c instanceof Map && p instanceof Map) {
       const out = collection(new Map());
-      for (const [k, v] of c) {
-        Map.prototype.set.call(out, fresh(k), share(p.get(k), v));
+      for (const [k, v] of mapEntries(c)) {
+        Map.prototype.set.call(out, fresh(k), share(mapGet(p, k), v));
       }
       return out;
     }
@@ -381,9 +400,20 @@ function equalBuiltin(
   b: object,
   assumed: Pairs,
 ): boolean | undefined {
-  if (a instanceof Date) return Object.is(a.getTime(), (b as Date).getTime());
+  if (a instanceof Date) {
+    const time = Date.prototype.getTime;
+    return (
+      Object.is(time.call(a), time.call(b as Date)) &&
+      equalExtraKeys(a, b, assumed)
+    );
+  }
   if (a instanceof RegExp) {
-    return String(a) === String(b) && a.lastIndex === (b as RegExp).lastIndex;
+    const text = RegExp.prototype.toString;
+    return (
+      text.call(a) === text.call(b as RegExp) &&
+      a.lastIndex === (b as RegExp).lastIndex &&
+      equalExtraKeys(a, b, assumed)
+    );
   }
   if (ArrayBuffer.isView(a)) {
     // A view is its place in its backing buffer, and the whole buffer (which
@@ -435,20 +465,22 @@ function equalKeys(
   return true;
 }
 
-/** Built-in collection prototypes, whose instances hold no extra keys. */
-const COLLECTION_PROTOS: ReadonlySet<object | null> = new Set([
+/** Built-in prototypes (see builtinLike), whose instances hold no extra keys. */
+const BUILTIN_PROTOS: ReadonlySet<object | null> = new Set([
   Array.prototype,
   Map.prototype,
   Set.prototype,
+  Date.prototype,
+  RegExp.prototype,
 ]);
 
 /**
- * Equality of the extra keys (see extraKeys) of two collections of one
+ * Equality of the extra keys (see extraKeys) of two built-ins of one
  * class: those of a subclass instance are part of its value.
  */
 function equalExtraKeys(a: object, b: object, assumed: Pairs): boolean {
   return (
-    COLLECTION_PROTOS.has(Object.getPrototypeOf(a) as object | null) ||
+    BUILTIN_PROTOS.has(Object.getPrototypeOf(a) as object | null) ||
     equalKeys(a, b, assumed, extraKeys)
   );
 }
@@ -470,9 +502,9 @@ function equal(a: unknown, b: unknown, assumed: Pairs): boolean {
 
   if (a instanceof Map || a instanceof Set) {
     const bc = b as Map<unknown, unknown> | Set<unknown>;
-    if (a.size !== bc.size) return false;
-    const ai = a.entries();
-    const bi = bc.entries();
+    if (collectionSize(a) !== collectionSize(bc)) return false;
+    const ai = a instanceof Map ? mapEntries(a) : setMembers(a);
+    const bi = bc instanceof Map ? mapEntries(bc) : setMembers(bc);
     for (
       let x = ai.next(), y = bi.next();
       !x.done;
@@ -762,13 +794,15 @@ function entryChildren(value: object): [string, unknown][] | undefined {
   const children: [string, unknown][] = [];
   if (value instanceof Map) {
     let index = 0;
-    for (const [k, v] of value) {
+    for (const [k, v] of mapEntries(value)) {
       children.push([entryKey('k', index), k], [entryKey('v', index), v]);
       index++;
     }
   } else if (value instanceof Set) {
     let index = 0;
-    for (const member of value) children.push([entryKey('s', index++), member]);
+    for (const member of setMembers(value)) {
+      children.push([entryKey('s', index++), member]);
+    }
   } else if (value instanceof Error) {
     for (const key of ['cause', 'errors'] as const) {
       if (hasOwn(value, key)) {
@@ -819,8 +853,9 @@ function setEntryValue(
   const holder = getByEntryPath(root, path.slice(0, -1));
   const match = /^\0v(\d+)$/.exec(path[path.length - 1]!);
   if (!(holder instanceof Map) || !match) return false;
-  const key = [...holder.keys()][Number(match[1])];
-  holder.set(key, value);
+  const entry = [...mapEntries(holder)][Number(match[1])];
+  if (!entry) return false;
+  mapSet(holder, entry[0], value);
   return true;
 }
 
@@ -921,7 +956,8 @@ function aliasMoved(
   if (xs && ys) {
     if (Object.getPrototypeOf(x) !== Object.getPrototypeOf(y)) return false;
     if (x instanceof Map || x instanceof Set) {
-      if (x.size !== (y as Map<unknown, unknown>).size) return false;
+      const ySize = collectionSize(y as Map<unknown, unknown>);
+      if (collectionSize(x) !== ySize) return false;
     }
     const held = new Map(ys);
     for (const [segment, a] of xs) {

package/src/triggers.ts

@@ -1,6 +1,7 @@
 import { evaluate } from './expression';
 import { executeMutation, readState } from './execute-mutation';
 import { useStoryStore } from './store';
+import { createListeners } from './utils/listeners';
 
 export interface WatchOptions {
   goto?: string;
@@ -294,12 +295,32 @@ export function reinitTriggerState(): void {
   }
 }
 
+/**
+ * Forget every watcher and close every dialog on display, whoever opened it
+ * (restart): a `{dialog}` or menubar dialog of the story interface, which
+ * stays mounted, would otherwise stay open over the new game (#397).
+ */
 export function resetTriggers(): void {
   triggers = [];
-  dialogQueue = [];
-  dialogHostCallbacks?.closeAll();
+  resets++;
+  closeAllOpenDialogs();
+  resetListeners.notify();
+}
+
+let resets = 0;
+const resetListeners = createListeners();
+
+/** How many times resetTriggers has forgotten every watcher. */
+export function triggerResets(): number {
+  return resets;
 }
 
+/**
+ * Call `listener` after each resetTriggers (a restart): a {watch} that stays
+ * mounted, in the story interface, registers its watcher again (#402).
+ */
+export const subscribeTriggerResets = resetListeners.subscribe;
+
 export function subscribeTriggerDialogs(cb: () => void): () => void {
   dialogNotify = cb;
   // Flush any queued dialogs