@nano133/nanoterra 0.10.1 → 0.12.0

package/dist/admin-signin/adapters/d1.js

@@ -0,0 +1,161 @@
+// The admin sign-in's store for a game on Cloudflare D1, on the game starter's OWN tables and columns: `signin_requests` and `sessions` (their admin
+// rows, scope = 'admin') and `admin_logins`. A starter moves onto it with no migration, and every creator who is signed in to /admin stays signed in.
+// A new game adds ./d1.sql to its migrations ("@nano133/nanoterra/admin-signin/d1.sql": the same tables, `IF NOT EXISTS`). The owner's passkeys (since
+// 0.12.0) use two more tables, `admin_passkeys` and `admin_once` (the end of d1.sql): only a game that turns the passkeys on needs them.
+//
+//   import { createD1AdminSignin } from "@nano133/nanoterra/admin-signin/d1";
+//   const store = createD1AdminSignin(env.DB);
+//
+// It reads and writes ONLY the admin's rows (scope = 'admin'): a game whose players sign in through the same tables (the player sign-in's scope 'play')
+// keeps its rows, and this adapter never reads, delivers, ends or deletes one. D1 has no transaction that reads and then writes, so each change is ONE
+// statement that holds its own check, and a delivery and its session are one batch (the session is written only when the delivery changed a row).
+// "Sign out everywhere" is the same two statements as the admin store's (`createD1Store(db, { logins: true })`): either one may run it.
+import { ADMIN_LOGIN_KEEP_MS, ADMIN_PASSKEY_LIMIT, ADMIN_WAYS } from "../types.js";
+const toRequest = (r) => ({
+    id: r.rid ?? r.id,
+    starter: r.starter,
+    status: r.status === "signedin" ? "signedin" : "waiting",
+    expiresAt: Number(r.expires_at),
+    ...(r.label ? { label: r.label } : {}),
+    ...(r.nonce ? { nonce: r.nonce } : {}),
+    ...(r.issued_at ? { issuedAt: Number(r.issued_at) } : {}),
+    ...(r.account ? { account: r.account } : {}),
+});
+const NAME = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
+const changes = (res) => Number(res?.meta?.changes ?? 0);
+/** True for D1's (and SQLite's) "no such table": a game that has not added the passkeys' tables. */
+const noTable = (e) => /no such table/i.test(String(e?.message ?? e));
+export function createD1AdminSignin(db, tables = {}) {
+    const T = {
+        requests: tables.requests ?? "signin_requests",
+        sessions: tables.sessions ?? "sessions",
+        logins: tables.logins ?? "admin_logins",
+        passkeys: tables.passkeys ?? "admin_passkeys",
+        once: tables.once ?? "admin_once",
+    };
+    for (const n of Object.values(T))
+        if (!NAME.test(n))
+            throw new Error(`not a table name: ${n}`);
+    const COLS = "id, rid, starter, status, expires_at, nonce, issued_at, label, account";
+    const stores = new Map();
+    for (const way of ADMIN_WAYS) {
+        stores.set(way, {
+            async create(key, r) {
+                // The starter's own insert: `scope` is written when the request is created, so a request started for the admin is the admin's for good.
+                await db
+                    .prepare(`INSERT INTO ${T.requests} (id, rid, way, starter, status, expires_at, nonce, issued_at, label, scope) VALUES (?, ?, ?, ?, 'waiting', ?, ?, ?, ?, 'admin')`)
+                    .bind(key, r.id, way, r.starter, r.expiresAt, r.nonce ?? null, r.issuedAt ?? null, r.label ?? null)
+                    .run();
+            },
+            async get(key) {
+                const r = await db.prepare(`SELECT ${COLS} FROM ${T.requests} WHERE id = ? AND way = ? AND scope = 'admin'`).bind(key, way).first();
+                return r ? toRequest(r) : null;
+            },
+            async find(id) {
+                const r = await db.prepare(`SELECT ${COLS} FROM ${T.requests} WHERE rid = ? AND way = ? AND scope = 'admin'`).bind(id, way).first();
+                return r ? { key: r.id, request: toRequest(r) } : null;
+            },
+            async finish(key, account) {
+                return changes(await db.prepare(`UPDATE ${T.requests} SET status = 'signedin', account = ? WHERE id = ? AND way = ? AND status = 'waiting' AND scope = 'admin'`).bind(account, key, way).run()) === 1;
+            },
+        });
+    }
+    return {
+        requests: (way) => {
+            const s = stores.get(way);
+            if (!s)
+                throw new Error(`no such way: ${String(way)}`);
+            return s;
+        },
+        async deliver(way, key, s) {
+            // The starter's batch: the delivery, and the session only when the delivery changed a row.
+            const done = await db.batch([
+                db.prepare(`UPDATE ${T.requests} SET delivered = 1 WHERE id = ? AND way = ? AND delivered = 0 AND status = 'signedin' AND scope = 'admin'`).bind(key, way),
+                db.prepare(`INSERT INTO ${T.sessions} (id_hash, address, created_at, expires_at, via, scope) SELECT ?, ?, ?, ?, ?, 'admin' WHERE changes() = 1`).bind(s.idHash, s.address, s.createdAt, s.expiresAt, s.via),
+            ]);
+            return changes(done[0]) === 1;
+        },
+        async session(idHash, now) {
+            const r = await db
+                .prepare(`SELECT id_hash, address, created_at, expires_at, via FROM ${T.sessions} WHERE id_hash = ? AND expires_at > ? AND scope = 'admin'`)
+                .bind(idHash, now)
+                .first();
+            return r ? { idHash: r.id_hash, address: r.address, createdAt: Number(r.created_at), expiresAt: Number(r.expires_at), via: String(r.via) } : null;
+        },
+        async endSession(idHash) {
+            await db.prepare(`DELETE FROM ${T.sessions} WHERE id_hash = ? AND scope = 'admin'`).bind(idHash).run();
+        },
+        async signOutEverywhere() {
+            const done = await db.batch([
+                db.prepare(`DELETE FROM ${T.sessions} WHERE scope = 'admin'`),
+                db.prepare(`UPDATE ${T.requests} SET delivered = 1, expires_at = 0 WHERE scope = 'admin' AND delivered = 0`),
+            ]);
+            return changes(done[0]);
+        },
+        async recordLogin(login) {
+            await db.batch([
+                db.prepare(`INSERT INTO ${T.logins} (at, country, browser) VALUES (?, ?, ?)`).bind(login.at, login.country, login.browser),
+                db.prepare(`DELETE FROM ${T.logins} WHERE at < ?`).bind(login.at - ADMIN_LOGIN_KEEP_MS),
+            ]);
+        },
+        async recentLogins(limit) {
+            const n = Math.min(Math.max(Math.floor(Number(limit)) || 0, 0), 50);
+            const rows = (await db.prepare(`SELECT at, country, browser FROM ${T.logins} ORDER BY at DESC, id DESC LIMIT ?`).bind(n).all()).results;
+            return rows.map((r) => ({ at: Number(r.at), country: r.country, browser: r.browser }));
+        },
+        async clean(now) {
+            // The starter's clean-up of its admin rows (its `cleanUp`, without the game's own `hits`).
+            await db.batch([
+                db.prepare(`DELETE FROM ${T.requests} WHERE expires_at < ? AND scope = 'admin'`).bind(now - 2 * 3_600_000),
+                db.prepare(`DELETE FROM ${T.sessions} WHERE expires_at < ? AND scope = 'admin'`).bind(now),
+                db.prepare(`DELETE FROM ${T.logins} WHERE at < ?`).bind(now - ADMIN_LOGIN_KEEP_MS),
+            ]);
+            // The used passkey signatures, on their own: a game without the passkeys' tables (they came in 0.12.0) still cleans the rest.
+            try {
+                await db.prepare(`DELETE FROM ${T.once} WHERE until <= ?`).bind(now).run();
+            }
+            catch (e) {
+                if (!noTable(e))
+                    throw e;
+            }
+        },
+        async createSession(s) {
+            await db.prepare(`INSERT INTO ${T.sessions} (id_hash, address, created_at, expires_at, via, scope) VALUES (?, ?, ?, ?, ?, 'admin')`).bind(s.idHash, s.address, s.createdAt, s.expiresAt, s.via).run();
+        },
+        async linkPasskey(owner, address, at) {
+            // ONE statement holds the limit: the row is written only while the owner has fewer than the limit, and never twice.
+            const res = await db
+                .prepare(`INSERT INTO ${T.passkeys} (owner, address, created_at) SELECT ?, ?, ? WHERE (SELECT COUNT(*) FROM ${T.passkeys} WHERE owner = ?) < ? ON CONFLICT (owner, address) DO NOTHING`)
+                .bind(owner, address, at, owner, ADMIN_PASSKEY_LIMIT)
+                .run();
+            if (changes(res) === 1)
+                return "linked";
+            const had = await db.prepare(`SELECT 1 AS one FROM ${T.passkeys} WHERE owner = ? AND address = ?`).bind(owner, address).first();
+            return had ? "exists" : "full";
+        },
+        async unlinkPasskey(owner, address) {
+            // The link, and the passkey's admin sessions with it.
+            const done = await db.batch([
+                db.prepare(`DELETE FROM ${T.passkeys} WHERE owner = ? AND address = ?`).bind(owner, address),
+                db.prepare(`DELETE FROM ${T.sessions} WHERE scope = 'admin' AND via = 'passkey' AND address = ?`).bind(address),
+            ]);
+            return changes(done[0]) > 0;
+        },
+        async passkeys(owner) {
+            const rows = (await db.prepare(`SELECT address, created_at FROM ${T.passkeys} WHERE owner = ? ORDER BY created_at, address`).bind(owner).all()).results;
+            return rows.map((r) => ({ address: String(r.address), createdAt: Number(r.created_at) }));
+        },
+        async linked(owner, address) {
+            return (await db.prepare(`SELECT 1 AS one FROM ${T.passkeys} WHERE owner = ? AND address = ?`).bind(owner, address).first()) !== null;
+        },
+        async useOnce(key, ttlMs) {
+            const now = Date.now();
+            // A row past its time may be taken again (its signature's window is long over); a live one may not.
+            const res = await db
+                .prepare(`INSERT INTO ${T.once} (key, until) VALUES (?, ?) ON CONFLICT (key) DO UPDATE SET until = excluded.until WHERE ${T.once}.until <= ?`)
+                .bind(key, now + ttlMs, now)
+                .run();
+            return changes(res) === 1;
+        },
+    };
+}

package/dist/admin-signin/adapters/firestore.d.ts

@@ -0,0 +1,52 @@
+import { type AdminSigninStore } from "../types.js";
+export type AdminSigninDocSnap = {
+    exists: boolean;
+    data(): Record<string, unknown> | undefined;
+};
+export interface AdminSigninDocRef {
+    get(): Promise<AdminSigninDocSnap>;
+}
+export type AdminSigninQuerySnap = {
+    docs: {
+        id: string;
+        ref: AdminSigninDocRef;
+        data(): Record<string, unknown>;
+    }[];
+};
+export interface AdminSigninQuery {
+    where(field: string, op: "==" | "<", value: unknown): AdminSigninQuery;
+    orderBy(field: string, direction?: "asc" | "desc"): AdminSigninQuery;
+    limit(n: number): AdminSigninQuery;
+    get(): Promise<AdminSigninQuerySnap>;
+}
+export interface AdminSigninCollection extends AdminSigninQuery {
+    doc(id: string): AdminSigninDocRef;
+}
+/** A transaction: every read before the first write, as Firestore asks. */
+export interface AdminSigninTransaction {
+    get(ref: AdminSigninDocRef): Promise<AdminSigninDocSnap>;
+    set(ref: AdminSigninDocRef, data: Record<string, unknown>, options?: {
+        merge?: boolean;
+    }): unknown;
+    delete(ref: AdminSigninDocRef): unknown;
+}
+export interface AdminSigninBatch {
+    set(ref: AdminSigninDocRef, data: Record<string, unknown>, options?: {
+        merge?: boolean;
+    }): unknown;
+    delete(ref: AdminSigninDocRef): unknown;
+    commit(): Promise<unknown>;
+}
+export interface FirestoreAdminSigninLike {
+    collection(name: string): AdminSigninCollection;
+    runTransaction<T>(fn: (tx: AdminSigninTransaction) => Promise<T>): Promise<T>;
+    batch(): AdminSigninBatch;
+}
+export type FirestoreAdminSigninCollections = {
+    requests?: string;
+    sessions?: string;
+    logins?: string;
+    passkeys?: string;
+    once?: string;
+};
+export declare function createFirestoreAdminSignin(db: FirestoreAdminSigninLike, collections?: FirestoreAdminSigninCollections): Required<AdminSigninStore>;

package/dist/admin-signin/adapters/firestore.js

@@ -0,0 +1,248 @@
+// The admin sign-in's store for a game on Firestore (the Admin SDK). The package has no Firebase dependency: the adapter uses the small interface
+// below, which the Admin SDK's `Firestore` fits. It reads and writes ONLY its three collections, and only the admin's documents (scope "admin") of the
+// first two: the player sign-in's Firestore adapter keeps its own (scope "play") in the same collections.
+//
+//   import { createFirestoreAdminSignin } from "@nano133/nanoterra/admin-signin/firestore";
+//   const store = createFirestoreAdminSignin(getFirestore());
+//
+// The data model (the three collection names can be changed):
+//   signin_requests/{key}   { id, way, starter, status, expiresAt, nonce?, issuedAt?, label?, account?, delivered, scope: "admin", deleteAt }
+//   sessions/{idHash}       { address, createdAt, expiresAt, via, scope: "admin", deleteAt }
+//   admin_logins/{id}       { at, country, browser, deleteAt }
+//   admin_passkeys/{owner}  { owner, passkeys: [{ address, createdAt }] }      (since 0.12.0: the owner's linked passkeys, at most 10; no deleteAt)
+//   admin_once/{key}        { until, deleteAt }                                (since 0.12.0: the passkeys' used signatures)
+// Times are ms numbers; `deleteAt` is a Date (a Timestamp in Firestore): set a TTL policy on `deleteAt` for each collection that has it. `{key}` is the
+// request's id; `{idHash}` the SHA-256 of "admin:" and the session's token. Every change that reads first is a transaction (the owner's passkeys are ONE
+// document, so a link holds the limit in its transaction). Indexes: Firestore's own single-field indexes are enough (`id`, `scope`, `expiresAt`, `at`,
+// `address`, `until`).
+//
+// The admin store for Firestore (`createFirestoreStore`) has no sign-in list and no "Sign out everywhere": give it this sign-in's,
+// `store.recentLogins = signin.recentLogins` and `store.signOutEverywhere = signin.signOutEverywhere`.
+import { ADMIN_LOGIN_KEEP_MS, ADMIN_PASSKEY_LIMIT, ADMIN_WAYS } from "../types.js";
+const DAY = 86_400_000;
+/** At most this many documents go in one batch (Firestore's limit is 500). */
+const BATCH = 400;
+const text = (v) => (typeof v === "string" ? v : undefined);
+const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : undefined);
+const hex = (bytes) => Array.from(crypto.getRandomValues(new Uint8Array(bytes)), (x) => x.toString(16).padStart(2, "0")).join("");
+function requestOf(d, key, way) {
+    if (!d || d.scope !== "admin" || d.way !== way || typeof d.starter !== "string" || num(d.expiresAt) === undefined)
+        return null;
+    const nonce = text(d.nonce);
+    const issuedAt = num(d.issuedAt);
+    const label = text(d.label);
+    const account = text(d.account);
+    return {
+        id: text(d.id) ?? key,
+        starter: d.starter,
+        status: d.status === "signedin" ? "signedin" : "waiting",
+        expiresAt: num(d.expiresAt),
+        ...(label !== undefined ? { label } : {}),
+        ...(nonce !== undefined ? { nonce } : {}),
+        ...(issuedAt !== undefined ? { issuedAt } : {}),
+        ...(account !== undefined ? { account } : {}),
+    };
+}
+/** The links a passkeys document holds: only well-formed ones. */
+function linksOf(d) {
+    const list = Array.isArray(d?.passkeys) ? d.passkeys : [];
+    return list.flatMap((p) => {
+        const v = p;
+        const address = text(v?.address);
+        return address !== undefined ? [{ address, createdAt: num(v?.createdAt) ?? 0 }] : [];
+    });
+}
+export function createFirestoreAdminSignin(db, collections = {}) {
+    const requestsCol = () => db.collection(collections.requests ?? "signin_requests");
+    const sessionsCol = () => db.collection(collections.sessions ?? "sessions");
+    const loginsCol = () => db.collection(collections.logins ?? "admin_logins");
+    const passkeysCol = () => db.collection(collections.passkeys ?? "admin_passkeys");
+    const onceCol = () => db.collection(collections.once ?? "admin_once");
+    const sessionData = (s) => ({ address: s.address, createdAt: s.createdAt, expiresAt: s.expiresAt, via: s.via, scope: "admin", deleteAt: new Date(s.expiresAt) });
+    const stores = new Map();
+    for (const way of ADMIN_WAYS) {
+        stores.set(way, {
+            async create(key, r) {
+                const ref = requestsCol().doc(key);
+                await db.runTransaction(async (tx) => {
+                    if ((await tx.get(ref)).exists)
+                        throw new Error("a request with this key exists");
+                    tx.set(ref, {
+                        id: r.id,
+                        way,
+                        starter: r.starter,
+                        status: "waiting",
+                        expiresAt: r.expiresAt,
+                        ...(r.nonce !== undefined ? { nonce: r.nonce } : {}),
+                        ...(r.issuedAt !== undefined ? { issuedAt: r.issuedAt } : {}),
+                        ...(r.label !== undefined ? { label: r.label } : {}),
+                        delivered: false,
+                        scope: "admin",
+                        deleteAt: new Date(r.expiresAt + DAY),
+                    });
+                });
+            },
+            async get(key) {
+                return requestOf((await requestsCol().doc(key).get()).data(), key, way);
+            },
+            async find(id) {
+                for (const d of (await requestsCol().where("id", "==", id).limit(10).get()).docs) {
+                    const request = requestOf(d.data(), d.id, way);
+                    if (request)
+                        return { key: d.id, request };
+                }
+                return null;
+            },
+            async finish(key, account) {
+                const ref = requestsCol().doc(key);
+                return db.runTransaction(async (tx) => {
+                    const cur = requestOf((await tx.get(ref)).data(), key, way);
+                    if (!cur || cur.status !== "waiting")
+                        return false;
+                    tx.set(ref, { status: "signedin", account }, { merge: true });
+                    return true;
+                });
+            },
+        });
+    }
+    async function deleteAll(docs) {
+        for (let i = 0; i < docs.length; i += BATCH) {
+            const b = db.batch();
+            for (const d of docs.slice(i, i + BATCH))
+                b.delete(d.ref);
+            await b.commit();
+        }
+        return docs.length;
+    }
+    return {
+        requests: (way) => {
+            const s = stores.get(way);
+            if (!s)
+                throw new Error(`no such way: ${String(way)}`);
+            return s;
+        },
+        async deliver(way, key, session) {
+            const ref = requestsCol().doc(key);
+            const sref = sessionsCol().doc(session.idHash);
+            return db.runTransaction(async (tx) => {
+                const raw = (await tx.get(ref)).data();
+                const cur = requestOf(raw, key, way);
+                await tx.get(sref);
+                if (!cur || cur.status !== "signedin" || raw?.delivered === true)
+                    return false;
+                tx.set(ref, { delivered: true }, { merge: true });
+                tx.set(sref, sessionData(session));
+                return true;
+            });
+        },
+        async session(idHash, now) {
+            const d = (await sessionsCol().doc(idHash).get()).data();
+            if (!d || d.scope !== "admin" || typeof d.address !== "string")
+                return null;
+            const expiresAt = num(d.expiresAt);
+            if (expiresAt === undefined || expiresAt <= now)
+                return null;
+            return { idHash, address: d.address, createdAt: num(d.createdAt) ?? 0, expiresAt, via: String(d.via ?? "") };
+        },
+        async endSession(idHash) {
+            const ref = sessionsCol().doc(idHash);
+            await db.runTransaction(async (tx) => {
+                const d = (await tx.get(ref)).data();
+                if (d && d.scope === "admin")
+                    tx.delete(ref);
+            });
+        },
+        async signOutEverywhere() {
+            // The requests first, then the sessions are read: a delivery that ran before the requests were ended wrote its session already, and it goes too; a
+            // delivery after it finds its request delivered (its transaction runs again on the changed document) and writes none.
+            const pending = (await requestsCol().where("scope", "==", "admin").get()).docs.filter((d) => d.data().delivered !== true);
+            for (let i = 0; i < pending.length; i += BATCH) {
+                const b = db.batch();
+                for (const d of pending.slice(i, i + BATCH))
+                    b.set(d.ref, { delivered: true, expiresAt: 0 }, { merge: true });
+                await b.commit();
+            }
+            return deleteAll((await sessionsCol().where("scope", "==", "admin").get()).docs);
+        },
+        async recordLogin(login) {
+            const old = (await loginsCol().where("at", "<", login.at - ADMIN_LOGIN_KEEP_MS).limit(BATCH).get()).docs;
+            const b = db.batch();
+            b.set(loginsCol().doc(`${String(login.at).padStart(15, "0")}-${hex(8)}`), { at: login.at, country: login.country, browser: login.browser, deleteAt: new Date(login.at + ADMIN_LOGIN_KEEP_MS) });
+            for (const d of old)
+                b.delete(d.ref);
+            await b.commit();
+        },
+        async recentLogins(limit) {
+            const n = Math.min(Math.max(Math.floor(Number(limit)) || 0, 0), 50);
+            if (!n)
+                return [];
+            // Newest first; two at the same time come in the order of their ids (the time, then random letters).
+            const docs = (await loginsCol().orderBy("at", "desc").limit(n).get()).docs;
+            return docs.map((d) => {
+                const v = d.data();
+                return { at: num(v.at) ?? 0, country: text(v.country) ?? null, browser: text(v.browser) ?? "Unknown browser" };
+            });
+        },
+        async clean(now) {
+            const old = (await requestsCol().where("expiresAt", "<", now - 2 * 3_600_000).limit(BATCH).get()).docs.filter((d) => d.data().scope === "admin");
+            const ended = (await sessionsCol().where("expiresAt", "<", now).limit(BATCH).get()).docs.filter((d) => d.data().scope === "admin");
+            const logins = (await loginsCol().where("at", "<", now - ADMIN_LOGIN_KEEP_MS).limit(BATCH).get()).docs;
+            const used = (await onceCol().where("until", "<", now + 1).limit(BATCH).get()).docs;
+            await deleteAll([...old, ...ended, ...logins, ...used]);
+        },
+        async createSession(session) {
+            const ref = sessionsCol().doc(session.idHash);
+            await db.runTransaction(async (tx) => {
+                if ((await tx.get(ref)).exists)
+                    throw new Error("a session with this id exists");
+                tx.set(ref, sessionData(session));
+            });
+        },
+        async linkPasskey(owner, address, at) {
+            const ref = passkeysCol().doc(owner);
+            return db.runTransaction(async (tx) => {
+                const d = (await tx.get(ref)).data();
+                const list = d && d.owner === owner ? linksOf(d) : [];
+                if (list.some((p) => p.address === address))
+                    return "exists";
+                if (list.length >= ADMIN_PASSKEY_LIMIT)
+                    return "full";
+                tx.set(ref, { owner, passkeys: [...list, { address, createdAt: at }] });
+                return "linked";
+            });
+        },
+        async unlinkPasskey(owner, address) {
+            const ref = passkeysCol().doc(owner);
+            const had = await db.runTransaction(async (tx) => {
+                const d = (await tx.get(ref)).data();
+                const list = d && d.owner === owner ? linksOf(d) : [];
+                if (!list.some((p) => p.address === address))
+                    return false;
+                tx.set(ref, { owner, passkeys: list.filter((p) => p.address !== address) });
+                return true;
+            });
+            // The passkey's admin sessions end with its link (after it: a session read in between finds no link and is refused anyway).
+            await deleteAll((await sessionsCol().where("address", "==", address).get()).docs.filter((x) => x.data().scope === "admin" && x.data().via === "passkey"));
+            return had;
+        },
+        async passkeys(owner) {
+            const d = (await passkeysCol().doc(owner).get()).data();
+            return d && d.owner === owner ? linksOf(d) : [];
+        },
+        async linked(owner, address) {
+            const d = (await passkeysCol().doc(owner).get()).data();
+            return Boolean(d && d.owner === owner && linksOf(d).some((p) => p.address === address));
+        },
+        async useOnce(key, ttlMs) {
+            const ref = onceCol().doc(key);
+            return db.runTransaction(async (tx) => {
+                const now = Date.now();
+                const d = (await tx.get(ref)).data();
+                if (d && (num(d.until) ?? Infinity) > now)
+                    return false;
+                tx.set(ref, { until: now + ttlMs, deleteAt: new Date(now + ttlMs) });
+                return true;
+            });
+        },
+    };
+}

package/dist/admin-signin/browser.d.ts

@@ -0,0 +1,4 @@
+/** "Chrome on macOS", "Safari on iOS", "Firefox", or "Unknown browser". At most 40 characters, only from the lists above. */
+export declare function shortBrowser(userAgent: string | null | undefined): string;
+/** The rough country of a request: Cloudflare's two-letter country header, or null (not there, "XX" for unknown, "T1" for Tor, or anything that is not two capital letters). */
+export declare function countryOf(req: Request): string | null;

package/dist/admin-signin/browser.js

@@ -0,0 +1,36 @@
+// What the admin's sign-in list keeps of a browser: a short name made from fixed lists ("Chrome on macOS") and the rough country. The game starter's
+// src/worker/browser.ts, unchanged. It NEVER returns any of the browser's own text, so a hostile browser text cannot put anything in the list, and only
+// this name is kept (never the browser text itself).
+const BROWSERS = [
+    [/\bEdg(?:e|A|iOS)?\//, "Edge"],
+    [/\bOPR\/|\bOpera\b/, "Opera"],
+    [/\bSamsungBrowser\//, "Samsung Internet"],
+    [/\bFirefox\/|\bFxiOS\//, "Firefox"],
+    [/\bChrome\/|\bCriOS\//, "Chrome"],
+    [/\bSafari\//, "Safari"],
+];
+const SYSTEMS = [
+    [/\biPhone\b|\biPad\b|\biPod\b/, "iOS"],
+    [/\bAndroid\b/, "Android"],
+    [/\bCrOS\b/, "ChromeOS"],
+    [/\bWindows\b/, "Windows"],
+    [/\bMac OS X\b|\bMacintosh\b/, "macOS"],
+    [/\bLinux\b|\bX11\b/, "Linux"],
+];
+/** "Chrome on macOS", "Safari on iOS", "Firefox", or "Unknown browser". At most 40 characters, only from the lists above. */
+export function shortBrowser(userAgent) {
+    if (typeof userAgent !== "string" || !userAgent)
+        return "Unknown browser";
+    // Only the start of the text is read: a long text cannot make the matching slow.
+    const ua = userAgent.slice(0, 400);
+    const browser = BROWSERS.find(([re]) => re.test(ua))?.[1];
+    const system = SYSTEMS.find(([re]) => re.test(ua))?.[1];
+    if (!browser && !system)
+        return "Unknown browser";
+    return `${browser ?? "Browser"}${system ? ` on ${system}` : ""}`;
+}
+/** The rough country of a request: Cloudflare's two-letter country header, or null (not there, "XX" for unknown, "T1" for Tor, or anything that is not two capital letters). */
+export function countryOf(req) {
+    const c = req.headers.get("CF-IPCountry");
+    return typeof c === "string" && /^[A-Z]{2}$/.test(c) && c !== "XX" && c !== "T1" ? c : null;
+}

package/dist/admin-signin/conformance.d.ts

@@ -0,0 +1,18 @@
+import type { AdminSigninStore } from "./types.js";
+export type AdminSigninHarness = {
+    store: AdminSigninStore;
+    /** Every row the store keeps (requests, sessions, the sign-in list) as one text. */
+    dump(): Promise<string>;
+};
+export type AdminSigninConformanceCase = {
+    name: string;
+    run: () => Promise<void>;
+};
+export type AdminSigninConformanceOptions = {
+    /**
+     * The owner's passkeys (the store's optional passkey methods). true: the cases run and the store must have them. false: no passkey case. Not set: the
+     * cases are listed, and a store with no `linkPasskey` passes them with nothing to check (a store written for 0.11.0).
+     */
+    passkeys?: boolean;
+};
+export declare function adminSigninStoreConformance(make: () => Promise<AdminSigninHarness>, options?: AdminSigninConformanceOptions): AdminSigninConformanceCase[];