@nano133/nanoterra 0.8.1 → 0.9.3

package/dist/player-signin/panel/view.js

@@ -0,0 +1,363 @@
+// The player's sign-in, ready to put in a sheet: `signInView(options)` gives { node, stop, reset }. Plain DOM, no framework, no browser dialog.
+//
+//   1. The ways: "Use a passkey" first (Face ID, Touch ID or the device PIN), then the wallet apps as tiles. A browser that reports no passkey PRF
+//      shows the passkey last, with "Not on this browser".
+//   2. The passkey: "Use my passkey" and "Make a passkey" (the main key is "Use" when this browser made or used one before). A new passkey is made,
+//      then used at once (its seed comes from a USE, never from the answer at create: @nano133/signin/passkey); where the browser allows one prompt
+//      per press, one key "Open my passkey" finishes it. A NEW account then shows "Keep a spare key" (it can be skipped, not missed). The purse signs
+//      the game's sign-in text in the page (@nano133/signin/purse, loaded only then) and the server checks it ({base}/passkey).
+//   3. A wallet app: on a touch screen one key that opens the app; with a mouse its QR code (the game's `qr` hook) for the phone. The page asks every
+//      2 seconds until the wallet has signed (5 minutes at most).
+//
+// The seed lives in local variables of one sign-in only: never in storage, a log, an error text or an address. The page remembers only the passkeys'
+// ids and the last way (./memo.ts).
+//
+// `words` changes any word of the sheet (./words.ts: PLAYER_SIGNIN_WORDS are the defaults), for a game's own words or language.
+import { firstUse, makePasskey, openPasskey, PasskeyError, passkeyFault, passkeySupport } from "@nano133/signin/passkey";
+import { ApiError, createApi } from "../../admin/panel/api.js";
+import { h, shortAddress } from "../../admin/panel/dom.js";
+import { icon } from "../../admin/panel/icons.js";
+import { checkScheme } from "../scheme-check.js";
+import { previewHost } from "../host.js";
+import { WAYS } from "../types.js";
+import { readMemo, rememberLast, rememberMade, rememberOpened } from "./memo.js";
+import { faultWords, playerSigninWords } from "./words.js";
+/** The wallets, with letters, not logos: no wallet's licence clearly allows its logo. */
+const WALLETS = {
+    berry: { name: "Berry Wallet", mark: "B" },
+    nanchat: { name: "NanChat", mark: "NC" },
+    nautilus: { name: "Nautilus", mark: "N" },
+};
+const NS = "http://www.w3.org/2000/svg";
+/** A key, the passkey's mark (drawn here: the shared icons have none). */
+function keyIcon(size = 26) {
+    const svg = document.createElementNS(NS, "svg");
+    for (const [k, v] of Object.entries({ viewBox: "0 0 24 24", width: size, height: size, fill: "none", stroke: "currentColor", "stroke-width": 1.9, "stroke-linecap": "round", "stroke-linejoin": "round", "aria-hidden": "true", focusable: "false" }))
+        svg.setAttribute(k, String(v));
+    for (const d of ["M14.5 9.5a4.5 4.5 0 1 1-1.3-3.2", "M13.2 6.3 21 6.3M18 6.3v3M21 6.3v2.2"]) {
+        const p = document.createElementNS(NS, "path");
+        p.setAttribute("d", d);
+        svg.append(p);
+    }
+    const c = document.createElementNS(NS, "circle");
+    for (const [k, v] of Object.entries({ cx: 10, cy: 9.5, r: 1.4, fill: "currentColor", stroke: "none" }))
+        c.setAttribute(k, String(v));
+    svg.append(c);
+    return svg;
+}
+/** True when the page's host may ask for a passkey of `rpId`: the same host, or a subdomain of it. An IP address never may. */
+export function hostFits(hostname, rpId) {
+    if (!hostname || /^[\d.]+$/.test(hostname) || hostname.includes(":"))
+        return false;
+    return hostname === rpId || hostname.endsWith(`.${rpId}`);
+}
+/** The passkey's name in the device's list: the game and the day it was made (the account does not exist yet). */
+export const passkeyName = (game, now = new Date()) => `${game} · ${now.toLocaleDateString("en-GB", { day: "numeric", month: "short", year: "numeric" })}`;
+export function signInView(options) {
+    const base = options.base ?? "/api/signin";
+    const api = createApi("", options.fetch ?? ((...a) => fetch(...a)));
+    const ways = (options.ways ?? WAYS).filter((w) => WAYS.includes(w));
+    const rpId = options.rpId ?? location.hostname;
+    const passkeyOn = options.passkey ?? !previewHost(rpId);
+    const scheme = passkeyOn ? checkScheme(options.scheme) : null;
+    const touch = () => options.touch ?? (typeof matchMedia === "function" && matchMedia("(pointer: coarse)").matches);
+    const w = playerSigninWords(options.words);
+    let stopped = false;
+    let timer;
+    let prompt = null;
+    /** The wallet request that is waiting. Back keeps it: the player may have approved it already. */
+    let current = null;
+    let support = "unknown";
+    const status = h("p", { class: "n133s-status", role: "status", "aria-live": "polite" });
+    const check = h("div", { class: "n133s-check" });
+    check.hidden = true;
+    const area = h("div", { class: "n133s-area" });
+    const node = h("div", { class: "n133-signin n133s-view" }, area, check, status);
+    const say = (text) => (status.textContent = text);
+    const busy = (on) => {
+        for (const b of Array.from(area.querySelectorAll("button")))
+            b.disabled = on;
+        node.toggleAttribute("aria-busy", on);
+    };
+    const key = (text, onclick, kind = "plain") => h("button", { class: `n133s-btn n133s-${kind}`, type: "button", onclick }, text);
+    const backKey = () => h("button", { class: "n133s-back", type: "button", onclick: () => showWays() }, icon("back", 18), h("span", {}, w.back));
+    const title = (text) => h("h3", { class: "n133s-step", tabindex: "-1" }, text);
+    const focusFirst = () => (area.querySelector("h3, button:not([disabled])") ?? area).focus?.({ preventScroll: true });
+    const setup = () => ({ rpId, rpName: options.name, scheme: scheme, userName: passkeyName(options.name), exclude: readMemo(rpId).ids });
+    /** Puts these in the area (a null is left out). */
+    const fill = (...parts) => area.replaceChildren(...parts.filter((p) => p !== null));
+    const personToken = async () => (options.personCheck ? options.personCheck(check) : undefined);
+    function stopWaiting() {
+        if (timer)
+            clearTimeout(timer);
+        timer = undefined;
+        prompt?.abort();
+        prompt = null;
+    }
+    function done(player) {
+        stopWaiting();
+        current = null;
+        area.replaceChildren(h("p", { class: "n133s-done" }, icon("check", 22), h("span", {}, w.signedInAs(shortAddress(player.address)))));
+        say("");
+        options.onSignedIn?.(player);
+    }
+    // ---- the ways ----
+    function passkeyTile() {
+        const off = support === "no";
+        const last = readMemo(rpId).last === "passkey";
+        return h("button", { class: `n133s-pk${off ? " is-off" : ""}`, type: "button", onclick: () => showPasskey() }, h("span", { class: "n133s-pk-mark" }, keyIcon()), h("span", { class: "n133s-pk-words" }, h("strong", {}, w.usePasskey), h("small", {}, off ? w.passkeyOff : w.passkeyHint)), last ? h("span", { class: "n133s-last" }, w.lastUsed) : null);
+    }
+    function walletTiles() {
+        const last = readMemo(rpId).last;
+        return h("div", { class: "n133s-tiles" }, ...ways.map((way) => h("button", { class: "n133s-tile", type: "button", onclick: () => choose(way) }, h("span", { class: "n133s-mark", "aria-hidden": "true" }, WALLETS[way].mark), h("span", { class: "n133s-name" }, WALLETS[way].name), last === way ? h("span", { class: "n133s-last" }, w.lastUsed) : null)));
+    }
+    function showWays() {
+        stopWaiting();
+        busy(false);
+        const pk = passkeyOn ? passkeyTile() : null;
+        const first = pk && support !== "no";
+        const walletsPart = ways.length ? [h("p", { class: "n133s-or" }, pk ? w.orWallet : w.chooseWallet), walletTiles()] : [];
+        fill(h("p", { class: "n133s-lead" }, w.lead), first ? pk : null, ...walletsPart, !first && pk ? h("p", { class: "n133s-or" }, w.orPasskey) : null, !first ? pk : null);
+        say("");
+    }
+    // ---- the passkey ----
+    function showFault(e) {
+        busy(false);
+        const f = passkeyFault(e);
+        const fw = faultWords(f.code, rpId, w);
+        if (fw.next === "stay")
+            return showPasskey(fw.text);
+        fill(backKey(), title(fw.title), h("p", { class: "n133s-text n133s-fault", "data-fault": f.code }, fw.text), ways.length ? h("p", { class: "n133s-or" }, w.faultWallets) : null, ways.length ? walletTiles() : null);
+        say("");
+        focusFirst();
+    }
+    function showPasskey(note) {
+        stopWaiting();
+        busy(false);
+        if (!scheme)
+            return showWays();
+        if (typeof window === "undefined" || !window.PublicKeyCredential)
+            return showFault({ name: "NotSupportedError" });
+        if (support === "no")
+            return showFault(new PasskeyError("no-prf"));
+        if (!hostFits(location.hostname, rpId))
+            return showFault({ name: "SecurityError" });
+        const known = readMemo(rpId).ids.length > 0;
+        const use = key(w.useMine, () => void usePasskey(), known ? "primary" : "plain");
+        const make = key(w.makeOne, () => void makeNew(), known ? "plain" : "primary");
+        area.replaceChildren(backKey(), title(w.passkeyTitle), h("p", { class: "n133s-text" }, w.passkeyText), h("div", { class: "n133s-keys" }, known ? use : make, known ? make : use));
+        say(note ?? "");
+        focusFirst();
+    }
+    async function usePasskey() {
+        busy(true);
+        say(w.waitingPasskey);
+        prompt = new AbortController();
+        try {
+            const p = await openPasskey(setup(), prompt.signal);
+            if (stopped)
+                return;
+            await finish(p.seed, p.credentialId, false);
+        }
+        catch (e) {
+            if (!stopped)
+                showFault(e);
+        }
+    }
+    async function makeNew() {
+        busy(true);
+        say(w.makingPasskey);
+        prompt = new AbortController();
+        let made;
+        try {
+            made = await makePasskey(setup(), prompt.signal);
+        }
+        catch (e) {
+            if (!stopped)
+                showFault(e);
+            return;
+        }
+        // Remembered now, before its first use: a closed sheet or a reload must not forget it.
+        rememberMade(rpId, made.credentialId);
+        if (stopped)
+            return;
+        await firstOpen(made, false);
+    }
+    /** The first use of a passkey just made. Where it gives nothing (a browser that allows one prompt per press, a closed sheet), one key finishes it. */
+    async function firstOpen(made, pick) {
+        busy(true);
+        say(w.openingPasskey);
+        prompt = new AbortController();
+        try {
+            const p = await firstUse(setup(), made, prompt.signal, pick);
+            if (stopped)
+                return;
+            await finish(p.seed, p.credentialId, true);
+        }
+        catch (e) {
+            if (stopped)
+                return;
+            const f = passkeyFault(e);
+            if (f.code !== "cancelled" && f.code !== "failed")
+                return showFault(f);
+            busy(false);
+            area.replaceChildren(title(w.madeTitle), h("p", { class: "n133s-text" }, w.madeText), h("div", { class: "n133s-keys" }, key(w.openMine, () => void firstOpen(made, true), "primary")));
+            say("");
+            focusFirst();
+        }
+    }
+    /** "Keep a spare key": the code shows only at the press, and the player goes on with Continue or Later. */
+    function spareKey(seed) {
+        return new Promise((resolve) => {
+            busy(false);
+            const code = h("p", { class: "n133s-code", translate: "no" });
+            const codeBox = h("div", { class: "n133s-codebox" }, code);
+            codeBox.hidden = true;
+            const go = key(w.later, () => resolve(), "quiet");
+            const copyBtn = key(w.copyCode, async () => {
+                try {
+                    await navigator.clipboard.writeText(seed);
+                    copyBtn.textContent = w.copied;
+                }
+                catch {
+                    copyBtn.textContent = w.copyFailed;
+                }
+            });
+            codeBox.append(copyBtn);
+            const show = key(w.showCode, () => {
+                code.textContent = seed.match(/.{1,16}/g).join("\n");
+                codeBox.hidden = false;
+                show.remove();
+                go.textContent = w.continue;
+                go.className = "n133s-btn n133s-primary";
+            }, "primary");
+            area.replaceChildren(title(w.spareTitle), h("p", { class: "n133s-text" }, w.spareText), codeBox, h("p", { class: "n133s-fine" }, w.spareFine), h("div", { class: "n133s-keys" }, show, go));
+            say("");
+            focusFirst();
+        });
+    }
+    async function finish(seed, credentialId, made) {
+        const fresh = made || readMemo(rpId).unopened.includes(credentialId);
+        if (fresh && options.spareKey !== false)
+            await spareKey(seed);
+        if (stopped)
+            return;
+        busy(true);
+        say(w.signingIn);
+        try {
+            const { signinBody } = await import("@nano133/signin/purse");
+            const turnstile = await personToken();
+            const r = await api.post(`${base}/passkey`, { ...signinBody(location.host, seed), ...(turnstile ? { turnstile } : {}) });
+            rememberOpened(rpId, credentialId);
+            if (!stopped)
+                done({ address: r.address, via: "passkey" });
+        }
+        catch (e) {
+            if (!stopped)
+                showPasskey(e instanceof ApiError ? w.refusal(e.message, e.status) : w.signInFailed);
+        }
+    }
+    // ---- a wallet app ----
+    async function choose(way) {
+        if (current?.way === way && Date.now() < current.expiresAt)
+            return showWallet(current);
+        stopWaiting();
+        current = null;
+        busy(true);
+        say(w.starting);
+        try {
+            const turnstile = await personToken();
+            const s = await api.post(`${base}/start`, { way, ...(turnstile ? { turnstile } : {}) });
+            if (stopped)
+                return;
+            current = s;
+            rememberLast(rpId, way);
+            showWallet(s);
+            void poll(s);
+        }
+        catch (e) {
+            busy(false);
+            showWays();
+            say(e instanceof ApiError ? w.refusal(e.message, e.status) : e instanceof Error && e.message ? w.refusal(e.message, 0) : w.startFailed);
+        }
+    }
+    function showWallet(s) {
+        const name = WALLETS[s.way].name;
+        area.replaceChildren(backKey(), title(name), ...walletSteps(s, name));
+        say(w.waitingFor(name));
+        focusFirst();
+    }
+    /** What the player does with the wallet: on a touch screen, one key; with a mouse, a QR code for the phone. */
+    function walletSteps(s, name) {
+        const open = (text, href, newTab = false) => h("a", { class: "n133s-btn n133s-primary", href, target: newTab ? "_blank" : undefined, rel: newTab ? "noopener" : undefined }, text);
+        const qr = (text) => {
+            if (!options.qr)
+                return h("p", { class: "n133s-fine" }, w.openOnPhone(name));
+            const c = options.qr(text);
+            c.setAttribute("aria-label", w.qrLabel(name));
+            return h("div", { class: "n133s-qr" }, c);
+        };
+        const only = h("p", { class: "n133s-fine" }, w.onlyYours(location.host));
+        const comeBack = h("p", { class: "n133s-fine" }, w.comeBack(s.way === "berry" ? w.yourWallet : name));
+        if (s.way === "nautilus") {
+            const code = h("p", { class: "n133s-text" }, w.checkCode, h("strong", { class: "n133s-signcode" }, s.code ?? ""));
+            return touch() ? [code, open(w.openApp(name), s.link), comeBack] : [qr(s.link), h("p", { class: "n133s-text" }, w.scanWith(name)), code, only];
+        }
+        if (s.way === "nanchat") {
+            const here = h("p", { class: "n133s-fine" }, w.onComputer, h("a", { href: s.link, target: "_blank", rel: "noopener" }, w.openLink(name)));
+            return touch() ? [open(w.openApp(name), s.link, true), comeBack, only] : [qr(s.link), h("p", { class: "n133s-text" }, w.scanCamera(name)), only, here];
+        }
+        const other = h("a", { class: "n133s-btn n133s-plain", href: s.walletLink ?? s.link }, w.anotherWallet);
+        const here = h("p", { class: "n133s-fine" }, w.onComputer, h("a", { href: s.walletLink ?? s.link }, w.openLink(w.aWallet)));
+        return touch() ? [open(w.openApp(name), s.link), other, comeBack] : [qr(s.link), h("p", { class: "n133s-text" }, w.scanWith(name)), only, here];
+    }
+    /** The request ended without a sign-in: say why, and offer a new one. */
+    function again(s, words) {
+        current = null;
+        area.replaceChildren(backKey(), title(WALLETS[s.way].name), h("div", { class: "n133s-keys" }, key(w.tryAgain, () => void choose(s.way), "primary"), key(w.otherWay, () => showWays())));
+        say(words);
+    }
+    async function poll(s) {
+        if (stopped || current !== s)
+            return;
+        if (Date.now() > s.expiresAt + 5000)
+            return again(s, w.expired);
+        try {
+            const r = await api.post(`${base}/check`, { id: s.id, way: s.way });
+            if (stopped || current !== s)
+                return;
+            if (r.status === "signedin" && r.address)
+                return done({ address: r.address, via: "wallet" });
+            if (r.status === "elsewhere" || r.status === "used")
+                return again(s, w.usedElsewhere);
+            if (r.status === "expired")
+                return again(s, w.expired);
+        }
+        catch (e) {
+            if (e instanceof ApiError && e.status === 429)
+                say(w.tooManyChecks);
+        }
+        timer = setTimeout(() => void poll(s), 2000);
+    }
+    function reset() {
+        stopped = false;
+        current = null;
+        showWays();
+    }
+    showWays();
+    if (passkeyOn)
+        void passkeySupport().then((s) => {
+            support = s;
+            // Only the ways' screen depends on it: redraw it when it shows.
+            if (!stopped && area.querySelector(".n133s-pk"))
+                showWays();
+        });
+    return {
+        node,
+        stop() {
+            stopped = true;
+            stopWaiting();
+        },
+        reset,
+    };
+}

package/dist/player-signin/panel/words.d.ts

@@ -0,0 +1,103 @@
+import type { PasskeyFault } from "@nano133/signin/passkey";
+/** What to do next after a fault: stay on the passkey step, or offer the wallet apps. */
+export type FaultWords = {
+    title: string;
+    text: string;
+    next: "stay" | "wallets";
+};
+/** A fault's words: its title, and its text (a function when it names the game's domain, `rpId`). */
+export type FaultText = {
+    title: string;
+    text: string | ((rpId: string) => string);
+};
+export type PlayerSigninWords = {
+    /** The sheet's title. The option `title` wins over it. */
+    title: string;
+    /** The close key's name for a screen reader. */
+    close: string;
+    /** The first line of the ways. */
+    lead: string;
+    usePasskey: string;
+    /** Under "Use a passkey". */
+    passkeyHint: string;
+    /** Under "Use a passkey" where the browser reports no passkey PRF. */
+    passkeyOff: string;
+    lastUsed: string;
+    /** Before the wallet tiles, after the passkey. */
+    orWallet: string;
+    /** Before the wallet tiles, with no passkey before them. */
+    chooseWallet: string;
+    /** Before the passkey, when it comes last. */
+    orPasskey: string;
+    back: string;
+    passkeyTitle: string;
+    passkeyText: string;
+    useMine: string;
+    makeOne: string;
+    waitingPasskey: string;
+    makingPasskey: string;
+    openingPasskey: string;
+    /** A passkey just made, whose first use gave nothing: one key opens it. */
+    madeTitle: string;
+    madeText: string;
+    openMine: string;
+    spareTitle: string;
+    spareText: string;
+    /** Under the code: keep it secret; how to use it. */
+    spareFine: string;
+    showCode: string;
+    copyCode: string;
+    copied: string;
+    copyFailed: string;
+    later: string;
+    continue: string;
+    signingIn: string;
+    signInFailed: string;
+    /** After a fault that offers the wallet apps. */
+    faultWallets: string;
+    faults: Record<PasskeyFault, FaultText>;
+    starting: string;
+    startFailed: string;
+    /** The words of a refusal: the server's own (`text`, in English) and its HTTP status (0: no answer). Default: the server's words. */
+    refusal: (text: string, status: number) => string;
+    /** The status while the page waits for a wallet ("Berry Wallet"). */
+    waitingFor: (wallet: string) => string;
+    /** After a sign-in, with the player's short address. */
+    signedInAs: (address: string) => string;
+    /** The key that opens a wallet app on a touch screen. */
+    openApp: (wallet: string) => string;
+    anotherWallet: string;
+    /** Before a link that opens the wallet on this computer. */
+    onComputer: string;
+    /** The link's words: open a wallet ("NanChat", or `aWallet`). */
+    openLink: (wallet: string) => string;
+    aWallet: string;
+    /** With no QR hook, on a screen with a mouse. */
+    openOnPhone: (wallet: string) => string;
+    qrLabel: (wallet: string) => string;
+    /** Only approve a sign-in the player started, on this host. */
+    onlyYours: (host: string) => string;
+    /** After the key that opens the app (`yourWallet` for Berry Wallet, which opens any wallet). */
+    comeBack: (wallet: string) => string;
+    yourWallet: string;
+    /** Under a QR code: scan it with this wallet. */
+    scanWith: (wallet: string) => string;
+    /** Under NanChat's QR code: the phone's camera opens it. */
+    scanCamera: (wallet: string) => string;
+    /** Before Nautilus's code (the code follows, bold). */
+    checkCode: string;
+    tryAgain: string;
+    otherWay: string;
+    expired: string;
+    usedElsewhere: string;
+    tooManyChecks: string;
+};
+/** `words` as a game gives it: any of the keys, and any of the faults. */
+export type PlayerSigninWordsOption = Partial<Omit<PlayerSigninWords, "faults">> & {
+    faults?: Partial<Record<PasskeyFault, FaultText>>;
+};
+export declare const PLAYER_SIGNIN_WORDS: PlayerSigninWords;
+/** The game's words over the defaults; its faults over the default faults. A key it leaves out, or gives as undefined, keeps its default. */
+export declare function playerSigninWords(over?: PlayerSigninWordsOption): PlayerSigninWords;
+/** A fault's title, text and next step, in the game's words (default: PLAYER_SIGNIN_WORDS). An unknown code gets the words of "failed". */
+export declare function faultWords(code: PasskeyFault, rpId: string, words?: PlayerSigninWordsOption): FaultWords;

package/dist/player-signin/panel/words.js

@@ -0,0 +1,111 @@
+// Every word of the sign-in sheet, and its words for each passkey fault, in plain English. A game gives `words` to `mountPlayerSignin` (or to
+// `signInView`) with the keys it wants to change, in its own words or language; the rest stay these. A text with a value in it is a function of that
+// value. The wallets' names (Berry Wallet, NanChat, Nautilus) are names, not words: they stay.
+//
+// The fault codes are @nano133/signin's (PasskeyFault). A fault never names a seed or a key, and never tells the player to delete a passkey. No
+// sentence has more than 10 words.
+export const PLAYER_SIGNIN_WORDS = {
+    title: "Sign in",
+    close: "Close",
+    lead: "No password and no payment.",
+    usePasskey: "Use a passkey",
+    passkeyHint: "Face ID, Touch ID or your device PIN",
+    passkeyOff: "Not on this browser",
+    lastUsed: "Last used",
+    orWallet: "Or a wallet app",
+    chooseWallet: "Choose your wallet",
+    orPasskey: "Or a passkey",
+    back: "Back",
+    passkeyTitle: "Passkey",
+    passkeyText: "Face ID, Touch ID or your device PIN. The passkey stays on your device. The game never sees it.",
+    useMine: "Use my passkey",
+    makeOne: "Make a passkey",
+    waitingPasskey: "Waiting for your passkey…",
+    makingPasskey: "Making your passkey…",
+    openingPasskey: "Opening your passkey…",
+    madeTitle: "Your passkey is made",
+    madeText: "Press the key to open it.",
+    openMine: "Open my passkey",
+    spareTitle: "Keep a spare key",
+    spareText: "Your looks belong to this passkey. If you lose it, this code brings them back.",
+    spareFine: "Keep it secret. Anyone with it can sign in as you. Import it as a seed in Nautilus or another wallet. Then sign in with that wallet.",
+    showCode: "Show my code",
+    copyCode: "Copy the code",
+    copied: "Copied",
+    copyFailed: "Copy failed: write it down",
+    later: "Later",
+    continue: "Continue",
+    signingIn: "Signing in…",
+    signInFailed: "Sign-in did not work. Try again.",
+    faultWallets: "Sign in with a wallet app",
+    faults: {
+        cancelled: { title: "No passkey was used", text: "No passkey was used." },
+        "no-prf": { title: "Not on this device yet", text: "This device's passkeys cannot sign in to games yet. Use a wallet app, or a passkey on another device." },
+        unsupported: { title: "No passkeys here", text: "This browser has no passkeys. Use a wallet app." },
+        "other-form": { title: "Not this password manager", text: "This game cannot read your password manager's answer. Choose iCloud Keychain or Google Password Manager instead. Or use a wallet app." },
+        "not-a-purse": { title: "Not this game's passkey", text: "That passkey is not one of this game's. Choose another one, or make one." },
+        "wrong-host": { title: "Wrong address", text: (rpId) => `Passkeys for this game work only on ${rpId}.` },
+        exists: { title: "You have a passkey", text: "This device has your passkey already. Use it." },
+        unstable: { title: "Not on this device", text: "This device gave two answers for one passkey. It cannot sign in here. Use a wallet app." },
+        "other-passkey": { title: "Another passkey", text: "That is another passkey. Choose the one you just made. Its name has today's date." },
+        failed: { title: "That did not work", text: "The passkey did not work. Try again." },
+    },
+    starting: "Starting…",
+    startFailed: "Sign-in did not start. Try again.",
+    refusal: (text) => text,
+    waitingFor: (wallet) => `Waiting for ${wallet}…`,
+    signedInAs: (address) => `Signed in as ${address}`,
+    openApp: (wallet) => `Open ${wallet}`,
+    anotherWallet: "Another wallet",
+    onComputer: "On this computer: ",
+    openLink: (wallet) => `open ${wallet}`,
+    aWallet: "a wallet",
+    openOnPhone: (wallet) => `Open this page on your phone to use ${wallet}.`,
+    qrLabel: (wallet) => `QR code to sign in with ${wallet}`,
+    onlyYours: (host) => `Only approve a sign-in you started yourself, on ${host}.`,
+    comeBack: (wallet) => `Approve the sign-in in ${wallet}. Then come back to this page.`,
+    yourWallet: "your wallet",
+    scanWith: (wallet) => `Scan this with ${wallet} on your phone. Then approve the sign-in.`,
+    scanCamera: (wallet) => `Scan this with your phone's camera to open ${wallet}. Then approve the sign-in.`,
+    checkCode: "Check that Nautilus shows this code: ",
+    tryAgain: "Try again",
+    otherWay: "Choose another way",
+    expired: "This sign-in expired.",
+    usedElsewhere: "This sign-in was used in another browser. Start again.",
+    tooManyChecks: "Too many checks. Waiting a moment…",
+};
+/** The game's words over the defaults; its faults over the default faults. A key it leaves out, or gives as undefined, keeps its default. */
+export function playerSigninWords(over) {
+    const out = { ...PLAYER_SIGNIN_WORDS, faults: { ...PLAYER_SIGNIN_WORDS.faults } };
+    for (const [k, v] of Object.entries(over ?? {})) {
+        if (v === undefined || !(k in PLAYER_SIGNIN_WORDS))
+            continue;
+        if (k === "faults") {
+            for (const [code, f] of Object.entries(v))
+                if (f && code in out.faults)
+                    out.faults[code] = f;
+        }
+        else
+            out[k] = v;
+    }
+    return out;
+}
+/** What happens after each fault: the passkey step again, or the wallet apps. Not words: the sheet's steps. */
+const NEXT = {
+    cancelled: "stay",
+    "no-prf": "wallets",
+    unsupported: "wallets",
+    "other-form": "wallets",
+    "not-a-purse": "stay",
+    "wrong-host": "wallets",
+    exists: "stay",
+    unstable: "wallets",
+    "other-passkey": "stay",
+    failed: "stay",
+};
+/** A fault's title, text and next step, in the game's words (default: PLAYER_SIGNIN_WORDS). An unknown code gets the words of "failed". */
+export function faultWords(code, rpId, words = PLAYER_SIGNIN_WORDS) {
+    const known = code in NEXT ? code : "failed";
+    const f = words.faults?.[known] ?? PLAYER_SIGNIN_WORDS.faults[known];
+    return { title: f.title, text: typeof f.text === "function" ? f.text(rpId) : f.text, next: NEXT[known] };
+}

package/dist/player-signin/scheme-check.d.ts

@@ -0,0 +1,3 @@
+import type { PasskeyScheme } from "@nano133/signin/passkey";
+/** Throws with plain words when a scheme cannot be one: three texts of 1 to 200 characters, and a version byte from 1 to 255. */
+export declare function checkScheme(scheme: PasskeyScheme): PasskeyScheme;

package/dist/player-signin/scheme-check.js

@@ -0,0 +1,14 @@
+// The check of a passkey scheme's shape, with no package: the browser sheet and the server both use it (./scheme.ts says what a scheme is).
+/** Throws with plain words when a scheme cannot be one: three texts of 1 to 200 characters, and a version byte from 1 to 255. */
+export function checkScheme(scheme) {
+    if (!scheme || typeof scheme !== "object")
+        throw new Error("pass the game's frozen passkey scheme: { input, salt, info, versionByte }");
+    for (const k of ["input", "salt", "info"]) {
+        const v = scheme[k];
+        if (typeof v !== "string" || !v.trim() || v.length > 200)
+            throw new Error(`the scheme's ${k} must be a text of 1 to 200 characters`);
+    }
+    if (!Number.isInteger(scheme.versionByte) || scheme.versionByte < 1 || scheme.versionByte > 255)
+        throw new Error("the scheme's versionByte must be a whole number from 1 to 255");
+    return scheme;
+}

package/dist/player-signin/scheme.d.ts

@@ -0,0 +1,13 @@
+import { type PasskeyScheme } from "@nano133/signin/passkey";
+import { checkScheme } from "./scheme-check.js";
+export type { PasskeyScheme };
+export { checkScheme };
+/**
+ * One fixed vector of a scheme: the seed and the address that a PRF output gives. For the game's own test, which must never change:
+ *
+ *   assert.deepEqual(await schemeVector(SCHEME, "0102…1f20"), { seed: "A3D5…", address: "nano_14kj…" });
+ */
+export declare function schemeVector(scheme: PasskeyScheme, prfHex: string): Promise<{
+    seed: string;
+    address: string;
+}>;

package/dist/player-signin/scheme.js

@@ -0,0 +1,28 @@
+// The game's passkey SCHEME: the texts that turn a passkey's secret (its PRF output) into the player's Nano account. It is the game's own, and it is
+// FROZEN: a player's looks belong to the address these exact texts give.
+//
+//   PRF input = UTF-8 scheme.input
+//   seed      = HKDF-SHA-256(ikm = the PRF output, salt = UTF-8 scheme.salt, info = UTF-8 scheme.info, 32 bytes)
+//   account   = the seed as 64 hex characters, account 0
+//
+// Write it one time, in one file of the game, and test it with fixed vectors (`schemeVector`): a PRF output, its seed, its address. A change of one
+// character gives every player another account (and so no looks). A new scheme is a new `versionByte` with new texts, never an edit. The kit offers
+// no default on purpose: a default in a library could change under the game.
+import { seedFromPrf } from "@nano133/signin/passkey";
+import { purseAddress } from "@nano133/signin/purse";
+import { checkScheme } from "./scheme-check.js";
+export { checkScheme };
+const bytesOf = (prfHex) => {
+    if (!/^[0-9a-fA-F]{64}$/.test(prfHex))
+        throw new Error("a PRF output is 64 hex characters (32 bytes)");
+    return Uint8Array.from(prfHex.match(/../g).map((b) => parseInt(b, 16)));
+};
+/**
+ * One fixed vector of a scheme: the seed and the address that a PRF output gives. For the game's own test, which must never change:
+ *
+ *   assert.deepEqual(await schemeVector(SCHEME, "0102…1f20"), { seed: "A3D5…", address: "nano_14kj…" });
+ */
+export async function schemeVector(scheme, prfHex) {
+    const seed = await seedFromPrf(bytesOf(prfHex), checkScheme(scheme));
+    return { seed, address: purseAddress(seed) };
+}