@zaisma/game-server 1.8.0 → 1.10.0

package/bin/local-play.js

@@ -145,6 +145,8 @@ function defaultState() {
     // Each player's guest, while they play as one: { id, name }.
     guests: {},
     friends: [],
+    // Friend requests waiting between bench accounts: { from, to, createdAtMs }.
+    friendRequests: [],
     blocks: [],
     ownedItems: {},
     items: [],
@@ -629,6 +631,8 @@ export async function startLocalPlay(givenOptions) {
     if (rest === "" && method === "DELETE") {
       state.accounts = state.accounts.filter((each) => each.id !== account.id);
       state.friends = state.friends.filter((pair) => !pair.includes(account.id));
+      state.friendRequests = (state.friendRequests ?? []).filter((each) => each.from !== account.id && each.to !== account.id);
+      state.acceptedFriendRequests = (state.acceptedFriendRequests ?? []).filter((each) => each.from !== account.id && each.to !== account.id);
       state.blocks = state.blocks.filter((block) => block.blocker !== account.id && block.blocked !== account.id);
       state.purchases = state.purchases.filter((purchase) => purchase.accountId !== account.id);
       delete state.ownedItems[account.id];
@@ -951,6 +955,67 @@ export async function startLocalPlay(givenOptions) {
       }
       return reply(200, { player: { player_id: target.playerId, name: target.username }, is_friend: friendIdsOf(account.id).includes(target.id), is_blocked: state.blocks.some((block) => block.blocker === account.id && block.blocked === target.id) });
     }
+    // Friend requests between bench accounts, as Zaisma's game page sends and answers them (apps/site/src/friend-requests.ts).
+    if (path === "/friends/requests" || path.startsWith("/friends/requests/")) {
+      if (!account) return reply(401, { error: { code: "not_signed_in", message: "Sign in to add friends." } });
+      const requests = (state.friendRequests ??= []);
+      const isBlockedPair = (other) => state.blocks.some((block) => isPair([block.blocker, block.blocked], account.id, other.id));
+      const isFriend = (other) => friendIdsOf(account.id).includes(other.id);
+      const waitingFrom = (from, to) => requests.find((each) => each.from === from && each.to === to);
+      const makeFriends = (other) => {
+        // The sender hears of the accept on their next look, for a day, as on Zaisma.
+        (state.acceptedFriendRequests ??= []).push({ from: other.id, to: account.id, answeredAtMs: Date.now() });
+        state.friendRequests = requests.filter((each) => !isPair([each.from, each.to], account.id, other.id));
+        if (!isFriend(other)) state.friends.push([account.id, other.id]);
+        saveState();
+        log(`${account.username} and ${other.username} are friends now.`);
+      };
+      if (request.method === "GET" && path === "/friends/requests") {
+        const accepted = (state.acceptedFriendRequests ?? []).filter((each) => each.from === account.id && each.answeredAtMs > Date.now() - 86400000 && isFriend({ id: each.to })).map((each) => ({ to: accountOf(each.to), answeredAtMs: each.answeredAtMs })).filter((each) => each.to);
+        return reply(200, {
+          requests: requests.filter((each) => each.to === account.id).map((each) => ({ from: accountOf(each.from), createdAtMs: each.createdAtMs })).filter((each) => each.from).map((each) => ({ player_id: each.from.playerId, name: each.from.username, created_at_ms: each.createdAtMs, game_slug: gameSlug })).reverse(),
+          accepted: accepted.map((each) => ({ player_id: each.to.playerId, name: each.to.username, answered_at_ms: each.answeredAtMs })).reverse(),
+        });
+      }
+      const aboutMatch = /^\/friends\/requests\/about\/(player_[a-z0-9]{1,40})$/.exec(path);
+      if (request.method === "GET" && aboutMatch) {
+        const other = accountOfPlayer(aboutMatch[1]);
+        if (!other || other.id === account.id) return reply(200, { player: null, can_send: false, has_sent: false, is_friend: false });
+        const hasSent = Boolean(waitingFrom(account.id, other.id));
+        const canSend = !isFriend(other) && !hasSent && !isBlockedPair(other) && other.ageBand === account.ageBand && (Boolean(waitingFrom(other.id, account.id)) || glass.takesFriendRequests(other.ageBand, other.socialMode));
+        return reply(200, { player: { player_id: other.playerId, name: other.username }, can_send: canSend, has_sent: hasSent, is_friend: isFriend(other) });
+      }
+      if (isPost && path === "/friends/requests") {
+        const body = await readJson(request);
+        const other = typeof body.player_id === "string" ? accountOfPlayer(body.player_id) : null;
+        if (!other || other.id === account.id) return reply(409, { error: { code: "not_an_account", message: "Only players signed in to Zaisma take friend requests." } });
+        if (isFriend(other)) return reply(409, { error: { code: "already_friends", message: "You're friends already." } });
+        if (waitingFrom(other.id, account.id)) {
+          makeFriends(other);
+          return reply(200, { status: "friends" });
+        }
+        if (waitingFrom(account.id, other.id)) return reply(409, { error: { code: "already_sent", message: "Your request is waiting for them." } });
+        if (isBlockedPair(other) || other.ageBand !== account.ageBand || !glass.takesFriendRequests(other.ageBand, other.socialMode)) return reply(409, { error: { code: "not_taking_requests", message: "They aren't taking friend requests from you." } });
+        requests.push({ from: account.id, to: other.id, createdAtMs: Date.now() });
+        saveState();
+        log(`${account.username} sent ${other.username} a friend request.`);
+        return reply(200, { status: "sent" });
+      }
+      const answerMatch = /^\/friends\/requests\/(player_[a-z0-9]{1,40})\/(accept|turn-down)$/.exec(path);
+      if (isPost && answerMatch) {
+        await readText(request);
+        const other = accountOfPlayer(answerMatch[1]);
+        if (!other || !waitingFrom(other.id, account.id)) return reply(404, { error: { code: "request_not_found", message: "That request isn't waiting any more." } });
+        if (answerMatch[2] === "accept") makeFriends(other);
+        else {
+          state.friendRequests = requests.filter((each) => !(each.from === other.id && each.to === account.id));
+          saveState();
+          log(`${account.username} turned down ${other.username}'s friend request.`);
+        }
+        return reply(200, { answer: answerMatch[2] === "accept" ? "accepted" : "turned_down" });
+      }
+      return reply(404, { error: { code: "not_found", message: "Nothing here." } });
+    }
     // A report goes to Zaisma's moderators, or the game's developer: here the terminal says what it would send.
     if (isPost && path === `${game}/report`) {
       const body = await readJson(request);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaisma/game-server",
-  "version": "1.8.0",
+  "version": "1.10.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

@@ -240,8 +240,35 @@ declare namespace Zaisma {
      * await Zaisma.friends.setRoom(null);   // left the match
      */
     setRoom(room: OwnServerRoom | null): Promise<void>;
+    /**
+     * Offer the player to send another player a friend request, from your own scoreboard, lobby or menu.
+     * Zaisma asks the player first on its page ("Send Mia a friend request?", with the name Zaisma knows
+     * them by), so nothing is sent without them, and the other player gets it over their game's corner and
+     * on zaisma.com/friends. Players can also send one from Players in Zaisma's bar, so a button of your
+     * own is optional. Resolves with what happened: "sent"; "cancelled" when the player said no or another
+     * question was up; "already_friends"; or "not_taking_requests" when the other player doesn't take them
+     * from this one (their settings, their age group, a block, or a guest), which never says which. Your game
+     * never hears of requests themselves, only that two players are friends (room.areFriends on your game server, and the
+     * passes' tags, from their next join). Fails with error.code "account_needed" for a guest (ask them to
+     * sign in with {@link player.signIn}), "bad_player_id" for something that isn't a player's id, and
+     * "not_on_zaisma" when the game isn't played on Zaisma.
+     *
+     * @example
+     * // A button beside each player on your end-of-match screen.
+     * const { status } = await Zaisma.friends.sendRequest(player.id);
+     * if (status === "sent") button.textContent = "Request sent";
+     */
+    sendRequest(playerId: string): Promise<FriendRequestAnswer>;
   }
 
+  /** What became of a friend request the game offered ({@link Friends.sendRequest}). */
+  interface FriendRequestAnswer {
+    status: FriendRequestStatus;
+  }
+
+  /** "sent", "cancelled" (the player said no), "already_friends", or "not_taking_requests" (never why). */
+  type FriendRequestStatus = "sent" | "cancelled" | "already_friends" | "not_taking_requests";
+
   /** The player's friends playing this game ({@link Friends.list}). */
   interface FriendList {
     /** By name. Empty when none of them are playing it. */
@@ -1005,7 +1032,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 +1250,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;
@@ -617,6 +617,9 @@
       } else if (message.type === "blocks") {
         room._blocks = new Set(Array.isArray(message.playerIds) ? message.playerIds : []);
         room._mutedChanged();
+      } else if (message.type === "friend_request") {
+        // Someone here sent this player a friend request, or accepted theirs: the Zaisma page looks now (never who).
+        if (onZaismaPage()) window.parent.postMessage({ type: "zaisma:friend-requests" }, config.site);
       } else if (message.type === "message") {
         room._emit("message", message.data, typeof message.fromPlayerId === "string" ? message.fromPlayerId : null);
       } else if (message.type === "chat" || message.type === "chat_sent" || message.type === "chat_stopped" || (message.type === "error" && typeof message.chatNumber === "number")) {
@@ -640,6 +643,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;
@@ -2454,6 +2460,51 @@
   }
 
   var rooms = { list: listRooms, quickJoin: quickJoin, linkedRoomCode: roomCodeFromPage(), linkedServerUrl: roomCodeFromPage() ? serverUrlFromPage() : null, isLinkedAsSpectator: watchFromPage() };
-  var friends = { list: listFriends, setRoom: setOwnRoom };
+  /*
+   * Friend requests (zaisma.d.ts: Friends.sendRequest): the Zaisma page asks the player before anything is
+   * sent, with the name Zaisma knows the other player by, so no game sends one on a player's behalf. Once one
+   * is sent, from here or the page's Players, the rooms the other player is in tell their game to have their
+   * page look now; Zaisma's record is the request itself.
+   */
+  var friendRequestAsk = null;
+  var FRIEND_REQUEST_STATUSES = ["sent", "cancelled", "already_friends", "not_taking_requests"];
+  function sendFriendRequest(playerId) {
+    if (!onZaismaPage() || !config.rooms) return Promise.reject(notOnZaisma("Friend requests come from Zaisma, so they work only in games played on Zaisma."));
+    if (typeof playerId !== "string" || !/^player_[a-z0-9]{1,40}$/.test(playerId)) return Promise.reject(codedError("bad_player_id", "Zaisma.friends.sendRequest takes a player's id from room.players or Zaisma.friends.list."));
+    return getPass().then(function (mine) {
+      if (mine.kind !== "account") throw codedError("account_needed", "Friend requests are for players signed in to Zaisma: ask the player to sign in first (Zaisma.player.signIn).");
+      // One question at a time: another request while the page is asking is a no.
+      if (friendRequestAsk) return { status: "cancelled" };
+      friendRequestAsk = new Promise(function (resolve) {
+        var isAsking = false;
+        var timer = setTimeout(function () { if (!isAsking) settle("cancelled"); }, 3000);
+        function settle(status) {
+          removeEventListener("message", onMessage);
+          clearTimeout(timer);
+          friendRequestAsk = null;
+          resolve({ status: status });
+        }
+        function onMessage(event) {
+          var told = event.data;
+          if (event.origin !== config.site || event.source !== window.parent || !told || told.type !== "zaisma:friend-request" || told.playerId !== playerId) return;
+          if (told.status === "asking") isAsking = true;
+          else if (FRIEND_REQUEST_STATUSES.indexOf(told.status) !== -1) settle(told.status);
+        }
+        addEventListener("message", onMessage);
+        window.parent.postMessage({ type: "zaisma:friend-request", playerId: playerId }, config.site);
+      });
+      return friendRequestAsk;
+    });
+  }
+  // A request sent (by the game's own button or the page's Players), or one accepted: the rooms the other player is in nudge their game.
+  window.addEventListener("message", function (event) {
+    var told = event.data;
+    if (!config.site || event.origin !== config.site || event.source !== window.parent || !told || told.type !== "zaisma:friend-request" || (told.status !== "sent" && told.status !== "accepted") || typeof told.playerId !== "string") return;
+    joined.forEach(function (room) {
+      if (!room._done && !room.isSpectator && room.players.some(function (each) { return each.id === told.playerId; })) room._say({ type: "friend_request", playerId: told.playerId });
+    });
+  });
+
+  var friends = { list: listFriends, setRoom: setOwnRoom, sendRequest: sendFriendRequest };
   window.Zaisma = { sdkVersionNumber: 1, gameSlug: config.game || null, player: player, joinRoom: joinRoom, rooms: rooms, server: server, invite: invite, checkChat: checkChat, openPlayersPanel: openPlayersPanel, links: links, items: items, friends: friends, saves: saves, versions: versions };
 })();