@zaisma/game-server 1.8.0 → 1.9.0

package/bench/glass.js

@@ -8146,6 +8146,7 @@ var GAME_SERVER_OPTIONS = [
   "onRefund",
   "onTick",
   "onEnding",
+  "onEndingCancelled",
   "onRestored",
   "stateView",
   "onVersionUpdate",
@@ -23873,24 +23874,63 @@ var SAVES_SCRIPT = pageScript("saves", `
   let applying = null;    // a developer's change while the game domain puts it in place under the running game
   let isRestoringCopy = false; // the game is going back to an earlier version (Zaisma.saves.restoreCopy)
   let versionId = null;   // the game version the game domain says it was served from (its last hello or save), a label on each save
+  let clockOffsetMs = 0;  // Zaisma's clock minus this device's, from the last answer's Date header
+  let retryTimer = null;  // a failed save waiting to be sent again
+  let retryDelayMs = 0;   // how long the last wait was: 30 seconds, doubling to 5 minutes
+  let isAwaitingSignIn = false; // saving paused after a 401 or another account signing in, until the player is signed in
   // A save with nothing in it, exactly as canonicalSave in packages/core/src/saves.ts writes it.
   const EMPTY_SAVE_TEXT = ${JSON.stringify(EMPTY_SAVE_TEXT)};
 
   // A save as one text, the same as canonicalSave on the server: all three keys in this order, localStorage keys sorted.
   const canonical = (save) => {
+    if (!save || !save.local_storage_items) return null;
     const items = {};
     Object.keys(save.local_storage_items).sort().forEach((k) => Object.defineProperty(items, k, { value: save.local_storage_items[k], enumerable: true, writable: true, configurable: true }));
     return JSON.stringify({ save_format_version_number: 1, local_storage_items: items, indexeddb_databases: save.indexeddb_databases });
   };
   const sha = async (text) => Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text))), (b) => b.toString(16).padStart(2, "0")).join("");
+  // Which save of an account this device last had: { version_number, sha256, slug, marked_at_ms }, per account tag.
   const marker = (tag, value) => {
     try {
       if (value === undefined) return JSON.parse(localStorage.getItem("zaisma:save:" + tag) || "null");
-      localStorage.setItem("zaisma:save:" + tag, JSON.stringify(value));
+      localStorage.setItem("zaisma:save:" + tag, JSON.stringify({ ...value, slug: SAVES.slug, marked_at_ms: serverNow() }));
     } catch { return null; }
   };
+  // Every account's marker for this game in this browser, with its tag (markers from before slug was kept are left out).
+  const markersHere = () => {
+    const found = [];
+    try {
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (!key || !key.startsWith("zaisma:save:")) continue;
+        const value = JSON.parse(localStorage.getItem(key) || "null");
+        if (value && value.slug === SAVES.slug) found.push({ tag: key.slice("zaisma:save:".length), ...value });
+      }
+    } catch {}
+    return found;
+  };
+  // Another account's progress, moved aside on a shared computer until that account signs in here again: { text, played_at_ms }.
+  const asideKey = (tag) => "zaisma:unsynced:" + tag;
+  const putAside = (tag, value) => {
+    try { localStorage.setItem(asideKey(tag), JSON.stringify(value)); return true; } catch { return false; }
+  };
+  const takeAside = (tag) => {
+    try {
+      const value = JSON.parse(localStorage.getItem(asideKey(tag)) || "null");
+      localStorage.removeItem(asideKey(tag));
+      return value && typeof value.text === "string" ? value : null;
+    } catch { return null; }
+  };
+  // Zaisma's clock: this device's, put right by the offset each answer's Date header shows.
+  const serverNow = () => Date.now() + clockOffsetMs;
+  // Every call to the account: learns Zaisma's clock from the answer.
+  const ask = (path, init = {}) => fetch(path, { credentials: "same-origin", ...init }).then((res) => {
+    const answeredAtMs = Date.parse((res.headers && res.headers.get && res.headers.get("date")) || "");
+    if (answeredAtMs) clockOffsetMs = answeredAtMs - Date.now();
+    return res;
+  });
   const ago = (savedAt) => {
-    const m = Math.round((Date.now() - Date.parse(savedAt)) / 60000);
+    const m = Math.round((serverNow() - Date.parse(savedAt)) / 60000);
     return m < 1 ? "just now" : m < 60 ? m + " min ago" : m < 1440 ? Math.round(m / 60) + " h ago" : Math.round(m / 1440) + " days ago";
   };
   // Where progress goes, in the Keep your progress card.
@@ -23909,11 +23949,10 @@ var SAVES_SCRIPT = pageScript("saves", `
   }
   // The account's progress wins: keep this device's as an earlier version on the account, dated when this device
   // last played it (played_at; null when that isn't known). Answers the copy's ID, or null.
-  const keepDevice = (text) => {
-    if (!text || text === EMPTY_SAVE_TEXT) return Promise.resolve(null);
-    const p = played();
-    const body = { keep: true, save_json: text, version_id: versionId, played_at: p && p.played_at_ms ? new Date(p.played_at_ms).toISOString() : null };
-    return fetch(SAVES.api, { method: "PUT", body: JSON.stringify(body), credentials: "same-origin" })
+  const keepDevice = (text, playedAtMs = (played() || {}).played_at_ms) => {
+    if (!text || text === EMPTY_SAVE_TEXT || !cloud || cloud instanceof Promise) return Promise.resolve(null);
+    const body = { tag: cloud.tag, keep: true, save_json: text, version_id: versionId, played_at: playedAtMs ? new Date(playedAtMs).toISOString() : null };
+    return ask(SAVES.api, { method: "PUT", body: JSON.stringify(body) })
       .then((r) => (r.ok ? r.json() : null))
       .then((out) => (out && out.save_copy_id) || null)
       .catch(() => null);
@@ -23925,25 +23964,22 @@ var SAVES_SCRIPT = pageScript("saves", `
       localStorage.setItem(playedKey, JSON.stringify(value));
     } catch { return null; }
   };
-  // The game sent its save: if it changed, this device played just now.
+  // The game sent its save: if it changed, this device played just now (on Zaisma's clock).
   async function notePlayed(text) {
     const hash = await sha(text);
     const was = played();
     if (!was) played({ sha256: hash, played_at_ms: null });
-    else if (was.sha256 !== hash) played({ sha256: hash, played_at_ms: Date.now() });
+    else if (was.sha256 !== hash) played({ sha256: hash, played_at_ms: serverNow() });
   }
   // Whether this device's progress was played after the account's was saved. Not known: the account's wins.
-  const deviceIsNewer = (savedAt) => {
-    const p = played();
-    return Boolean(p && p.played_at_ms && savedAt && p.played_at_ms > Date.parse(savedAt));
-  };
+  const deviceIsNewer = (savedAt, playedAtMs = (played() || {}).played_at_ms) => Boolean(playedAtMs && savedAt && playedAtMs > Date.parse(savedAt));
   const tell = (msg) => frame && frame.contentWindow && frame.contentWindow.postMessage({ type: "zaisma:saves", ...msg }, SAVES.frameOrigin);
   // To the game itself (the SDK), not the game domain's saves script.
   const toGame = (msg) => frame && frame.contentWindow && frame.contentWindow.postMessage(msg, SAVES.frameOrigin);
   const copyFields = (copy) => ({ id: copy.id, savedAt: copy.saved_at, copyReason: copy.copy_reason, sizeBytes: copy.size_bytes, isCurrentSave: copy.is_current_save, versionId: copy.version_id ?? null });
   async function copyById(saveCopyId) {
     if (!saveCopyId) return null;
-    const res = await fetch(SAVES.api + "/copies", { credentials: "same-origin" }).catch(() => null);
+    const res = await ask(SAVES.api + "/copies").catch(() => null);
     const out = res && res.ok ? await res.json().catch(() => null) : null;
     const copy = out && Array.isArray(out.save_copies) ? out.save_copies.find((each) => each.id === saveCopyId) : null;
     return copy ? copyFields(copy) : null;
@@ -23964,7 +24000,7 @@ var SAVES_SCRIPT = pageScript("saves", `
   // One retry for a passing hiccup; a signed-out player or a game without saves just plays.
   async function load(retry = true) {
     try {
-      const res = await fetch(SAVES.api, { credentials: "same-origin" });
+      const res = await ask(SAVES.api);
       if (res.ok) return await res.json();
       if (res.status === 401 || res.status === 404 || !retry) return null;
     } catch { if (!retry) return null; }
@@ -23984,6 +24020,9 @@ var SAVES_SCRIPT = pageScript("saves", `
     pendingConflict = null; // A conflict from this reload comes after it (conflicted).
     if (applying) { clearTimeout(applying.timer); applying = null; }
     queued = null; // From the game as it was; the reloaded game sends its own.
+    clearTimeout(retryTimer);
+    retryTimer = null;
+    retryDelayMs = 0;
     cloud = load();
     openAt("_zaisma/restore#" + encodeURIComponent(SAVES.query));
     clearTimeout(fallback);
@@ -24094,8 +24133,8 @@ var SAVES_SCRIPT = pageScript("saves", `
     const c = await load();
     if (!c) return say("Couldn't reach your saved progress, so this visit won't save to your account.");
     cloud = c;
-    if (!c.version_number) {
-      // A new account: whatever this device has becomes the account's save.
+    if (!c.version_number || !c.save_data) {
+      // A new account (or one whose save has no data): whatever this device has becomes the account's save.
       paused = false;
       synced = null;
       welcome = true;
@@ -24108,6 +24147,10 @@ var SAVES_SCRIPT = pageScript("saves", `
       tell({ step: "sync", text: guestText });
       say("Progress saves to your account.");
       pop("Your progress now saves to your account.");
+    } else if (!guestText || guestText === EMPTY_SAVE_TEXT) {
+      // Nothing on this device: the game reopens with the account's progress.
+      forceCloud = true;
+      openThroughRestore();
     } else if (deviceIsNewer(c.saved_at)) {
       // Both have progress, and this device's was played more recently: it replaces the account's, which is kept
       // as an earlier version (the game hears the conflict once that save is stored).
@@ -24126,9 +24169,37 @@ var SAVES_SCRIPT = pageScript("saves", `
       pop("You're signed in. Your account's progress in this game is newer, so the game reloaded with it.");
     }
   }
-  addEventListener("focus", joined);
-  document.addEventListener("visibilitychange", joined);
-  try { new BroadcastChannel("zaisma").onmessage = (e) => e.data === "signed-in" && joined(); } catch {}
+  // Saving paused after a 401 or another account signing in: once the account answers again, the game reopens
+  // through the restore page as whoever is signed in now, which checks whose progress is on this device.
+  async function signedInAgain() {
+    if (!isAwaitingSignIn || guest || !signedIn()) return;
+    const res = await ask(SAVES.api + "?version").catch(() => null);
+    if (!isAwaitingSignIn || !res || !res.ok) return;
+    isAwaitingSignIn = false;
+    openThroughRestore();
+  }
+  function awaitSignIn(isOtherAccount) {
+    paused = true;
+    queued = null;
+    tell({ step: "pause" });
+    isAwaitingSignIn = true;
+    if (isOtherAccount) signedInAgain();
+    else say("Sign in again to keep saving to your account.");
+  }
+  const heardSignIn = () => { joined(); signedInAgain(); };
+  addEventListener("focus", heardSignIn);
+  document.addEventListener("visibilitychange", heardSignIn);
+  try { new BroadcastChannel("zaisma").onmessage = (e) => e.data === "signed-in" && heardSignIn(); } catch {}
+
+  // Whose this device's progress is, when it isn't this account's (tag): another account's synced save (isSynced),
+  // or progress never synced, which belongs to the account that played here last. Null: this account's, or no one's.
+  function progressOwner(localHash, tag) {
+    const markers = markersHere();
+    const synced = markers.find((each) => each.tag !== tag && each.sha256 === localHash);
+    if (synced) return { tag: synced.tag, isSynced: true };
+    const last = markers.reduce((newest, each) => (!newest || (each.marked_at_ms || 0) > (newest.marked_at_ms || 0) ? each : newest), null);
+    return last && last.tag !== tag ? { tag: last.tag, isSynced: false } : null;
+  }
 
   async function restore(text, broken) {
     clearTimeout(fallback);
@@ -24143,63 +24214,98 @@ var SAVES_SCRIPT = pageScript("saves", `
       say("Couldn't reach your saved progress, so this visit won't save to your account.");
       return tell({ step: "restore", action: "keep" });
     }
-    const localHash = await sha(text);
-    const empty = text === EMPTY_SAVE_TEXT;
+    // An answer without its data counts as no save on the account; the next save still starts from its version.
+    const hasCloudSave = Boolean(c.version_number && c.save_data);
+    let localHash = await sha(text);
     // The first time this page sees this device's save: from now on a change to it counts as playing.
     if (!played()) played({ sha256: localHash, played_at_ms: null });
     // A marker from before version_number and sha256 matches neither, so the most recently played wins.
     const mark = marker(c.tag);
+    // A shared computer: progress here that's another account's stays that account's, and this account starts from its own.
+    let deviceText = text;
+    let isStorageOthers = false;
+    if (text !== EMPTY_SAVE_TEXT && localHash !== c.sha256 && !(mark && mark.sha256 === localHash)) {
+      const owner = progressOwner(localHash, c.tag);
+      if (owner) {
+        if (!owner.isSynced && !putAside(owner.tag, { text, played_at_ms: (played() || {}).played_at_ms || null })) {
+          say("Another account's progress is on this device, so this visit won't save to your account.");
+          return tell({ step: "restore", action: "keep" });
+        }
+        isStorageOthers = true;
+        deviceText = EMPTY_SAVE_TEXT;
+      }
+    }
+    // This account's own progress, moved aside while another account played here: it's this device's progress again.
+    const aside = takeAside(c.tag);
+    let devicePlayedAtMs = (played() || {}).played_at_ms;
+    if (aside) {
+      deviceText = aside.text;
+      devicePlayedAtMs = aside.played_at_ms;
+      localHash = await sha(aside.text);
+    }
+    const empty = deviceText === EMPTY_SAVE_TEXT;
     let use;
-    if (forceCloud && c.version_number) {
+    if (forceCloud && hasCloudSave) {
       use = "cloud";
       // This device's progress since its last save (the account keeps one copy of each progress).
       // Unchanged since it last synced, it was the account's own save, so there's nothing to keep; nor when it was kept before the reload.
-      if (!empty && localHash !== c.sha256 && !(mark && mark.sha256 === localHash) && text !== keptBeforeReload) keepDevice(text);
+      if (!empty && localHash !== c.sha256 && !(mark && mark.sha256 === localHash) && deviceText !== keptBeforeReload) keepDevice(deviceText, devicePlayedAtMs);
     }
-    else if (!c.version_number) use = "local";
+    else if (!hasCloudSave) use = "local";
     else if (empty || localHash === c.sha256) use = "cloud";
     else if (mark && mark.version_number === c.version_number) use = "local";
     else if (mark && mark.sha256 === localHash) use = "cloud";
     else {
       // Both played on since they last matched: the progress played most recently wins, the other is kept.
-      use = deviceIsNewer(c.saved_at) ? "local" : "cloud";
-      if (use === "cloud") conflicted("account", keepDevice(text));
+      use = deviceIsNewer(c.saved_at, devicePlayedAtMs) ? "local" : "cloud";
+      if (use === "cloud") conflicted("account", keepDevice(deviceText, devicePlayedAtMs));
       else replacing = true; // The game hears the conflict once its save replaced the account's (store).
     }
     forceCloud = false;
     keptBeforeReload = null;
-    if (use === "cloud" && c.version_number) {
-      restoring = c;
-      tell({ step: "restore", action: "use-cloud", data: c.save_data });
+    // What goes in the game's storage: the account's save, this account's moved-aside progress, or nothing in place of another's.
+    const putting = use === "cloud" && hasCloudSave ? { saveData: c.save_data } : aside && !empty ? { saveData: JSON.parse(deviceText), isDeviceProgress: true, aside } : isStorageOthers ? { saveData: JSON.parse(EMPTY_SAVE_TEXT) } : null;
+    if (putting) {
+      restoring = { c, ...putting };
+      tell({ step: "restore", action: "use-cloud", data: putting.saveData });
     } else {
       paused = false;
       // Keep this device's save; the game sends it as soon as it starts.
-      synced = empty && !c.version_number ? text : null;
+      synced = empty && !hasCloudSave ? text : null;
       tell({ step: "restore", action: "keep" });
       say("Progress saves to your account.");
     }
   }
 
-  // The game domain put the account's save in place (or couldn't). Only then does saving start.
+  // The game domain put a save in place (or couldn't). Only then does saving start.
   function restored(ok) {
-    const c = restoring;
+    const r = restoring;
     restoring = null;
+    if (!r) return;
     if (!ok) {
+      if (r.aside) putAside(r.c.tag, r.aside);
       say("Couldn't put your account's progress on this device, so this visit won't save to your account.");
       return;
     }
-    synced = canonical(c.save_data);
-    marker(c.tag, { version_number: c.version_number, sha256: c.sha256 });
-    played({ sha256: c.sha256, played_at_ms: Date.parse(c.saved_at) || null });
+    const c = r.c;
+    const isAccountSave = r.saveData === c.save_data;
+    // This account's own moved-aside progress back in place: the game sends it, and it saves from the account's version.
+    synced = r.isDeviceProgress ? null : canonical(r.saveData);
     paused = false;
-    say("Progress saves to your account. Last saved " + ago(c.saved_at) + ".");
+    if (isAccountSave) {
+      marker(c.tag, { version_number: c.version_number, sha256: c.sha256 });
+      played({ sha256: c.sha256, played_at_ms: Date.parse(c.saved_at) || null });
+    } else {
+      sha(canonical(r.saveData)).then((hash) => played({ sha256: hash, played_at_ms: r.isDeviceProgress ? r.aside.played_at_ms || null : null }));
+    }
+    say(isAccountSave ? "Progress saves to your account. Last saved " + ago(c.saved_at) + "." : "Progress saves to your account.");
   }
 
   async function store(text) {
     if (paused) return;
-    if (saving) { queued = text; return; }
-    const body = JSON.stringify({ base_version_number: cloud.version_number, save_json: text, version_id: versionId, ...(replacing ? { replace: true } : {}) });
-    saving = fetch(SAVES.api, { method: "PUT", body, credentials: "same-origin", keepalive: body.length < 60000 }).catch(() => null);
+    if (saving || retryTimer) { queued = text; return; }
+    const body = JSON.stringify({ tag: cloud.tag, base_version_number: cloud.version_number, save_json: text, version_id: versionId, ...(replacing ? { replace: true } : {}) });
+    saving = ask(SAVES.api, { method: "PUT", body, keepalive: body.length < 60000 }).catch(() => null);
     const opened = openCount;
     const res = await saving;
     saving = null;
@@ -24208,9 +24314,13 @@ var SAVES_SCRIPT = pageScript("saves", `
     // Going back to an earlier version: a save that went through still moved the account on; anything else waits for that.
     if (isRestoringCopy && !(res && res.ok)) return;
     const out = res ? await res.json().catch(() => ({})) : {};
-    if (res && res.ok) {
-      if (replacing) conflicted("this_device", Promise.resolve(out.kept_save_copy_id));
+    // A 409 for exactly this save: it landed before (its answer was lost), so it's saved.
+    const isSavedBefore = res && res.status === 409 && out.error !== "account_changed" && out.sha256 && out.sha256 === (await sha(text));
+    if (opened !== openCount) return;
+    if (res && (res.ok || isSavedBefore)) {
+      if (replacing && res.ok) conflicted("this_device", Promise.resolve(out.kept_save_copy_id));
       replacing = false;
+      retryDelayMs = 0;
       cloud.version_number = out.version_number;
       cloud.sha256 = out.sha256;
       synced = text;
@@ -24218,17 +24328,23 @@ var SAVES_SCRIPT = pageScript("saves", `
       say("Progress saves to your account. Last saved just now.");
       if (welcome) pop("Your progress now saves to your account.");
       welcome = false;
+    } else if (res && res.status === 409 && out.error === "account_changed") {
+      // Another account signed in on this browser: this page's progress never goes to it.
+      return awaitSignIn(true);
     } else if (res && res.status === 409) {
       paused = true;
       tell({ step: "pause" });
+      // The newest progress this device has; a save waiting behind this one is from before whatever happens next.
+      const newest = queued ?? text;
+      queued = null;
       // The developer's change always wins, and so does another device's progress played after this device's:
       // reload the game with it, keeping this device's progress. Otherwise this device's, played just now, replaces it.
       // A developer's change is never a conflict, and a game that listens for it takes it in place.
       if (out.changed_by_kind === "developer" && listening.has("developerChange")) {
-        takeDeveloperChange(text);
+        takeDeveloperChange(newest);
       } else if (out.changed_by_kind === "developer" || !deviceIsNewer(out.saved_at)) {
-        const keeping = keepDevice(text);
-        keptBeforeReload = text;
+        const keeping = keepDevice(newest);
+        keptBeforeReload = newest;
         forceCloud = true;
         openThroughRestore();
         if (out.changed_by_kind !== "developer") conflicted("account", keeping);
@@ -24243,14 +24359,27 @@ var SAVES_SCRIPT = pageScript("saves", `
       overLimit();
       return;
     } else if (res && res.status === 401) {
+      return awaitSignIn(false);
+    } else if (res && res.status === 404) {
+      // The game stopped saving to accounts (or isn't live): nothing more goes for this visit.
       paused = true;
+      queued = null;
       tell({ step: "pause" });
-      say("Sign in again to keep saving to your account.");
+      say("This game doesn't save to your account right now, so its progress stays on this device.");
       return;
     } else {
-      // Let the game send this save again on its next check.
+      // Offline, too often or Zaisma had a problem: send the newest save again later, waiting longer each time.
+      queued = queued ?? text;
+      retryDelayMs = Math.min(retryDelayMs ? retryDelayMs * 2 : 30000, 300000);
+      const retryAfterMs = res && res.status === 429 ? Number((res.headers && res.headers.get && res.headers.get("retry-after")) || 0) * 1000 : 0;
       say("Couldn't save to your account. Trying again soon.");
-      tell({ step: "sync", text: synced });
+      retryTimer = setTimeout(() => {
+        retryTimer = null;
+        const next = queued;
+        queued = null;
+        if (next !== null && opened === openCount) store(next);
+      }, Math.max(retryDelayMs, retryAfterMs || 0));
+      return;
     }
     if (queued !== null) { const next = queued; queued = null; store(next); }
   }
@@ -24260,7 +24389,7 @@ var SAVES_SCRIPT = pageScript("saves", `
   // asked for, so this costs one small read.
   document.addEventListener("visibilitychange", async () => {
     if (guest || paused || saving || document.visibilityState !== "visible" || !cloud || cloud instanceof Promise) return;
-    const res = await fetch(SAVES.api + "?version", { credentials: "same-origin" }).catch(() => null);
+    const res = await ask(SAVES.api + "?version").catch(() => null);
     const out = res && res.ok ? await res.json().catch(() => null) : null;
     if (!out || out.version_number === cloud.version_number || paused || saving) return;
     if (out.changed_by_kind !== "developer" && deviceIsNewer(out.saved_at)) return;
@@ -24277,6 +24406,7 @@ var SAVES_SCRIPT = pageScript("saves", `
   // text is this device's progress since its last save, kept as an earlier version (null: nothing to keep).
   async function takeDeveloperChange(text) {
     const opened = openCount;
+    queued = null;
     const keeping = keepDevice(text);
     const reload = () => {
       keptBeforeReload = text;
@@ -24293,6 +24423,7 @@ var SAVES_SCRIPT = pageScript("saves", `
     const taking = applying;
     if (!taking) return;
     applying = null;
+    queued = null; // From the game before the change: the game sends its own after it.
     clearTimeout(taking.timer);
     if (!ok) return taking.reload();
     const c = taking.c;
@@ -24330,7 +24461,7 @@ var SAVES_SCRIPT = pageScript("saves", `
     reply({ status: "asking" });
     if (guest || !signedIn()) return fail("account_needed", "Earlier versions are kept for players signed in to Zaisma: a guest's progress stays in this browser. Ask the player to sign in first (Zaisma.player.signIn).");
     if (m.request === "list_copies") {
-      const res = await fetch(SAVES.api + "/copies", { credentials: "same-origin" }).catch(() => null);
+      const res = await ask(SAVES.api + "/copies").catch(() => null);
       const out = res && res.ok ? await res.json().catch(() => null) : null;
       if (!out || !Array.isArray(out.save_copies)) return failed();
       return reply({ answer: out.save_copies.map(copyFields) });
@@ -24339,7 +24470,7 @@ var SAVES_SCRIPT = pageScript("saves", `
     const copyPath = SAVES.api + "/copies/" + m.saveCopyId;
     const noCopy = () => fail("no_save_copy", "The player has no earlier version " + m.saveCopyId + " in this game: Zaisma.saves.listCopies() lists the ones kept.");
     if (m.request === "get_copy") {
-      const res = await fetch(copyPath, { credentials: "same-origin" }).catch(() => null);
+      const res = await ask(copyPath).catch(() => null);
       if (res && res.status === 404) return noCopy();
       const out = res && res.ok ? await res.json().catch(() => null) : null;
       if (!out || !out.save_copy) return failed();
@@ -24351,7 +24482,7 @@ var SAVES_SCRIPT = pageScript("saves", `
     isRestoringCopy = true;
     queued = null;
     tell({ step: "pause" });
-    const res = await fetch(copyPath + "/restore", { method: "POST", credentials: "same-origin" }).catch(() => null);
+    const res = await ask(copyPath + "/restore", { method: "POST", body: JSON.stringify({ tag: cloud && !(cloud instanceof Promise) ? cloud.tag : null }) }).catch(() => null);
     isRestoringCopy = false;
     if (res && res.ok) {
       reply({ answer: null });
@@ -24360,6 +24491,11 @@ var SAVES_SCRIPT = pageScript("saves", `
       openThroughRestore();
       return;
     }
+    // Another account signed in on this browser: the game reopens as that account.
+    if (res && res.status === 409) {
+      awaitSignIn(true);
+      return failed();
+    }
     paused = wasPaused;
     if (!wasPaused) tell({ step: "sync", text: synced });
     if (res && res.status === 404) return noCopy();
@@ -43523,6 +43659,9 @@ function isLocalPreview(env2) {
   return siteHost === "localhost" || siteHost === "127.0.0.1" || siteHost.endsWith(".ts.net");
 }
 
+// ../../apps/site/src/credit-api.ts
+var PENDING_REFUND_FIRST_RETRY_MS = 5 * 6e4;
+
 // ../../apps/site/src/stripe-account-api.ts
 var CONNECT_STATE_DURATION_MS = 10 * 6e4;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaisma/game-server",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "Run your Zaisma game server: the same rooms on Zaisma or on your own server.",
   "license": "MIT",
   "homepage": "https://zaisma.com",

package/sdk/saves.js

@@ -33,7 +33,7 @@
   // first, doubling up to 1,024 while a batch's text stays under 1 MB (games keep whole files as records).
   var FIRST_BATCH_RECORD_COUNT = 16;
   var MAXIMUM_BATCH_RECORD_COUNT = 1024;
-  var SMALL_BATCH_CHARACTER_COUNT = 1024 * 1024;
+  var SMALL_BATCH_BYTE_COUNT = 1024 * 1024;
 
   // Tests check the save format through this (test/node/saves.test.ts).
   if (__ZAISMA_SAVES__.test) return __ZAISMA_SAVES__.test({ encode: encode, decode: decode, saveText: saveText, putSave: putSave, readDatabases: readDatabases, databasesReader: databasesReader });
@@ -67,6 +67,17 @@
     return textOf(canonical(local), idbText);
   }
   // The same text as canonicalSave on the server: all three keys, always in this order.
+  /** Text's size in UTF-8 bytes, as the server counts a save against the limit, without encoding it. */
+  function byteLength(text) {
+    var byteCount = text.length;
+    for (var i = 0; i < text.length; i++) {
+      var code = text.charCodeAt(i);
+      if (code < 0x80) continue;
+      // Two bytes below U+0800, and each half of a surrogate pair (four bytes the pair); three for the rest.
+      byteCount += code < 0x800 || (code >= 0xd800 && code < 0xe000) ? 1 : 2;
+    }
+    return byteCount;
+  }
   function textOf(localText, idbText) {
     return '{"save_format_version_number":1,"local_storage_items":' + localText + ',"indexeddb_databases":' + (idbText || "[]") + "}";
   }
@@ -319,21 +330,23 @@
 
   /**
    * readNumberbText while the game plays: each store's text is kept, and a read only reads again the stores
-   * the game changed (changed: { isAll, databases: [name], stores: ["<database>\n<store>"] }), a batch of
-   * records at a time, stopping once the save passes maximumCharacterCount characters. The text is exactly
+   * the game changed (changed: { isAll, isCountCheck, databases: [name], stores: ["<database>\n<store>"] }), a batch
+   * of records at a time, stopping once the save passes maximumByteCount bytes (UTF-8, as the server counts).
+   * isCountCheck also reads again any database whose version, stores or record counts changed, which catches most
+   * writes the script can't watch (the game's own workers) without reading what didn't change. The text is exactly
    * readNumberbText's, put together from the kept parts. Answers { text } or { isOverLimit: true }.
    */
   function databasesReader() {
     // Database name -> { version, stores: { name: { text, hasRecords } } }
     var kept = {};
-    return function read(changed, maximumCharacterCount) {
+    return function read(changed, maximumByteCount) {
       var changedStores = {};
       changed.stores.forEach(function (storeKey) {
         changedStores[storeKey] = true;
       });
       return names().then(function (list) {
         var keptNow = {};
-        var characterCount = 0;
+        var byteCount = 0;
         var index = 0;
         function next() {
           if (index === list.length) {
@@ -355,26 +368,73 @@
           var isAnyStore = isWhole || Object.keys(changedStores).some(function (storeKey) {
             return storeKey.indexOf(name + "\n") === 0;
           });
-          if (!isAnyStore) {
+          var keep = function () {
             keptNow[name] = before;
-            characterCount += before.characterCount;
-            return characterCount > maximumCharacterCount ? { isOverLimit: true } : next();
-          }
-          return readChanged(name, before, isWhole, changedStores, maximumCharacterCount - characterCount).then(function (database) {
-            if (database && database.isOverLimit) return { isOverLimit: true };
-            if (database) {
-              keptNow[name] = database;
-              characterCount += database.characterCount;
-            }
-            return next();
+            byteCount += before.byteCount;
+            return byteCount > maximumByteCount ? { isOverLimit: true } : next();
+          };
+          var readAgain = function (isWholeRead) {
+            return readChanged(name, before, isWholeRead, changedStores, maximumByteCount - byteCount).then(function (database) {
+              if (database && database.isOverLimit) return { isOverLimit: true };
+              if (database) {
+                keptNow[name] = database;
+                byteCount += database.byteCount;
+              }
+              return next();
+            });
+          };
+          if (isAnyStore) return readAgain(isWhole);
+          if (!changed.isCountCheck) return keep();
+          return countsChanged(name, before).then(function (isChanged) {
+            return isChanged ? readAgain(true) : keep();
           });
         }
         return next();
       });
     };
   }
+  /** Whether a database kept from an earlier read looks changed: its version, stores or a store's record count. Only counts are read, never records. */
+  function countsChanged(name, before) {
+    var created = false;
+    return open(name, 0, function () {
+      created = true;
+    }).then(function (database) {
+      var stores = storeNames(database);
+      if (created || database.version !== before.version || stores.join("\n") !== before.storeNames.join("\n")) {
+        database.close();
+        if (created) indexedDB.deleteDatabase(name);
+        return true;
+      }
+      if (!stores.length) {
+        database.close();
+        return false;
+      }
+      return new Promise(function (ok) {
+        var transaction = database.transaction(stores, "readonly");
+        var recordCounts = {};
+        stores.forEach(function (storeName) {
+          var counting = transaction.objectStore(storeName).count();
+          counting.onsuccess = function () {
+            recordCounts[storeName] = counting.result;
+          };
+        });
+        transaction.oncomplete = function () {
+          database.close();
+          ok(
+            stores.some(function (storeName) {
+              return recordCounts[storeName] !== before.stores[storeName].recordCount;
+            }),
+          );
+        };
+        transaction.onerror = transaction.onabort = function () {
+          database.close();
+          ok(true);
+        };
+      });
+    });
+  }
   /** One database for databasesReader: its stores read again where changed, the rest as kept. null when it's gone or has no stores. */
-  function readChanged(name, before, isWhole, changedStores, maximumCharacterCount) {
+  function readChanged(name, before, isWhole, changedStores, maximumByteCount) {
     var created = false;
     return open(name, 0, function () {
       created = true;
@@ -390,12 +450,12 @@
       var reading = stores.filter(function (storeName) {
         return isWhole || !before.stores[storeName] || changedStores[name + "\n" + storeName];
       });
-      var out = { version: database.version, storeNames: stores, stores: {}, characterCount: 0, hasRecords: false };
+      var out = { version: database.version, storeNames: stores, stores: {}, byteCount: 0, hasRecords: false };
       stores.forEach(function (storeName) {
         if (reading.indexOf(storeName) === -1) out.stores[storeName] = before.stores[storeName];
       });
       stores.forEach(function (storeName) {
-        if (out.stores[storeName]) out.characterCount += out.stores[storeName].text.length;
+        if (out.stores[storeName]) out.byteCount += out.stores[storeName].byteCount;
       });
       if (!reading.length) {
         database.close();
@@ -421,20 +481,21 @@
           var keys = store.getAllKeys(range, batchRecordCount);
           var values = store.getAll(range, batchRecordCount);
           values.onsuccess = function () {
-            var previousCharacterCount = out.characterCount;
+            var previousByteCount = out.byteCount;
             var blobCharacterCount = pending.blobCharacterCount || 0;
             values.result.forEach(function (record, i) {
               var encoded = encode([keys.result[i], record], pending, []);
               copy.records.push(encoded);
-              out.characterCount += JSON.stringify(encoded).length + 1;
+              out.byteCount += byteLength(JSON.stringify(encoded)) + 1;
             });
-            out.characterCount += (pending.blobCharacterCount || 0) - blobCharacterCount;
-            if (out.characterCount > maximumCharacterCount) {
+            // A file's base64 text is all ASCII: a character a byte.
+            out.byteCount += (pending.blobCharacterCount || 0) - blobCharacterCount;
+            if (out.byteCount > maximumByteCount) {
               isOverLimit = true;
               transaction.abort();
               return;
             }
-            var isSmall = out.characterCount - previousCharacterCount < SMALL_BATCH_CHARACTER_COUNT;
+            var isSmall = out.byteCount - previousByteCount < SMALL_BATCH_BYTE_COUNT;
             if (values.result.length === batchRecordCount) nextBatch(keys.result[keys.result.length - 1], isSmall ? Math.min(batchRecordCount * 2, MAXIMUM_BATCH_RECORD_COUNT) : batchRecordCount);
             else nextStore();
           };
@@ -448,11 +509,12 @@
               var recordTexts = stored.records.map(function (record) {
                 return JSON.stringify(record);
               });
-              out.stores[stored.shape.name] = { text: shapeText.slice(0, -1) + ',"records":[' + recordTexts.join(",") + "]}", hasRecords: stored.records.length > 0 };
+              var storeText = shapeText.slice(0, -1) + ',"records":[' + recordTexts.join(",") + "]}";
+              out.stores[stored.shape.name] = { text: storeText, byteCount: byteLength(storeText), recordCount: stored.records.length, hasRecords: stored.records.length > 0 };
             });
-            out.characterCount = 0;
+            out.byteCount = 0;
             stores.forEach(function (storeName) {
-              out.characterCount += out.stores[storeName].text.length;
+              out.byteCount += out.stores[storeName].byteCount;
             });
             ok(finish(out));
           }, fail);
@@ -477,7 +539,7 @@
     var read = databasesReader();
     addEventListener("message", function (event) {
       var asked = event.data || {};
-      read(asked.changed, asked.maximumCharacterCount).then(
+      read(asked.changed, asked.maximumByteCount).then(
         function (answer) {
           answer.id = asked.id;
           postMessage(answer);
@@ -596,7 +658,7 @@
     // The page always hands over a v1 save.
     var local = save.local_storage_items;
     var databases = decode(save.indexeddb_databases);
-    // IndexedDB first: it's the part that can fail, and then localStorage is still as it was.
+    // IndexedDB first, so a database that can't be set up leaves localStorage as it was.
     var writing =
       window.indexedDB && indexedDB.databases
         ? writeDatabases(databases, onBlocked)
@@ -604,10 +666,20 @@
           ? Promise.reject(new Error("No IndexedDB here"))
           : Promise.resolve();
     return writing.then(function () {
-      localStorage.clear();
-      Object.keys(local).forEach(function (key) {
-        localStorage.setItem(key, String(local[key]));
-      });
+      // A write that throws (the browser's storage is full) puts this device's localStorage back as it was.
+      var before = snapshot();
+      try {
+        localStorage.clear();
+        Object.keys(local).forEach(function (key) {
+          localStorage.setItem(key, String(local[key]));
+        });
+      } catch (error) {
+        localStorage.clear();
+        Object.keys(before).forEach(function (key) {
+          localStorage.setItem(key, before[key]);
+        });
+        throw error;
+      }
     });
   }
 
@@ -681,7 +753,8 @@
 
   // What the game changed since the last check, so a check reads only that again: a store, a whole
   // database (set up anew or deleted) or localStorage. Writes the game's own workers make, and
-  // localStorage set as a property, aren't seen, so every 10th check (5 minutes) reads everything.
+  // localStorage set as a property, aren't seen: every 10th check (5 minutes) reads localStorage and any
+  // database whose version or record counts changed, and leaving the page reads every database whole.
   var changedStores = {};
   var changedDatabases = {};
   var isLocalChanged = true;
@@ -735,7 +808,7 @@
   var hereReader = null;
   var waiting = null;
   var readNumber = 0;
-  function readDatabasesText(changed, maximumCharacterCount) {
+  function readDatabasesText(changed, maximumByteCount) {
     if (!isWorkerTried) {
       isWorkerTried = true;
       try {
@@ -755,7 +828,7 @@
     }
     if (!worker) {
       hereReader = hereReader || databasesReader();
-      return hereReader(changed, maximumCharacterCount);
+      return hereReader(changed, maximumByteCount);
     }
     var id = ++readNumber;
     return new Promise(function (ok) {
@@ -766,14 +839,14 @@
           ok(answer);
         },
       };
-      worker.postMessage({ id: id, changed: changed, maximumCharacterCount: maximumCharacterCount });
+      worker.postMessage({ id: id, changed: changed, maximumByteCount: maximumByteCount });
     }).then(function (answer) {
       if (!answer.isFailed) return answer;
       // The worker can't read here (or stopped): read on the page from now on, from the start.
       if (worker) worker.terminate();
       worker = null;
       hereReader = databasesReader();
-      return hereReader({ isAll: true, databases: [], stores: [] }, maximumCharacterCount);
+      return hereReader({ isAll: true, databases: [], stores: [] }, maximumByteCount);
     });
   }
 
@@ -781,35 +854,44 @@
   var last = null;
   var timer = null;
   var localText = null;
+  var localByteCount = 0;
   var idbText = null;
   var checkCount = 0;
   var reading = false;
   var again = false;
   // localStorage this small is read at every check anyway, which also catches it set as a property.
   var SMALL_LOCAL_CHARACTER_COUNT = 64 * 1024;
-  /** isLeaving: the player is leaving the tab, so localStorage is read whatever was seen. */
-  function check(isLeaving) {
+  /**
+   * isLeaving: the player is leaving the tab, so localStorage is read whatever was seen. isWhole: the page is going
+   * away, so every database is read whole, catching any write the script couldn't see.
+   */
+  function check(isLeaving, isWhole) {
     if (!syncing) return;
     if (reading) {
       again = true;
       return;
     }
-    var isAll = isAllChanged || idbText === null || ++checkCount % 10 === 0;
-    var changed = { isAll: isAll, databases: Object.keys(changedDatabases), stores: Object.keys(changedStores) };
-    var readsIdb = isAll || changed.databases.length > 0 || changed.stores.length > 0;
-    var readsLocal = isAll || isLocalChanged || localText === null || isLeaving === true || localText.length < SMALL_LOCAL_CHARACTER_COUNT;
+    var isAll = isAllChanged || idbText === null || isWhole === true;
+    // Every 10th check (5 minutes), also what the script can't watch: localStorage, and databases whose version or record counts changed.
+    var isCountCheck = !isAll && ++checkCount % 10 === 0;
+    var changed = { isAll: isAll, isCountCheck: isCountCheck, databases: Object.keys(changedDatabases), stores: Object.keys(changedStores) };
+    var readsIdb = isAll || isCountCheck || changed.databases.length > 0 || changed.stores.length > 0;
+    var readsLocal = isAll || isCountCheck || isLocalChanged || localText === null || isLeaving === true || localText.length < SMALL_LOCAL_CHARACTER_COUNT;
     if (!readsIdb && !readsLocal) return;
     changedStores = {};
     changedDatabases = {};
     isAllChanged = false;
     isLocalChanged = false;
     reading = true;
-    if (readsLocal) localText = canonical(snapshot());
-    var maximumCharacterCount = saveLimitBytes - localText.length;
-    (readsIdb ? readDatabasesText(changed, maximumCharacterCount) : Promise.resolve({ text: idbText }))
+    if (readsLocal) {
+      localText = canonical(snapshot());
+      localByteCount = byteLength(localText);
+    }
+    var maximumByteCount = saveLimitBytes - localByteCount;
+    (readsIdb ? readDatabasesText(changed, maximumByteCount) : Promise.resolve({ text: idbText }))
       .then(function (answer) {
         if (answer.isFailed) throw new Error("The save couldn't be read");
-        if (answer.isOverLimit || localText.length > saveLimitBytes) {
+        if (answer.isOverLimit || localByteCount > saveLimitBytes) {
           // Read again in full next time: what's kept stopped partway.
           idbText = null;
           post({ step: "over_limit" });
@@ -856,17 +938,15 @@
         fail(new Error("The game holds its database open"));
       }).then(ok, fail);
     })
-      .then(function () {
-        // What's in storage now is the save the page sent: the next check has nothing new to send.
-        return readNumberbText();
-      })
       .then(
-        function (freshIdbText) {
-          idbText = freshIdbText;
+        function () {
+          // What's in storage now is the save the page sent, already encoded: nothing is read again on the game's thread.
+          idbText = save.indexeddb_databases.length ? JSON.stringify(save.indexeddb_databases) : "";
           localText = canonical(snapshot());
-          // The worker's kept parts are from before: the next check reads everything (and finds nothing new).
+          localByteCount = byteLength(localText);
+          // The worker's kept parts are from before: the next check reads everything there (and finds nothing new).
           isAllChanged = true;
-          last = textOf(localText, freshIdbText);
+          last = textOf(localText, idbText);
           post({ step: "applied", ok: true });
         },
         function () {
@@ -878,7 +958,7 @@
     if (document.visibilityState === "hidden") check(true);
   });
   addEventListener("pagehide", function () {
-    check(true);
+    check(true, true);
   });
   post({ step: "hello", phase: "game", versionId: versionId });
 })();

package/sdk/zaisma.d.ts

@@ -1005,7 +1005,8 @@ declare namespace Zaisma {
     readonly canChat: boolean;
     /**
      * When Zaisma will end this match, an ISO time, or null: set once the game's hosting pauses for the
-     * month, an hour after the pause (the "ending" event). Never set in a room on your own server.
+     * month, an hour after the pause (the "ending" event); null again if Zaisma calls the end off (the
+     * "endingCancelled" event). Never set in a room on your own server.
      */
     readonly endsAt: string | null;
     /**
@@ -1222,6 +1223,11 @@ declare namespace Zaisma {
      * "ended" follows then.
      */
     ending: (ending: Ending) => void;
+    /**
+     * Zaisma called off the end the "ending" event announced, because the game's hosting started again:
+     * room.endsAt is null, and the match goes on. Optional, as events added after v1 are, so v1's types still fit.
+     */
+    endingCancelled?: () => void;
     /** The game server or the host removed the player from the room. The connection closes. */
     kicked: (kicked: Kicked) => void;
     /** The room's listing, Join switch, name or labels changed, or how many watch: room.isListed, room.isOpen, room.friendJoinsEnabled, room.name, room.labels and room.spectatorCount have the new ones. */

package/sdk/zaisma.js

@@ -29,7 +29,7 @@
   var SMOOTHING_OPTIONS = ["delayMs"];
   var DELIVERIES = ["reliable", "latest_only"];
   var ROOM_INFO_FIELDS = ["name", "labels"];
-  var ROOM_EVENTS = ["message", "bytes", "state", "players", "connectionStatus", "ended", "ending", "kicked", "settings", "move", "moved", "idle", "away", "back", "muted", "error", "versionUpdate", "chat"];
+  var ROOM_EVENTS = ["message", "bytes", "state", "players", "connectionStatus", "ended", "ending", "endingCancelled", "kicked", "settings", "move", "moved", "idle", "away", "back", "muted", "error", "versionUpdate", "chat"];
   /** Chat (room.chat): the longest message, the lines a room keeps in memory for reports, and how many of them a report carries. */
   var MAXIMUM_CHAT_CHARACTER_COUNT = 2000;
   var KEPT_CHAT_LINE_COUNT = 50;
@@ -640,6 +640,9 @@
       } else if (message.type === "ending") {
         room.endsAt = message.endsAt;
         room._emit("ending", { endsAt: message.endsAt });
+      } else if (message.type === "ending_cancelled") {
+        room.endsAt = null;
+        room._emit("endingCancelled");
       } else if (message.type === "version_update") {
         var versionUpdate = { versionId: message.versionId, appliesAt: message.appliesAt, isReloading: message.isReloading === true };
         if (message.step === "now") room._isReloadingForVersion = versionUpdate.isReloading;

package/src/room.d.ts

@@ -98,7 +98,8 @@ export interface Room {
     /**
      * When Zaisma will end this match, an ISO time, or null. Set once the game's hosting on Zaisma rooms
      * pauses for the month (its free allowance, or its developer's budget or credit, is used), an hour after
-     * the pause, so your game can save and tell its players (onEnding runs then); never set on your own server.
+     * the pause, so your game can save and tell its players (onEnding runs then); back to null when Zaisma calls the
+     * end off because the game's hosting started again (onEndingCancelled runs then). Never set on your own server.
      */
     readonly endsAt: string | null;
     /** Shown in room lists (the game page and Zaisma.rooms.list). A hidden room still works by code and link. */
@@ -541,6 +542,12 @@ export interface GameServer<S = any> {
      * the "ending" event. Never runs on your own server.
      */
     onEnding?(state: S, room: Room): HandlerResult<S>;
+    /**
+     * Zaisma called off the end onEnding announced, because the game's hosting started again (credit came in, its
+     * budget was raised or the month reset): room.endsAt is null again, the match goes on and takes new players.
+     * Runs once; each player's game also gets the "endingCancelled" event. Never runs on your own server.
+     */
+    onEndingCancelled?(state: S, room: Room): HandlerResult<S>;
     /**
      * The room restarted (Zaisma restarts its rooms on every update, and your own server may restart) and
      * came back with the state it last saved: restoreInfo.savedAt says when, and restoreInfo.lostDurationSec
@@ -634,7 +641,7 @@ export declare function readJoinAnswer(answer: unknown): {
     mistake: GameServerError;
 };
 /** Everything a game server object may have, in the order the docs give them. Anything else is refused. */
-export declare const GAME_SERVER_OPTIONS: readonly ["maximumPlayerCount", "maximumSpectatorCount", "ticksPerSec", "hostControlsEnabled", "idleCheck", "idleTimeoutSec", "awayMode", "seatHoldDurationSec", "stateSyncEnabled", "adultChatFilterEnabled", "reconnectTimeoutSec", "maximumRoomCountPerPlayer", "stateSaveIntervalSec", "setup", "onJoin", "canJoin", "onChat", "onMoved", "onLeave", "onSpectatorJoin", "onSpectatorLeave", "onAway", "onBack", "onMessage", "onBytes", "onPurchase", "onRefund", "onTick", "onEnding", "onRestored", "stateView", "onVersionUpdate", "onRequest", "schedules", "onSchedule", "onWebhook"];
+export declare const GAME_SERVER_OPTIONS: readonly ["maximumPlayerCount", "maximumSpectatorCount", "ticksPerSec", "hostControlsEnabled", "idleCheck", "idleTimeoutSec", "awayMode", "seatHoldDurationSec", "stateSyncEnabled", "adultChatFilterEnabled", "reconnectTimeoutSec", "maximumRoomCountPerPlayer", "stateSaveIntervalSec", "setup", "onJoin", "canJoin", "onChat", "onMoved", "onLeave", "onSpectatorJoin", "onSpectatorLeave", "onAway", "onBack", "onMessage", "onBytes", "onPurchase", "onRefund", "onTick", "onEnding", "onEndingCancelled", "onRestored", "stateView", "onVersionUpdate", "onRequest", "schedules", "onSchedule", "onWebhook"];
 export declare const ROOM_LIMITS: {
     /** Players in one room: what one room carries at 60 ticks a second (test/load/room-load.test.ts). */
     readonly maximumPlayerCount: 100;
@@ -843,6 +850,8 @@ export type ServerMessage = {
 } | {
     type: "ending";
     endsAt: string;
+} | {
+    type: "ending_cancelled";
 } | {
     type: "version_update";
     step: "coming" | "now";
@@ -1664,6 +1673,11 @@ export declare class RoomCore<S = any> {
      * Only Zaisma rooms call it, when the game's hosting pauses.
      */
     startEnding(endsAt: string): void;
+    /**
+     * Zaisma calls off the end startEnding announced, since the game's hosting started again: endsAt is null, every
+     * player hears it and onEndingCancelled runs, once. Only Zaisma rooms call it.
+     */
+    cancelEnding(): void;
     /** End the match: everyone hears message and why (endReason), and their connections close. */
     end(message: string, endReason: EndReason): void;
     /** The players as every player's game lists them, with why each isn't playing. */

package/src/room.js

@@ -94,6 +94,7 @@ export const GAME_SERVER_OPTIONS = [
     "onRefund",
     "onTick",
     "onEnding",
+    "onEndingCancelled",
     "onRestored",
     "stateView",
     "onVersionUpdate",
@@ -2210,6 +2211,19 @@ export class RoomCore {
         if (this.server.onEnding)
             this.run(() => this.server.onEnding(this.state, this.api), "onEnding");
     }
+    /**
+     * Zaisma calls off the end startEnding announced, since the game's hosting started again: endsAt is null, every
+     * player hears it and onEndingCancelled runs, once. Only Zaisma rooms call it.
+     */
+    cancelEnding() {
+        if (this.ended || this.endsAt === null)
+            return;
+        this.endsAt = null;
+        this.dirty = true;
+        this.sendEach(this.everyone(), JSON.stringify({ type: "ending_cancelled" }));
+        if (this.server.onEndingCancelled)
+            this.run(() => this.server.onEndingCancelled(this.state, this.api), "onEndingCancelled");
+    }
     /** End the match: everyone hears message and why (endReason), and their connections close. */
     end(message, endReason) {
         if (this.ended)