@gryt/core 0.13.0 → 0.15.0

package/README.md

@@ -49,15 +49,30 @@ goes missing **and** when one appears that nobody listed.
   space on the phone, which is a key one of them could collide on.
 - **`mls`** — the DM half of MLS stage 1. It keeps a device's KeyPackages
   topped up, opens a DM group, joins from a Welcome, sends, and reads the group
-  log in order. Each app hands it the socket, the storage and the pins through
+  log in order. For linking a device, `addOwnDevice` puts a new device of yours
+  in every DM straight away and says where in each group's log it went in.
+  `groupPositions` says where each log stood when the history snapshot was
+  taken. Each app hands it the socket, the storage and the pins through
   the interfaces in `src/mls/interfaces.ts`. `mlsPinsFromPeerPins` builds the
   pins from the peer pins `@gryt/crypto` already keeps.
   `encodeMlsDmContent` and `decodeMlsDmContent` write and read what goes inside
   each message, so both apps use the same JSON: a message, an edit, a delete or
   a reaction. `readMlsDmContent` also says when something came from a newer app,
   so it can be skipped quietly rather than counted as broken. `applyMlsReaction` puts a reaction on a message in the archive,
-  since the server never sees one. It's the one module with a
-  dependency, `@gryt/crypto`, pinned exactly the way the apps pin it.
+  since the server never sees one. It depends on `@gryt/crypto`, pinned
+  exactly the way the apps pin it.
+- **`pairing`** — linking a new device by QR code or short code, as
+  `docs/pairing-design.md` in `@gryt/crypto` lays it out. There's one state
+  machine per side. `createNewDevicePairing` shows the QR and code, checks the
+  emoji, opens the envelope and, for an account, signs in with the device grant
+  and checks the ID token is for the right person. It writes nothing until all
+  of that passes. `createApproverPairing` claims the session, shows who's
+  asking, seals the envelope, approves the sign-in through the Keycloak
+  extension, and adds the new device to every DM. If the extension isn't there,
+  it hands back Keycloak's own device page to open instead. The app passes in
+  `fetch`, a clock, storage and the OIDC calls through
+  `src/pairing/interfaces.ts`. History isn't in it yet. It uses
+  `@noble/hashes` for the PKCE challenge, which `@gryt/crypto` already pulls in.
 
 ## What deliberately isn't
 

package/dist/index.d.ts

@@ -14,4 +14,8 @@ export { createMlsDmDriver, MlsDriverError, type MlsDriverErrorCode } from "./ml
 export { mlsPinsFromPeerPins } from "./mls/pins.js";
 export { decodeMlsDmContent, encodeMlsDmContent, MLS_DM_CONTENT_VERSION, type MlsDmContent, readMlsDmContent, } from "./mls/content.js";
 export { applyMlsReaction, mlsReactionAction, type MlsReaction } from "./mls/reactions.js";
-export type { DmSealingMode, MlsClaimedKeyPackage, MlsDecryptedMessage, MlsDeviceRecord, MlsDeviceRef, MlsDmDriver, MlsDmDriverOptions, MlsDmEvents, MlsGroupRecord, MlsGroupView, MlsKeyPackageRecord, MlsListedDevice, MlsLogEntry, MlsOwnDevice, MlsPins, MlsRefusal, MlsReply, MlsServerCapability, MlsStateStore, MlsTransport, MlsWelcomeDelivery, } from "./mls/interfaces.js";
+export type { DmSealingMode, MlsAddOwnDeviceOptions, MlsClaimedKeyPackage, MlsDecryptedMessage, MlsDeviceRecord, MlsDeviceRef, MlsDmDriver, MlsDmDriverOptions, MlsDmEvents, MlsGroupPosition, MlsGroupRecord, MlsGroupView, MlsKeyPackageRecord, MlsListedDevice, MlsLogEntry, MlsOwnDevice, MlsOwnDeviceAdd, MlsPins, MlsRefusal, MlsReply, MlsServerCapability, MlsStateStore, MlsTransport, MlsWelcomeDelivery, } from "./mls/interfaces.js";
+export { createApproverPairing, type ApproverOptions, type ApproverPairing, type ApproverState, } from "./pairing/approver.js";
+export { createNewDevicePairing, PAIRING_APPROVAL_MS, type NewDeviceOptions, type NewDevicePairing, type NewDeviceState, } from "./pairing/newDevice.js";
+export { createPairingRelay, PairingRelayError, type PairingRelay } from "./pairing/relayClient.js";
+export type { DeviceAuthorization, DeviceTokenPoll, OwnDeviceAdder, PairedServerDevice, PairingClock, PairingDeviceInfo, PairingEndReason, PairingFetch, PairingOidc, PairingStorage, PairingTokens, } from "./pairing/interfaces.js";

package/dist/index.js

@@ -16,3 +16,6 @@ export { createMlsDmDriver, MlsDriverError } from "./mls/dmDriver.js";
 export { mlsPinsFromPeerPins } from "./mls/pins.js";
 export { decodeMlsDmContent, encodeMlsDmContent, MLS_DM_CONTENT_VERSION, readMlsDmContent, } from "./mls/content.js";
 export { applyMlsReaction, mlsReactionAction } from "./mls/reactions.js";
+export { createApproverPairing, } from "./pairing/approver.js";
+export { createNewDevicePairing, PAIRING_APPROVAL_MS, } from "./pairing/newDevice.js";
+export { createPairingRelay, PairingRelayError } from "./pairing/relayClient.js";

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" | "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. */