@gryt/core 0.14.0 → 0.15.0

package/dist/mls/deliveryService.fake.d.ts

@@ -0,0 +1,96 @@
+import { type IdentityScope } from "@gryt/crypto";
+import type { MlsDmDriver, MlsGroupRecord, MlsKeyPackageRecord, MlsDeviceRecord, MlsLogEntry, MlsStateStore, MlsTransport, MlsWelcomeDelivery } from "./interfaces.js";
+interface KeyPackageRow {
+    ref: string;
+    serverUserId: string;
+    deviceId: string;
+    data: Uint8Array;
+    lastResort: boolean;
+    claimed: boolean;
+}
+interface GroupRow {
+    conversationId: string;
+    groupId: string;
+    epoch: number;
+    headSeq: number;
+    log: MlsLogEntry[];
+}
+interface Socket {
+    serverUserId: string;
+    driver: MlsDmDriver | null;
+    online: boolean;
+    /** False: every call answers `offline` without reaching the server, as an app's transport does. */
+    reachable: boolean;
+    /** The next call to each method either never arrives or has its answer lost. Both answer `timeout`. */
+    lose: Map<keyof MlsTransport, "request" | "answer">;
+}
+export declare class FakeDeliveryService {
+    scope: IdentityScope;
+    conversations: Map<string, string[]>;
+    devices: Map<string, string[]>;
+    /** Ids their owner removed, as `${serverUserId}:${deviceId}`. Anything naming one is refused (GRYT-1555). */
+    removed: Set<string>;
+    /** Every call that named a device, in order, by device id. */
+    callsBy: Map<string, string[]>;
+    /** When each device id first published, as `mls:devices` reports it. */
+    deviceAddedAt: Map<string, string>;
+    keyPackages: KeyPackageRow[];
+    groups: Map<string, GroupRow>;
+    welcomes: (MlsWelcomeDelivery & {
+        serverUserId: string;
+    })[];
+    sockets: Socket[];
+    stats: {
+        commits: number;
+        staleEpoch: number;
+        groupExists: number;
+        claims: number;
+        publishes: number;
+        mostBinaryParts: number;
+    };
+    /** A cap on Welcomes per sync, for a server that pages them (GRYT-1528). server#241 has none. */
+    syncWelcomeLimit: number;
+    /** What each `mls:send` said it carried, by seq. */
+    attachmentIds: Map<number, string[] | undefined>;
+    private inFlight;
+    private held;
+    private nextWelcome;
+    constructor(scope: IdentityScope);
+    dm(a: string, b: string): string;
+    /** Commits wait until `count` of them are in, then go through in the order they came. */
+    holdCommits(count: number): void;
+    /** Waits until every push has been handled, including what those handlers set off. */
+    settle(): Promise<void>;
+    connect(serverUserId: string): {
+        transport: MlsTransport;
+        socket: Socket;
+    };
+    dropLogThrough(conversationId: string, seq: number): void;
+    private push;
+    private peopleSharing;
+    private devicesOf;
+    private isDevice;
+    private groupView;
+    private transportFor;
+    private checkParts;
+    private counts;
+    private append;
+    private commit;
+}
+/** What an app's store does, kept in maps and copied on the way in and out. */
+export declare class MemoryMlsStore implements MlsStateStore {
+    device: MlsDeviceRecord | null;
+    keyPackages: Map<string, MlsKeyPackageRecord>;
+    groups: Map<string, MlsGroupRecord>;
+    loadDevice(): Promise<MlsDeviceRecord | null>;
+    saveDevice(device: MlsDeviceRecord): Promise<void>;
+    putKeyPackages(records: MlsKeyPackageRecord[]): Promise<void>;
+    listKeyPackages(): Promise<MlsKeyPackageRecord[]>;
+    getKeyPackage(ref: string): Promise<MlsKeyPackageRecord | null>;
+    deleteKeyPackage(ref: string): Promise<void>;
+    loadGroup(conversationId: string): Promise<MlsGroupRecord | null>;
+    listGroups(): Promise<MlsGroupRecord[]>;
+    saveGroup(record: MlsGroupRecord): Promise<void>;
+    deleteGroup(conversationId: string): Promise<void>;
+}
+export {};

package/dist/mls/deliveryService.fake.js

@@ -0,0 +1,413 @@
+/* An in-memory stand-in for the delivery service in Gryt-chat/server#241, for tests only.
+   Same answers and pushes; no auth, blocks, rate limits or member checks on adds. */
+import { base64UrlDecode, inspectMlsMessage, mlsWelcomeRefs, readMlsKeyPackage } from "@gryt/crypto";
+const MAX_DEVICES = 5;
+const MAX_KEY_PACKAGES = 20;
+const MAX_LOG_PAGE = 200;
+const DUPLICATE_WINDOW = 100;
+const fail = (error, message, extra = {}) => ({ ok: false, error, message, ...extra });
+const hexOf = (b64) => Array.from(base64UrlDecode(b64), (b) => b.toString(16).padStart(2, "0")).join("");
+function same(a, b) {
+    return a.length === b.length && a.every((x, i) => x === b[i]);
+}
+export class FakeDeliveryService {
+    scope;
+    conversations = new Map();
+    devices = new Map();
+    /** Ids their owner removed, as `${serverUserId}:${deviceId}`. Anything naming one is refused (GRYT-1555). */
+    removed = new Set();
+    /** Every call that named a device, in order, by device id. */
+    callsBy = new Map();
+    /** When each device id first published, as `mls:devices` reports it. */
+    deviceAddedAt = new Map();
+    keyPackages = [];
+    groups = new Map();
+    welcomes = [];
+    sockets = [];
+    stats = { commits: 0, staleEpoch: 0, groupExists: 0, claims: 0, publishes: 0, mostBinaryParts: 0 };
+    /** A cap on Welcomes per sync, for a server that pages them (GRYT-1528). server#241 has none. */
+    syncWelcomeLimit = Infinity;
+    /** What each `mls:send` said it carried, by seq. */
+    attachmentIds = new Map();
+    inFlight = new Set();
+    held = null;
+    nextWelcome = 1;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    dm(a, b) {
+        const id = `dm:${[a, b].sort().join(":")}`;
+        this.conversations.set(id, [a, b]);
+        return id;
+    }
+    /** Commits wait until `count` of them are in, then go through in the order they came. */
+    holdCommits(count) {
+        this.held = { count, waiting: [] };
+    }
+    /** Waits until every push has been handled, including what those handlers set off. */
+    async settle() {
+        while (this.inFlight.size > 0)
+            await Promise.allSettled([...this.inFlight]);
+    }
+    connect(serverUserId) {
+        const socket = { serverUserId, driver: null, online: true, reachable: true, lose: new Map() };
+        this.sockets.push(socket);
+        return { transport: this.transportFor(socket), socket };
+    }
+    dropLogThrough(conversationId, seq) {
+        const g = this.groups.get(conversationId);
+        if (g)
+            g.log = g.log.filter((e) => e.seq > seq);
+    }
+    push(to, deliver) {
+        for (const s of this.sockets) {
+            if (!s.online || !s.reachable || !s.driver || !to.includes(s.serverUserId))
+                continue;
+            const driver = s.driver;
+            const p = new Promise((resolve) => setTimeout(resolve, 0)).then(() => deliver(driver));
+            const tracked = p.catch(() => undefined).finally(() => this.inFlight.delete(tracked));
+            this.inFlight.add(tracked);
+        }
+    }
+    peopleSharing(serverUserId) {
+        const out = new Set([serverUserId]);
+        for (const members of this.conversations.values())
+            if (members.includes(serverUserId))
+                members.forEach((m) => out.add(m));
+        return [...out];
+    }
+    devicesOf(ids) {
+        return ids.flatMap((serverUserId) => (this.devices.get(serverUserId) ?? []).map((deviceId) => ({ serverUserId, deviceId })));
+    }
+    isDevice(serverUserId, deviceId) {
+        return (this.devices.get(serverUserId) ?? []).includes(deviceId);
+    }
+    groupView(g) {
+        return { conversationId: g.conversationId, groupId: g.groupId, epoch: g.epoch, headSeq: g.headSeq };
+    }
+    transportFor(socket) {
+        const me = socket.serverUserId;
+        const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+        const member = (conversationId) => this.conversations.get(conversationId)?.includes(me) ?? false;
+        const methods = {
+            publishKeyPackages: async ({ deviceId, keyPackages, lastResort }) => {
+                await tick();
+                this.stats.publishes += 1;
+                const isNew = !this.isDevice(me, deviceId);
+                if (isNew && (this.devices.get(me) ?? []).length >= MAX_DEVICES) {
+                    return fail("too_many_devices", "You have five devices using encrypted messages here.");
+                }
+                const raw = [...keyPackages.map((b) => ({ b, lastResort: false }))];
+                if (lastResort)
+                    raw.push({ b: lastResort, lastResort: true });
+                const rows = [];
+                for (const { b, lastResort: lr } of raw) {
+                    const { ref } = await readMlsKeyPackage(b, this.scope);
+                    rows.push({ ref, serverUserId: me, deviceId, data: b.slice(), lastResort: lr, claimed: false });
+                }
+                if (isNew) {
+                    this.devices.set(me, [...(this.devices.get(me) ?? []), deviceId]);
+                    this.deviceAddedAt.set(deviceId, new Date().toISOString());
+                }
+                let stored = 0;
+                for (const row of rows) {
+                    const unclaimed = this.keyPackages.filter((k) => k.deviceId === deviceId && !k.lastResort && !k.claimed).length;
+                    if (!row.lastResort && unclaimed >= MAX_KEY_PACKAGES)
+                        continue;
+                    if (row.lastResort) {
+                        for (const k of this.keyPackages)
+                            if (k.deviceId === deviceId && k.lastResort)
+                                k.claimed = true;
+                    }
+                    this.keyPackages.push(row);
+                    stored += 1;
+                }
+                if (isNew)
+                    this.push(this.peopleSharing(me), (d) => d.handleDevicesChanged({ serverUserId: me }));
+                return { ok: true, stored, ...this.counts(me, deviceId) };
+            },
+            claimKeyPackages: async ({ conversationId, deviceId, devices }) => {
+                await tick();
+                if (!member(conversationId))
+                    return fail("not_found", "No such conversation.");
+                this.stats.claims += 1;
+                let targets = this.devicesOf(this.conversations.get(conversationId)).filter((d) => !(d.serverUserId === me && d.deviceId === deviceId));
+                if (devices)
+                    targets = targets.filter((t) => devices.some((d) => d.serverUserId === t.serverUserId && d.deviceId === t.deviceId));
+                const keyPackages = [];
+                const missing = [];
+                for (const t of targets) {
+                    const mine = this.keyPackages.filter((k) => k.serverUserId === t.serverUserId && k.deviceId === t.deviceId && !k.claimed);
+                    const fresh = mine.find((k) => !k.lastResort);
+                    const kp = fresh ?? mine.find((k) => k.lastResort);
+                    if (!kp) {
+                        missing.push(t);
+                        continue;
+                    }
+                    if (fresh)
+                        fresh.claimed = true;
+                    keyPackages.push({ ...t, keyPackage: kp.data.slice(), lastResort: kp.lastResort });
+                }
+                return { ok: true, keyPackages, missing };
+            },
+            listDevices: async ({ conversationId }) => {
+                await tick();
+                if (conversationId === undefined) {
+                    const devices = this.devicesOf([me]).map((d) => {
+                        const at = this.deviceAddedAt.get(d.deviceId);
+                        return at ? { ...d, createdAt: at, lastSeenAt: at } : d;
+                    });
+                    return { ok: true, devices };
+                }
+                if (!member(conversationId))
+                    return fail("not_found", "No such conversation.");
+                return { ok: true, devices: this.devicesOf(this.conversations.get(conversationId)) };
+            },
+            removeDevice: async ({ deviceId }) => {
+                await tick();
+                if (!this.isDevice(me, deviceId))
+                    return fail("unknown_device", "Publish KeyPackages from this device first.");
+                this.devices.set(me, (this.devices.get(me) ?? []).filter((d) => d !== deviceId));
+                this.removed.add(`${me}:${deviceId}`);
+                this.keyPackages = this.keyPackages.filter((k) => !(k.serverUserId === me && k.deviceId === deviceId));
+                this.welcomes = this.welcomes.filter((w) => !(w.serverUserId === me && w.deviceId === deviceId));
+                this.push(this.peopleSharing(me), (d) => d.handleDevicesChanged({ serverUserId: me }));
+                return { ok: true };
+            },
+            createGroup: async ({ conversationId, groupId }) => {
+                await tick();
+                if (!member(conversationId))
+                    return fail("not_found", "No such conversation.");
+                const existing = this.groups.get(conversationId);
+                if (existing) {
+                    this.stats.groupExists += 1;
+                    return fail("group_exists", "This conversation already has a group.", { group: this.groupView(existing) });
+                }
+                const g = { conversationId, groupId, epoch: 0, headSeq: 0, log: [] };
+                this.groups.set(conversationId, g);
+                return { ok: true, group: this.groupView(g) };
+            },
+            commit: async ({ conversationId, deviceId, commit, welcome }) => {
+                await tick();
+                if (this.held) {
+                    const held = this.held;
+                    await new Promise((resolve) => {
+                        held.waiting.push(resolve);
+                        if (held.waiting.length >= held.count) {
+                            this.held = null;
+                            held.waiting.forEach((go) => go());
+                        }
+                    });
+                }
+                return this.commit(me, conversationId, deviceId, commit, welcome);
+            },
+            send: async ({ conversationId, deviceId, message, attachmentIds }) => {
+                await tick();
+                if (!member(conversationId))
+                    return fail("not_found", "No such conversation.");
+                const g = this.groups.get(conversationId);
+                if (!g)
+                    return fail("no_group", "This conversation has no group yet.");
+                const info = inspectMlsMessage(message);
+                if (info.contentType === "commit")
+                    return fail("use_commit", "Send commits with mls:commit.");
+                if (hexOf(info.groupId) !== g.groupId)
+                    return fail("wrong_group", "That message is for another group.");
+                const epoch = Number(info.epoch);
+                if (epoch > g.epoch)
+                    return fail("future_epoch", "That epoch hasn't happened yet.", { epoch: g.epoch });
+                const dup = g.log.find((e) => e.seq > g.headSeq - DUPLICATE_WINDOW && same(e.data, message));
+                if (dup)
+                    return { ok: true, seq: dup.seq };
+                const kind = info.contentType === "application" ? "application" : "proposal";
+                const entry = this.append(g, kind, epoch, me, deviceId, message);
+                this.attachmentIds.set(entry.seq, attachmentIds);
+                this.push(this.conversations.get(conversationId), (d) => d.handleMessage(entry));
+                return { ok: true, seq: entry.seq };
+            },
+            fetchLog: async ({ conversationId, after, limit }) => {
+                await tick();
+                if (!member(conversationId))
+                    return fail("not_found", "No such conversation.");
+                const g = this.groups.get(conversationId);
+                if (!g)
+                    return { ok: true, group: null, entries: [], nextCursor: after, hasMore: false, gap: false };
+                const n = Math.min(limit ?? 100, MAX_LOG_PAGE);
+                const rows = g.log.filter((e) => e.seq > after).slice(0, n + 1);
+                const page = rows.slice(0, n);
+                const oldest = g.log.length ? g.log[0].seq : null;
+                const gap = after < g.headSeq && (oldest === null || oldest > after + 1);
+                return {
+                    ok: true,
+                    group: this.groupView(g),
+                    entries: page.map((e) => ({ ...e, data: e.data.slice() })),
+                    nextCursor: page.length ? page[page.length - 1].seq : Math.max(after, gap ? g.headSeq : after),
+                    hasMore: rows.length > n,
+                    gap,
+                };
+            },
+            sync: async ({ deviceId }) => {
+                await tick();
+                const registered = this.isDevice(me, deviceId);
+                const groups = [...this.groups.values()]
+                    .filter((g) => member(g.conversationId))
+                    .map((g) => ({ ...this.groupView(g), oldestSeq: g.log.length ? g.log[0].seq : null }));
+                const welcomes = registered
+                    ? this.welcomes.filter((w) => w.serverUserId === me && w.deviceId === deviceId).slice(0, this.syncWelcomeLimit)
+                    : [];
+                return { ok: true, registered, groups, welcomes, keyPackages: { ...this.counts(me, deviceId), target: MAX_KEY_PACKAGES } };
+            },
+            ackWelcomes: async ({ deviceId, welcomeIds }) => {
+                await tick();
+                const before = this.welcomes.length;
+                this.welcomes = this.welcomes.filter((w) => !(w.serverUserId === me && w.deviceId === deviceId && welcomeIds.includes(w.welcomeId)));
+                return { ok: true, deleted: before - this.welcomes.length };
+            },
+        };
+        // socket.io-parser closes the connection on a packet with more than ten binary parts.
+        const guarded = {};
+        for (const [name, method] of Object.entries(methods)) {
+            guarded[name] = async (req) => {
+                if (!socket.reachable)
+                    return fail("offline", "Not connected to this server.");
+                const lost = socket.lose.get(name);
+                socket.lose.delete(name);
+                if (lost === "request")
+                    return fail("timeout", `No answer to ${name}.`);
+                if (lost === "answer") {
+                    await guarded[name](req).catch(() => undefined);
+                    return fail("timeout", `No answer to ${name}.`);
+                }
+                this.checkParts(socket, name, req);
+                const deviceId = req?.deviceId;
+                if (typeof deviceId === "string") {
+                    this.callsBy.set(deviceId, [...(this.callsBy.get(deviceId) ?? []), name]);
+                    if (this.removed.has(`${me}:${deviceId}`)) {
+                        await tick();
+                        return fail("device_removed", "You removed this device from encrypted messages here.");
+                    }
+                }
+                const reply = await method(req);
+                this.checkParts(socket, name, reply);
+                return reply;
+            };
+        }
+        return guarded;
+    }
+    checkParts(socket, event, value) {
+        const count = (v) => v instanceof Uint8Array ? 1 : Array.isArray(v) ? v.reduce((n, x) => n + count(x), 0)
+            : v && typeof v === "object" ? Object.values(v).reduce((n, x) => n + count(x), 0) : 0;
+        const parts = count(value);
+        this.stats.mostBinaryParts = Math.max(this.stats.mostBinaryParts, parts);
+        if (parts > 10) {
+            socket.online = false;
+            throw new Error(`${event}: ${parts} binary parts, so the socket was closed ("too many attachments").`);
+        }
+    }
+    counts(serverUserId, deviceId) {
+        const mine = this.keyPackages.filter((k) => k.serverUserId === serverUserId && k.deviceId === deviceId && !k.claimed);
+        return { unclaimed: mine.filter((k) => !k.lastResort).length, lastResort: mine.some((k) => k.lastResort) };
+    }
+    append(g, kind, epoch, sender, deviceId, data) {
+        g.headSeq += 1;
+        const entry = {
+            conversationId: g.conversationId,
+            groupId: g.groupId,
+            seq: g.headSeq,
+            kind,
+            epoch,
+            senderServerUserId: sender,
+            senderDeviceId: deviceId,
+            data: data.slice(),
+            createdAt: new Date().toISOString(),
+        };
+        g.log.push(entry);
+        return entry;
+    }
+    async commit(me, conversationId, deviceId, commit, welcome) {
+        if (!this.conversations.get(conversationId)?.includes(me))
+            return fail("not_found", "No such conversation.");
+        if (!this.isDevice(me, deviceId))
+            return fail("unknown_device", "Publish KeyPackages from this device first.");
+        const g = this.groups.get(conversationId);
+        if (!g)
+            return fail("no_group", "This conversation has no group yet.");
+        const info = inspectMlsMessage(commit);
+        if (info.wireformat !== "mls_public_message" || info.contentType !== "commit")
+            return fail("not_a_commit", "Not a commit.");
+        if (hexOf(info.groupId) !== g.groupId)
+            return fail("wrong_group", "That commit is for another group.");
+        const dup = g.log.find((e) => e.seq > g.headSeq - DUPLICATE_WINDOW && same(e.data, commit));
+        if (dup)
+            return { ok: true, seq: dup.seq, epoch: dup.epoch + 1 };
+        const epoch = Number(info.epoch);
+        if (epoch !== g.epoch) {
+            this.stats.staleEpoch += 1;
+            return fail("stale_epoch", "Another commit got there first.", { epoch: g.epoch, headSeq: g.headSeq });
+        }
+        const recipients = [];
+        if (welcome) {
+            for (const ref of mlsWelcomeRefs(welcome)) {
+                const owner = this.keyPackages.find((k) => k.ref === ref);
+                if (!owner)
+                    return fail("not_a_member_device", "That Welcome is for somebody outside the conversation.");
+                recipients.push({ serverUserId: owner.serverUserId, deviceId: owner.deviceId });
+            }
+        }
+        this.stats.commits += 1;
+        const entry = this.append(g, "commit", epoch, me, deviceId, commit);
+        g.epoch += 1;
+        this.push(this.conversations.get(conversationId), (d) => d.handleMessage(entry));
+        for (const r of recipients) {
+            const w = {
+                welcomeId: `w${this.nextWelcome++}`,
+                conversationId,
+                groupId: g.groupId,
+                deviceId: r.deviceId,
+                data: welcome.slice(),
+                createdAt: entry.createdAt,
+            };
+            this.welcomes.push({ ...w, serverUserId: r.serverUserId });
+            this.push([r.serverUserId], (d) => d.handleWelcome(w));
+        }
+        return { ok: true, seq: entry.seq, epoch: g.epoch };
+    }
+}
+/** What an app's store does, kept in maps and copied on the way in and out. */
+export class MemoryMlsStore {
+    device = null;
+    keyPackages = new Map();
+    groups = new Map();
+    async loadDevice() {
+        return this.device;
+    }
+    async saveDevice(device) {
+        this.device = device;
+    }
+    async putKeyPackages(records) {
+        for (const r of records)
+            this.keyPackages.set(r.ref, r);
+    }
+    async listKeyPackages() {
+        return [...this.keyPackages.values()];
+    }
+    async getKeyPackage(ref) {
+        return this.keyPackages.get(ref) ?? null;
+    }
+    async deleteKeyPackage(ref) {
+        this.keyPackages.delete(ref);
+    }
+    async loadGroup(conversationId) {
+        const r = this.groups.get(conversationId);
+        return r ? structuredClone(r) : null;
+    }
+    async listGroups() {
+        return [...this.groups.values()].map((r) => structuredClone(r));
+    }
+    async saveGroup(record) {
+        this.groups.set(record.conversationId, structuredClone(record));
+    }
+    async deleteGroup(conversationId) {
+        this.groups.delete(conversationId);
+    }
+}

package/dist/mls/dmDriver.d.ts

@@ -1,5 +1,5 @@
 import type { MlsDmDriver, MlsDmDriverOptions, MlsRefusal } from "./interfaces.js";
-export type MlsDriverErrorCode = "refused" | "not_own_device" | "no_device" | "waiting_for_welcome" | "not_in_group" | "unexpected_member" | "peer_unverified" | "too_many_attachments" | "commit_retries" | "device_removed";
+export type MlsDriverErrorCode = "refused" | "not_own_device" | "no_device" | "waiting_for_welcome" | "not_in_group" | "unexpected_member" | "peer_unverified" | "too_many_attachments" | "commit_retries" | "device_removed" | "offline" | "stopped";
 export declare class MlsDriverError extends Error {
     code: MlsDriverErrorCode;
     /** The server's refusal, when there was one. */

package/dist/mls/dmDriver.js

@@ -9,6 +9,10 @@ const PUBLISH_BATCH = MAX_BINARY_PARTS - 1;
 /** The server's cap on files in one message. */
 const MAX_ATTACHMENT_IDS = 10;
 const WELCOME_WAIT_MS = 10_000;
+/** The same cap as a message that isn't MLS: after this a send fails and the text goes back. */
+const SEND_GIVE_UP_MS = 5 * 60_000;
+/** A send with no answer goes again after this, or sooner if the connection comes back. */
+const RESEND_AFTER_MS = 2_000;
 /** The server keeps Welcomes 30 days; a last-resort package is replaced with a week to go. */
 const WELCOME_KEEP_S = 30 * 86_400;
 const RENEW_BEFORE_S = 7 * 86_400;
@@ -26,6 +30,11 @@ export class MlsDriverError extends Error {
 function refused(what, r) {
     return new MlsDriverError("refused", `${what}: ${r.error} (${r.message})`, r);
 }
+/** A refusal that says nothing about the request, only that the server couldn't be reached. */
+function unreachable(r) {
+    const error = r instanceof MlsDriverError ? r.refusal?.error : r?.error;
+    return error === "offline" || error === "timeout" ? error : null;
+}
 function toHex(bytes) {
     return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
@@ -107,6 +116,35 @@ export function createMlsDmDriver(options) {
     const reconciled = new Set();
     const seen = new Set();
     const welcomeWaiters = new Map();
+    const flights = new Set();
+    let waitingForServer = false;
+    let stopped = false;
+    const paused = new Set();
+    const giveUpMs = options.sendGiveUpMs ?? SEND_GIVE_UP_MS;
+    function setWaiting(next) {
+        if (waitingForServer === next)
+            return;
+        waitingForServer = next;
+        events.onWaiting?.(next);
+    }
+    /** Until `start()` has caught up again, or `ms`. Fails at the deadline or on `stop()`. */
+    function pause(deadline, ms) {
+        return new Promise((resolve, reject) => {
+            const left = deadline - Date.now();
+            if (stopped || left <= 0)
+                return reject(stopped ? stoppedError() : gaveUpError());
+            const done = (then) => {
+                clearTimeout(timer);
+                paused.delete(entry);
+                then();
+            };
+            const entry = { resume: () => done(resolve), fail: (e) => done(() => reject(e)) };
+            const timer = setTimeout(() => (Date.now() >= deadline ? entry.fail(gaveUpError()) : entry.resume()), Math.min(left, ms));
+            paused.add(entry);
+        });
+    }
+    const gaveUpError = () => new MlsDriverError("offline", "The server didn't answer in time, so the message wasn't sent.");
+    const stoppedError = () => new MlsDriverError("stopped", "This connection has closed.");
     async function ownDevice() {
         if (device)
             return device;
@@ -255,7 +293,14 @@ export function createMlsDmDriver(options) {
                 }
             }
         }
-        else if (!(e.senderServerUserId === self && e.senderDeviceId === d.deviceId) && e.epoch >= open.rec.joinedEpoch) {
+        else if (e.senderServerUserId === self && e.senderDeviceId === d.deviceId) {
+            // A send whose answer never came: the log says it landed, so it isn't sent again.
+            for (const f of flights) {
+                if (f.conversationId === open.rec.conversationId && f.seq === null && f.message && sameBytes(f.message, e.data))
+                    f.seq = e.seq;
+            }
+        }
+        else if (e.epoch >= open.rec.joinedEpoch) {
             let plaintext = null;
             try {
                 const r = await processMlsMessage(open.state, e.data);
@@ -569,12 +614,50 @@ export function createMlsDmDriver(options) {
         }
         if (!registered)
             throw new MlsDriverError("no_device", "This device isn't registered for MLS here. Call start() first.");
-        await ensureOpen(conversationId);
+        if (stopped)
+            throw stoppedError();
+        const deadline = Date.now() + giveUpMs;
+        const flight = { conversationId, message: null, seq: null };
+        flights.add(flight);
+        try {
+            for (;;) {
+                try {
+                    return await sendOnce(flight, peer, plaintext, attachmentIds);
+                }
+                catch (e) {
+                    const why = unreachable(e);
+                    if (!why || stopped)
+                        throw e;
+                    // Offline waits for the next start(). A timeout goes again soon, as the same bytes.
+                    if (why === "offline")
+                        setWaiting(true);
+                    await pause(deadline, why === "offline" ? Infinity : RESEND_AFTER_MS);
+                }
+            }
+        }
+        finally {
+            flights.delete(flight);
+        }
+    }
+    /* Encrypted at most once, and only once the group is caught up. Every later attempt sends
+       the same bytes, which the server takes as a repeat rather than a second message. */
+    async function sendOnce(flight, peer, plaintext, attachmentIds) {
+        const { conversationId } = flight;
+        if (!flight.message)
+            await ensureOpen(conversationId);
         return run(conversationId, async () => {
             const d = await ownDevice();
             const open = await load(conversationId);
             if (!open || !(await catchUp(open)))
                 throw new MlsDriverError("not_in_group", "This device isn't in that group.");
+            if (flight.seq !== null)
+                return { seq: flight.seq };
+            if (flight.message) {
+                const r = await transport.send({ conversationId, deviceId: d.deviceId, message: flight.message, attachmentIds });
+                if (!r.ok)
+                    throw refused("Sending", r);
+                return { seq: r.seq };
+            }
             if (!reconciled.has(conversationId))
                 await reconcile(open, peer, true);
             const people = await peopleIn(conversationId, open.state);
@@ -589,6 +672,7 @@ export function createMlsDmDriver(options) {
             open.state = out.state;
             // The generation is used up whether or not the send arrives, so the state is saved first.
             await save(open);
+            flight.message = out.message;
             const r = await transport.send({ conversationId, deviceId: d.deviceId, message: out.message, attachmentIds });
             if (!r.ok)
                 throw refused("Sending", r);
@@ -806,6 +890,15 @@ export function createMlsDmDriver(options) {
                         await catchUp(open);
                 });
             }
+            // Caught up, so the sends that waited go now, on top of that.
+            setWaiting(false);
+            for (const p of [...paused])
+                p.resume();
+        },
+        stop() {
+            stopped = true;
+            for (const p of [...paused])
+                p.fail(stoppedError());
         },
         modeFor,
         send,

package/dist/mls/interfaces.d.ts

@@ -51,8 +51,8 @@ export interface MlsClaimedKeyPackage extends MlsDeviceRef {
     lastResort: boolean;
 }
 /**
- * One method per mls:* request. The app adds `accessToken`, emits, and resolves with the ack,
- * turning ArrayBuffers into Uint8Arrays. Pushes go to the driver's `handle*` methods instead.
+ * One method per mls:* request: add `accessToken`, emit, resolve with the ack. Pushes go to `handle*`.
+ * Disconnected, answer `offline` without emitting; with no ack in time, answer `timeout`.
  */
 export interface MlsTransport {
     publishKeyPackages(req: {
@@ -230,6 +230,8 @@ export interface MlsDmEvents {
         seq: number;
         reason: string;
     }): void;
+    /** Sends are held until the connection is back and `start()` has caught up, or not any more. */
+    onWaiting?(waiting: boolean): void;
     /** This device is out of the group: removed, or its state couldn't keep up. */
     onGroupLost?(info: {
         conversationId: string;
@@ -309,13 +311,18 @@ export interface MlsDmDriverOptions {
     capability: MlsServerCapability | null;
     /** The first time only: `createMlsDevice` from @gryt/crypto, so the seed stays in the app. */
     newDevice(): MlsDeviceRecord | Promise<MlsDeviceRecord>;
+    /** How long a send waits for the server before it fails with `offline`. Five minutes. */
+    sendGiveUpMs?: number;
 }
 /** One per server. Calls for one conversation run one at a time, in order. */
 export interface MlsDmDriver {
     /** On connect: register, top up KeyPackages, take waiting Welcomes, catch up every group. */
     start(): Promise<void>;
     modeFor(conversationId: string, peerServerUserId: string): Promise<DmSealingMode>;
-    /** Opens the group if need be, adds or removes devices that changed, then sends. */
+    /**
+     * Opens the group if need be, adds or removes devices that changed, then sends. Offline, it
+     * waits for the next `start()` and encrypts after that. It goes out once, or fails `offline`.
+     */
     send(conversationId: string, peerServerUserId: string, plaintext: Uint8Array, options?: {
         attachmentIds?: readonly string[];
     }): Promise<{
@@ -337,4 +344,6 @@ export interface MlsDmDriver {
      * Throws `not_own_device` for a device the server doesn't list as yours, or not under your person key.
      */
     addOwnDevice(deviceId: string, options?: MlsAddOwnDeviceOptions): Promise<MlsOwnDeviceAdd[]>;
+    /** Sends still waiting fail with `stopped`, and no more are taken. For a session going away. */
+    stop(): void;
 }

package/dist/pairing/approver.js

@@ -2,6 +2,17 @@ import { base64Url, base64UrlDecode, createPairingKey, decodePairingSessionId, e
 import { mailbox, openJson, PairingEnded, reasonFor, systemClock } from "./channel.js";
 import { PAIRING_APPROVAL_MS } from "./newDevice.js";
 const NOT_LISTED_RETRIES = 5;
+/** auth#46's codes that get a named reason. Anything else it can answer still falls
+    through to the generic `approve:<code>`. */
+const APPROVE_ERROR_REASONS = {
+    code_used: "code_used",
+    unknown_code: "code_expired",
+    expired_code: "code_expired",
+    code_not_pending: "code_expired",
+    required_actions: "required_actions",
+    stale_token: "stale_token",
+    rate_limited: "rate_limited",
+};
 /** A: claims the session, shows N and the emoji, and on Approve seals the envelope, signs N in and adds it. */
 export function createApproverPairing(options) {
     const { relay, fetch, devices } = options;
@@ -107,7 +118,8 @@ export function createApproverPairing(options) {
         if (res.status === 404)
             return false;
         const body = (await res.json().catch(() => null));
-        throw new PairingEnded(`approve:${typeof body?.error === "string" ? body.error : res.status}`);
+        const code = typeof body?.error === "string" ? body.error : String(res.status);
+        throw new PairingEnded(APPROVE_ERROR_REASONS[code] ?? `approve:${code}`);
     }
     async function addEverywhere(ready) {
         const added = {};

package/dist/pairing/interfaces.d.ts

@@ -70,5 +70,18 @@ export interface PairedServerDevice {
 export type OwnDeviceAdder = (host: string) => {
     addOwnDevice(deviceId: string, options?: MlsAddOwnDeviceOptions): Promise<MlsOwnDeviceAdd[]>;
 } | undefined;
-/** Why a pairing stopped. `approve:<error>` carries the extension's own error code. */
-export type PairingEndReason = "cancelled" | "cancelled_by_other" | "mismatch" | "timed_out" | "expired" | "already_claimed" | "unknown_code" | "wrong_relay" | "newer_version" | "not_pairing" | "rate_limited" | "tampered" | "wrong_account" | "sign_in_failed" | "relay_error" | `approve:${string}`;
+/** Why a pairing stopped. `approve:<error>` carries the extension's own error code for anything
+    below that isn't broken out on its own (GRYT-1578; auth#46 has the full list). */
+export type PairingEndReason = "cancelled" | "cancelled_by_other" | "mismatch" | "timed_out" | "expired" | "already_claimed" | "unknown_code" | "wrong_relay" | "newer_version" | "not_pairing" | "rate_limited" | "tampered" | "wrong_account" | "sign_in_failed" | "relay_error"
+/** The approve endpoint says this user_code already got its one answer. */
+ | "code_used"
+/** The approve endpoint says the user_code isn't valid any more: unknown, expired, or not pending. */
+ | "code_expired"
+/** The approve endpoint refuses because the account has something pending, like verifying an email. */
+ | "required_actions"
+/** The approve endpoint refuses A's access token as too old; refresh it and try again. */
+ | "stale_token"
+/** The device grant itself said no: A denied it, or the approve endpoint's refusal denied the code. */
+ | "access_denied"
+/** The device grant's user_code ran out before anyone answered it. */
+ | "expired_token" | `approve:${string}`;

package/dist/pairing/newDevice.js

@@ -116,10 +116,15 @@ export function createNewDevicePairing(options) {
                     throw failure;
                 if (polled.status === "ok")
                     return checkIdToken(polled.tokens, account, session.keycloakNonce);
+                // RFC 8628's own two terminal errors, plus what auth#46 leaves behind when A's approve
+                // endpoint refuses the code: either way N's device grant sees it as denied.
+                if (polled.status === "denied")
+                    throw new PairingEnded("access_denied");
+                if (polled.status === "expired")
+                    throw new PairingEnded("expired_token");
                 if (polled.status === "slow_down")
                     interval += 5000;
-                else if (polled.status !== "pending")
-                    break;
+                // Anything else is "pending": keep polling.
             }
             throw new PairingEnded("sign_in_failed");
         }

package/dist/testing.d.ts

@@ -0,0 +1 @@
+export { FakeDeliveryService, MemoryMlsStore } from "./mls/deliveryService.fake.js";

package/dist/testing.js

@@ -0,0 +1,3 @@
+/* For the apps' own tests: the in-memory delivery service and state store the driver's tests
+   use, so a session can run the real driver against it. Not for app code. */
+export { FakeDeliveryService, MemoryMlsStore } from "./mls/deliveryService.fake.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gryt/core",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Gryt's shared application logic: one implementation of the things the desktop and mobile apps both do.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -14,6 +14,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
     }
   },
   "files": [
@@ -35,7 +39,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@gryt/crypto": "0.8.0",
+    "@gryt/crypto": "0.9.0",
     "@noble/hashes": "^2.3.0"
   }
 }