@arcadible/sdk 1.5.1 → 1.5.2-next.0

package/dist/bus/protocol.js

@@ -157,7 +157,7 @@ export function utf8Size(text) {
 }
 // [function]
 // A rough size of a message as the browser copies it: strings by their
-// UTF-8 bytes, and a few bytes for anything else. It only has to be close
+// UTF-8 bytes, a Blob by its own, and a few bytes for anything else. It only has to be close
 // enough to refuse a message far over the limit, so it stops counting once
 // past `limit`, and counts an object it has seen (a cycle) once.
 export function messageSize(value, limit = Number.POSITIVE_INFINITY) {
@@ -172,6 +172,11 @@ export function messageSize(value, limit = Number.POSITIVE_INFINITY) {
             size += 8;
         else if (seen.has(item))
             size += 8;
+        else if (typeof Blob !== "undefined" && item instanceof Blob) {
+            // a picture: its bytes are copied with it.
+            seen.add(item);
+            size += item.size + 8;
+        }
         else {
             seen.add(item);
             size += 2;

package/dist/client.d.ts

@@ -1,6 +1,7 @@
 import { type Build } from "./bus/protocol.js";
 import { type Context } from "./context/client.js";
 import { type System } from "./system/client.js";
+import { type Players } from "./players/client.js";
 import type { Backend } from "./saves/backend/types.js";
 import { type Saves } from "./saves/client.js";
 export type Ready = {
@@ -39,6 +40,13 @@ export interface Arcadible {
      * alone, and `undefined` before.
      */
     readonly context: Context | null | undefined;
+    /**
+     * Who's playing: `primary`, the player the game runs for, fixed for the
+     * run, and `pictures()`, theirs. `primary` is set by the time `ready`
+     * settles; `null` where no page says, such as standing alone, and
+     * `undefined` before.
+     */
+    readonly players: Players;
     /**
      * Starts the game's initialization: call it as your code starts, before
      * anything it awaits, and Arcadible shows the game's loading screen until

package/dist/client.js

@@ -8,6 +8,7 @@ import { createLifecycle } from "./lifecycle/client.js";
 import { createPause } from "./lifecycle/pause.js";
 import { createContextClient } from "./context/client.js";
 import { createSystemClient } from "./system/client.js";
+import { createPlayersClient } from "./players/client.js";
 import { indexedDBBackend } from "./saves/backend/indexeddb.js";
 import { createSaves } from "./saves/client.js";
 import { serve } from "./host.js";
@@ -40,10 +41,11 @@ export function createClient(options = {}) {
     });
     const system = createSystemClient(bus);
     const context = createContextClient(bus);
+    const players = createPlayersClient(bus);
     const lifecycle = createLifecycle(bus, win);
     const pause = createPause(bus);
     // the ones `ready` waits on, or tells: lifecycle and pause do neither.
-    const parts = [saves, system, context];
+    const parts = [saves, system, context, players];
     let settled = null;
     // ready once welcomed, and each module's first messages have arrived;
     // then each is told, so its facts are known, or null.
@@ -69,6 +71,7 @@ export function createClient(options = {}) {
         get context() {
             return context.value;
         },
+        players: players.players,
         initStart() {
             lifecycle.start();
             return ready;

package/dist/host.d.ts

@@ -5,6 +5,8 @@ import { type Holds } from "./lifecycle/holds.js";
 import { type SystemState } from "./system/rules.js";
 import { type System } from "./system/server.js";
 import { type LifecycleHost } from "./lifecycle/server.js";
+import { type SignedIn } from "./players/host.js";
+import { type PlayersHost } from "./players/server.js";
 import type { Backend } from "./saves/backend/types.js";
 import type { Where } from "./saves/rules.js";
 export type ServeOptions = {
@@ -18,6 +20,7 @@ export type ServeOptions = {
     holds?: Holds;
     system?: System;
     context?: ContextState;
+    players?: PlayersHost;
 };
 export type Host = {
     close(): void;
@@ -25,7 +28,9 @@ export type Host = {
     leave(timeout?: number): Promise<void>;
     setSystem(state: Partial<SystemState>): void;
 };
-type HostOptions = Omit<ServeOptions, "holds" | "system" | "context"> & {
+type HostOptions = Omit<ServeOptions, "holds" | "system" | "context" | "players"> & {
+    player?: SignedIn | null;
+    fetch?: (url: string) => Promise<Response>;
     language?: string;
     launchedAt?: string;
     frame: HTMLIFrameElement;
@@ -37,6 +42,7 @@ export declare function serve(options: ServeOptions): Server;
 export declare function createHost(options: HostOptions): Host;
 export type { Server } from "./bus/server.js";
 export { createHolds, type Holds } from "./lifecycle/holds.js";
+export type { SignedIn } from "./players/host.js";
 export { createSystem, type System } from "./system/server.js";
 export { indexedDBBackend } from "./saves/backend/indexeddb.js";
 export { memoryBackend } from "./saves/backend/memory.js";

package/dist/host.js

@@ -9,6 +9,8 @@ import { createHolds } from "./lifecycle/holds.js";
 import { browserLanguage } from "./system/rules.js";
 import { createSystem } from "./system/server.js";
 import { lifecycleServer } from "./lifecycle/server.js";
+import { playersHost } from "./players/host.js";
+import { playersServer } from "./players/server.js";
 import { savesServer } from "./saves/server.js";
 // [function]
 // Answers the bus for one game in one channel, on any number of ports.
@@ -22,6 +24,7 @@ export function serve(options) {
             ...(options.holds ? [options.holds.module] : []),
             ...(options.system ? [options.system.module] : []),
             ...(options.context ? [contextServer(options.context)] : []),
+            ...(options.players ? [playersServer(options.players)] : []),
             savesServer({
                 backend,
                 now: options.now ?? (() => new Date()),
@@ -64,6 +67,16 @@ export function createHost(options) {
             ...options,
             holds,
             system,
+            ...(options.player === undefined
+                ? {}
+                : {
+                    players: playersHost({
+                        backend: options.backend,
+                        fetch: options.fetch ?? ((url) => win.fetch(url)),
+                        game: options.game,
+                        player: options.player,
+                    }),
+                }),
             context: {
                 // Arcadible's time when given, else the device's: never a time the
                 // game would refuse.

package/dist/index.d.ts

@@ -6,4 +6,6 @@ export type { Arcadible, Ready } from "./client.js";
 export type { Saves } from "./saves/client.js";
 export type { System } from "./system/client.js";
 export type { Context } from "./context/client.js";
+export type { Players } from "./players/client.js";
+export type { Player } from "./players/rules.js";
 export type { SaveInfo } from "./saves/rules.js";

package/dist/players/client.d.ts

@@ -0,0 +1,24 @@
+import type { Bus } from "../bus/client.js";
+import { type Player } from "./rules.js";
+/** Who's playing. */
+export interface Players {
+    /**
+     * The player the game runs for, fixed for the run: their id in this game,
+     * whether they're a guest, and their name. Set by the time `ready`
+     * settles; `null` where no page says, such as standing alone, and
+     * `undefined` before.
+     */
+    readonly primary: Player | null | undefined;
+    /**
+     * Each player's picture, 256 × 256, as WebP, in the order given: a Blob,
+     * or `null` for a player with none (a guest always). Takes players or
+     * their ids, up to 50. Rejects with `unavailable` when the pictures can't
+     * be reached, as offline.
+     */
+    pictures(players: readonly (Player | string)[]): Promise<(Blob | null)[]>;
+}
+export type PlayersClient = {
+    players: Players;
+    settle(): void;
+};
+export declare function createPlayersClient(bus: Bus): PlayersClient;

package/dist/players/client.js

@@ -0,0 +1,76 @@
+// The game's side of `players`: `arcadible.players`, who's playing. Its
+// `primary` is a fact, fixed for the run: `undefined` before `ready`, and
+// `null` where no page says (standing alone, or an older page). Pictures
+// are asked for when a game draws them.
+import { ArcadibleError, Codes, isObject, log } from "../bus/protocol.js";
+import { fact } from "../facts.js";
+import { isId, isPicture, MAX_PICTURES, Names, PICTURES_PER_REQUEST, stateOf, } from "./rules.js";
+// [function]
+// an answer the game can use: a list as long as what it asked for.
+function isAnswer(length) {
+    return (value) => Array.isArray(value) && value.length === length;
+}
+// [function]
+// the ids a game asked for, checked before anything is sent.
+function idsOf(players) {
+    if (!Array.isArray(players)) {
+        throw new ArcadibleError(Codes.Invalid, "players.pictures takes an array of players, or of their ids.");
+    }
+    if (players.length > MAX_PICTURES) {
+        throw new ArcadibleError(Codes.TooMany, `players.pictures takes up to ${MAX_PICTURES} players at once, not ${players.length}.`);
+    }
+    return players.map((entry, index) => {
+        const id = isObject(entry) ? entry["id"] : entry;
+        if (!isId(id)) {
+            throw new ArcadibleError(Codes.Invalid, `players.pictures takes players, or their ids: entry ${index} is neither.`);
+        }
+        return id;
+    });
+}
+// [function]
+export function createPlayersClient(bus) {
+    const primary = fact(bus, Names.State, {
+        fixed: true,
+        parse(data) {
+            const state = stateOf(data);
+            return state ? Object.freeze({ ...state.primary }) : null;
+        },
+    });
+    const ask = async function (ids) {
+        let answer;
+        try {
+            answer = await bus.request(Names.Pictures, { ids }, isAnswer(ids.length));
+        }
+        catch (err) {
+            // no page to ask (standing alone), or one from before pictures: no
+            // one has a picture there.
+            if (err instanceof ArcadibleError && err.code === Codes.Unsupported) {
+                return ids.map(() => null);
+            }
+            throw err;
+        }
+        return answer.map((entry, index) => {
+            if (entry === null)
+                return null;
+            if (isPicture(entry))
+                return entry;
+            log("warn", `ignored a malformed picture for player ${ids[index]}.`);
+            return null;
+        });
+    };
+    const players = {
+        get primary() {
+            return primary.value;
+        },
+        async pictures(list) {
+            const ids = idsOf(list);
+            // a few at a time, so every answer fits a message.
+            const pictures = [];
+            for (let at = 0; at < ids.length; at += PICTURES_PER_REQUEST) {
+                pictures.push(...(await ask(ids.slice(at, at + PICTURES_PER_REQUEST))));
+            }
+            return pictures;
+        },
+    };
+    return { players, settle: () => primary.settle() };
+}

package/dist/players/host.d.ts

@@ -0,0 +1,14 @@
+import type { Backend } from "../saves/backend/types.js";
+import type { PlayersHost } from "./server.js";
+export type SignedIn = {
+    id: string;
+    name: string | null;
+    picture?: string | null;
+};
+export type PlayersHostOptions = {
+    player: SignedIn | null;
+    backend: Backend;
+    game: string;
+    fetch: (url: string) => Promise<Response>;
+};
+export declare function playersHost(options: PlayersHostOptions): PlayersHost;

package/dist/players/host.js

@@ -0,0 +1,50 @@
+// Who a play page's game runs for: the player signed in, from the page's
+// own lookup, or the device's guest in this game.
+// [import]
+import { log } from "../bus/protocol.js";
+import { isId } from "./rules.js";
+// [function]
+// Only the primary's picture is found, fetched from its address when a
+// game first asks and kept for the run; no one else has one yet.
+export function playersHost(options) {
+    const signedIn = options.player;
+    if (signedIn && !isId(signedIn.id)) {
+        log("error", `the player's id isn't a UUID: ${JSON.stringify(signedIn.id)}.`);
+    }
+    let primary = null;
+    const address = signedIn?.picture ?? null;
+    let picture = null;
+    const fetchPicture = async function (url) {
+        // a fetch that fails rejects: the pictures can't be reached.
+        const response = await options.fetch(url);
+        if (!response.ok) {
+            log("warn", `the player's picture answered ${response.status}.`);
+            return null;
+        }
+        return response.blob();
+    };
+    return {
+        primary() {
+            primary ??= signedIn
+                ? Promise.resolve({
+                    id: signedIn.id,
+                    guest: false,
+                    name: signedIn.name,
+                })
+                : options.backend
+                    .guest(options.game)
+                    .then((id) => ({ id, guest: true, name: null }));
+            return primary;
+        },
+        async picture(id) {
+            if (!signedIn || !address || id !== signedIn.id)
+                return null;
+            picture ??= fetchPicture(address).catch((err) => {
+                // not kept, so the next ask tries again.
+                picture = null;
+                throw err;
+            });
+            return picture;
+        },
+    };
+}

package/dist/players/rules.d.ts

@@ -0,0 +1,37 @@
+export declare const Names: {
+    readonly State: "players.state";
+    readonly Pictures: "players.pictures";
+};
+/** A player, as a game sees one. */
+export interface Player {
+    /** This player in this game: a UUID, the same every run, different in every game. */
+    readonly id: string;
+    /** Signed out: playing on this device, with no account. */
+    readonly guest: boolean;
+    /** The profile's name, as players see it; null for a guest, or with none. */
+    readonly name: string | null;
+}
+export type PlayersState = {
+    primary: Player;
+};
+export declare const MAX_PICTURES = 50;
+export declare const PICTURES_PER_REQUEST = 10;
+export declare const MAX_PICTURE: number;
+export declare const PICTURE_TYPE = "image/webp";
+/** Whether a value is a player's id: a UUID, in lowercase. */
+export declare function isId(value: unknown): value is string;
+/**
+ * A new id, for a guest: a random UUID. `crypto.randomUUID` isn't on
+ * plain-http pages, as a development play page is, so it's built from
+ * `getRandomValues`, which is.
+ */
+export declare function newId(): string;
+/**
+ * A player as the game keeps one: only fields it knows, each checked. A
+ * guest has no name; a name that's blank is none.
+ */
+export declare function playerOf(value: unknown): Player | null;
+/** The state as the game keeps it, or null. */
+export declare function stateOf(value: unknown): PlayersState | null;
+/** Whether a value is a picture as either end hands one over. */
+export declare function isPicture(value: unknown): value is Blob;

package/dist/players/rules.js

@@ -0,0 +1,83 @@
+// `players` on the bus, shared by both ends: who's playing, fixed for the
+// run, and their pictures, on demand.
+// [import]
+import { isObject } from "../bus/protocol.js";
+// [declare]
+export const Names = {
+    // who's playing, `{ primary }`: an event, sent once, as the module opens.
+    State: "players.state",
+    // pictures, a request with `{ ids }`, answered with a Blob or null each.
+    Pictures: "players.pictures",
+};
+// The most pictures one call asks for.
+export const MAX_PICTURES = 50;
+// How many go in one request, and the largest picture the page hands over,
+// so an answer always fits a message: ten of the largest are under
+// `MAX_MESSAGE`. A 256 × 256 WebP is 15 to 20 KB.
+export const PICTURES_PER_REQUEST = 10;
+export const MAX_PICTURE = 96 * 1024;
+export const PICTURE_TYPE = "image/webp";
+// The longest name kept: a profile's is far shorter.
+const MAX_NAME = 200;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+// [function]
+/** Whether a value is a player's id: a UUID, in lowercase. */
+export function isId(value) {
+    return typeof value === "string" && UUID.test(value);
+}
+// [function]
+/**
+ * A new id, for a guest: a random UUID. `crypto.randomUUID` isn't on
+ * plain-http pages, as a development play page is, so it's built from
+ * `getRandomValues`, which is.
+ */
+export function newId() {
+    const bytes = crypto.getRandomValues(new Uint8Array(16));
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = [...bytes].map((byte) => byte.toString(16).padStart(2, "0"));
+    return [
+        hex.slice(0, 4),
+        hex.slice(4, 6),
+        hex.slice(6, 8),
+        hex.slice(8, 10),
+        hex.slice(10, 16),
+    ]
+        .map((part) => part.join(""))
+        .join("-");
+}
+// [function]
+/**
+ * A player as the game keeps one: only fields it knows, each checked. A
+ * guest has no name; a name that's blank is none.
+ */
+export function playerOf(value) {
+    if (!isObject(value))
+        return null;
+    const { id, guest, name } = value;
+    if (!isId(id) || typeof guest !== "boolean")
+        return null;
+    if (name !== null && typeof name !== "string")
+        return null;
+    if (typeof name === "string" && name.length > MAX_NAME)
+        return null;
+    const kept = guest || name === null || name.trim() === "" ? null : name;
+    return { id, guest, name: kept };
+}
+// [function]
+/** The state as the game keeps it, or null. */
+export function stateOf(value) {
+    if (!isObject(value))
+        return null;
+    const primary = playerOf(value["primary"]);
+    return primary ? { primary } : null;
+}
+// [function]
+/** Whether a value is a picture as either end hands one over. */
+export function isPicture(value) {
+    return (typeof Blob !== "undefined" &&
+        value instanceof Blob &&
+        value.type === PICTURE_TYPE &&
+        value.size > 0 &&
+        value.size <= MAX_PICTURE);
+}

package/dist/players/server.d.ts

@@ -0,0 +1,7 @@
+import type { Module } from "../bus/server.js";
+import { type Player } from "./rules.js";
+export type PlayersHost = {
+    primary(): Promise<Player>;
+    picture(id: string): Promise<Blob | null>;
+};
+export declare function playersServer(host: PlayersHost): () => Module;

package/dist/players/server.js

@@ -0,0 +1,57 @@
+// The page's side of `players`: who's playing, sent once as the game
+// connects, and their pictures, fetched when a game asks. It never changes
+// during the run: the page ends the run when the player does.
+// [import]
+import { ArcadibleError, Codes, log } from "../bus/protocol.js";
+import { isId, isPicture, Names, PICTURES_PER_REQUEST, playerOf, } from "./rules.js";
+// [function]
+function idsOf(params) {
+    const ids = params["ids"];
+    if (!Array.isArray(ids) ||
+        ids.length > PICTURES_PER_REQUEST ||
+        !ids.every(isId)) {
+        throw new ArcadibleError(Codes.Invalid, `players.pictures takes up to ${PICTURES_PER_REQUEST} ids.`);
+    }
+    return ids;
+}
+// [function]
+export function playersServer(host) {
+    const pictures = async function (params) {
+        const ids = idsOf(params);
+        const found = await Promise.allSettled(ids.map((id) => host.picture(id)));
+        // one that fails among many is null, said in the console; when none
+        // can be reached, the game is told, and can try again.
+        const failed = found.filter((one) => one.status === "rejected");
+        if (ids.length > 0 && failed.length === ids.length) {
+            throw new ArcadibleError(Codes.Unavailable, "Pictures can't be reached right now. Try again.");
+        }
+        return found.map((one, index) => {
+            if (one.status === "rejected") {
+                log("warn", `player ${ids[index]}'s picture couldn't be fetched.`);
+                return null;
+            }
+            if (one.value === null || isPicture(one.value))
+                return one.value;
+            log("warn", `player ${ids[index]}'s picture isn't one a game takes.`);
+            return null;
+        });
+    };
+    return () => ({
+        handlers: {
+            // beside the queue: it waits on the network, not on storage.
+            [Names.Pictures]: { run: pictures, parallel: true },
+        },
+        // first on each channel, so the game has it by `ready`.
+        async open(send) {
+            try {
+                const primary = playerOf(await host.primary());
+                if (!primary)
+                    throw new Error("The page's player isn't one.");
+                send(Names.State, { primary });
+            }
+            catch (err) {
+                log("warn", "the game isn't told who's playing.", err);
+            }
+        },
+    });
+}

package/dist/saves/backend/indexeddb.js

@@ -1,5 +1,6 @@
 // [import]
 import { ArcadibleError, Codes, log } from "../../bus/protocol.js";
+import { isId, newId } from "../../players/rules.js";
 import { listenersByKey } from "./listeners.js";
 import { memoryBackend } from "./memory.js";
 // [declare]
@@ -10,9 +11,12 @@ const GAMES = "games";
 const BY_SCOPE = "scope";
 // tells the page's other tabs about each change.
 const CHANNEL = "arcadible-saves";
-// every save is a guest's for One; a signed-in player's sit beside them
-// later, under their own id, with no migration.
+// a guest's saves; a signed-in player's sit beside them, under their id in
+// the game, so each player's are their own on a device they share.
 const GUEST = "guest";
+// the guest's id in a game is kept in the game's row for no channel, since
+// it's the same in every one: no real channel is empty.
+const NO_CHANNEL = "";
 // after a failed reopen, how long calls fail at once before it's tried again,
 // so a game saving every frame doesn't try, and fail, every frame.
 const REOPEN_WAIT = 1000;
@@ -161,6 +165,59 @@ export function indexedDBBackend(options = {}) {
             return again ? op(again) : otherwise();
         }
     };
+    // A signed-in player with no saves of a game on this device takes the
+    // guest's: what they played before signing in is theirs, and the guest
+    // starts again. With saves of their own (or once they've had any, a
+    // revision), theirs are used and the guest's stay the guest's. One
+    // transaction, so two tabs can't both take them; once for each game and
+    // channel, before anything reads or writes them.
+    const taken = new Map();
+    const take = async function (db, scope) {
+        const tx = db.transaction([SAVES, GAMES], "readwrite");
+        const saves = tx.objectStore(SAVES);
+        const games = tx.objectStore(GAMES);
+        const own = [player, scope.game, scope.channel];
+        const guest = [GUEST, scope.game, scope.channel];
+        const [mine, row, theirs, guestRow] = await Promise.all([
+            settle(saves.index(BY_SCOPE).count(IDBKeyRange.only(own))),
+            settle(games.get(own)),
+            settle(saves.index(BY_SCOPE).getAll(IDBKeyRange.only(guest))),
+            settle(games.get(guest)),
+        ]);
+        const had = (row?.revision ?? 0) > 0;
+        if (mine === 0 && !had && theirs.length > 0) {
+            for (const stored of theirs) {
+                saves.put({ ...stored, player });
+                saves.delete([...guest, stored.name]);
+            }
+            // the player's counter carries on from the guest's, so each save's
+            // revision still orders it.
+            games.put({
+                ...(row ?? {
+                    player,
+                    game: scope.game,
+                    channel: scope.channel,
+                }),
+                revision: guestRow?.revision ?? 0,
+            });
+        }
+        await finish(tx);
+    };
+    const mine = function (db, scope) {
+        if (player === GUEST)
+            return Promise.resolve();
+        const key = keyOf(scope);
+        let done = taken.get(key);
+        if (!done) {
+            done = take(db, scope).catch((err) => {
+                // not kept, so the next call tries again.
+                taken.delete(key);
+                throw err;
+            });
+            taken.set(key, done);
+        }
+        return done;
+    };
     database().catch(() => undefined);
     const broadcast = typeof BroadcastChannel === "undefined"
         ? null
@@ -220,6 +277,7 @@ export function indexedDBBackend(options = {}) {
         status: () => status,
         list(scope) {
             return run(async (db) => {
+                await mine(db, scope);
                 const tx = db.transaction(SAVES, "readonly");
                 const all = await settle(tx.objectStore(SAVES).index(BY_SCOPE).getAll(rangeOf(scope)));
                 return all.map(toRecord);
@@ -227,6 +285,7 @@ export function indexedDBBackend(options = {}) {
         },
         get(scope, name) {
             return run(async (db) => {
+                await mine(db, scope);
                 const tx = db.transaction(SAVES, "readonly");
                 const stored = await settle(tx
                     .objectStore(SAVES)
@@ -235,13 +294,17 @@ export function indexedDBBackend(options = {}) {
             }, () => fallback.get(scope, name));
         },
         async change(scope, name, decide, source) {
-            const result = await run((db) => change(db, scope, name, decide), () => fallback.change(scope, name, decide, source));
+            const result = await run(async (db) => {
+                await mine(db, scope);
+                return change(db, scope, name, decide);
+            }, () => fallback.change(scope, name, decide, source));
             if (result)
                 tell(scope, result, source);
             return result;
         },
         touch(scope, at) {
             return run(async (db) => {
+                await mine(db, scope);
                 const tx = db.transaction(GAMES, "readwrite");
                 const games = tx.objectStore(GAMES);
                 const key = [player, scope.game, scope.channel];
@@ -253,6 +316,23 @@ export function indexedDBBackend(options = {}) {
                 return finish(tx);
             }, () => fallback.touch(scope, at));
         },
+        guest(game) {
+            return run(async (db) => {
+                // read and made in one transaction, so two tabs agree on it.
+                const tx = db.transaction(GAMES, "readwrite");
+                const games = tx.objectStore(GAMES);
+                const key = [GUEST, game, NO_CHANNEL];
+                const row = (await settle(games.get(key)));
+                if (row && isId(row.id)) {
+                    await finish(tx);
+                    return row.id;
+                }
+                const id = newId();
+                games.put({ player: GUEST, game, channel: NO_CHANNEL, id });
+                await finish(tx);
+                return id;
+            }, () => fallback.guest(game));
+        },
         subscribe(scope, listener) {
             return listeners.add(keyOf(scope), listener);
         },

package/dist/saves/backend/memory.js

@@ -1,4 +1,5 @@
 // [import]
+import { newId } from "../../players/rules.js";
 import { listenersByKey } from "./listeners.js";
 // [function]
 function keyOf(scope) {
@@ -11,6 +12,7 @@ function keyOf(scope) {
 // device's with `device`.
 export function memoryBackend({ status = "memory", } = {}) {
     const games = new Map();
+    const guests = new Map();
     const listeners = listenersByKey();
     const gameOf = function (scope) {
         const key = keyOf(scope);
@@ -46,6 +48,11 @@ export function memoryBackend({ status = "memory", } = {}) {
         touch: async (scope, at) => {
             gameOf(scope).usedAt = at;
         },
+        guest: async (game) => {
+            const id = guests.get(game) ?? newId();
+            guests.set(game, id);
+            return id;
+        },
         subscribe: (scope, listener) => listeners.add(keyOf(scope), listener),
         used: (scope) => games.get(keyOf(scope))?.usedAt,
     };

package/dist/saves/backend/types.d.ts

@@ -23,5 +23,6 @@ export interface Backend {
     get(scope: Scope, name: string): Promise<SaveRecord | null>;
     change(scope: Scope, name: string, decide: (saves: SaveRecord[]) => NewRecord | null, source: string): Promise<Change | null>;
     touch(scope: Scope, at: string): Promise<void>;
+    guest(game: string): Promise<string>;
     subscribe(scope: Scope, listener: (change: Change, source: string) => void): () => void;
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.5.1";
+export declare const VERSION = "1.5.2-next.0";

package/dist/version.js

@@ -1,3 +1,3 @@
 // The client's version, sent in its hello and shown as `arcadible.version`,
 // for bug reports. It matches package.json (test/unit/protocol.test.ts).
-export const VERSION = "1.5.1";
+export const VERSION = "1.5.2-next.0";

package/package.json

@@ -43,5 +43,5 @@
   ],
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.5.1"
+  "version": "1.5.2-next.0"
 }