@gryt/core 0.14.0 → 0.16.0

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.d.ts

@@ -1,6 +1,6 @@
 import { type PairingEmoji, type PairingEnvelope } from "@gryt/crypto";
 import type { MlsOwnDeviceAdd } from "../mls/interfaces.js";
-import type { OwnDeviceAdder, PairingClock, PairingDeviceInfo, PairingEndReason, PairingFetch } from "./interfaces.js";
+import type { HistoryArchive, HistoryNotedMessage, HistoryProgress, OwnDeviceAdder, PairingClock, PairingDeviceInfo, PairingEndReason, PairingFetch } from "./interfaces.js";
 import type { PairingRelay } from "./relayClient.js";
 export type ApproverState = {
     phase: "idle";
@@ -34,6 +34,12 @@ export type ApproverState = {
     host: string;
     done: number;
     total: number;
+}
+/** N is in every conversation; the history's tail is still going. Progress is on `history`. */
+ | {
+    phase: "sending";
+    device: PairingDeviceInfo;
+    added: Record<string, MlsOwnDeviceAdd[]>;
 } | {
     phase: "done";
     device: PairingDeviceInfo;
@@ -51,10 +57,19 @@ export interface ApproverOptions {
     devices: OwnDeviceAdder;
     clock?: PairingClock;
     approvalMs?: number;
+    /** A's archive. Without it, no history goes across. */
+    history?: HistoryArchive;
+    /** How long after the adds A keeps collecting old-epoch messages for the last tail. */
+    lateWindowMs?: number;
 }
 export interface ApproverPairing {
     readonly state: ApproverState;
     subscribe(listener: (state: ApproverState) => void): () => void;
+    /** Null until Approve, or with no archive. */
+    readonly history: HistoryProgress | null;
+    subscribeHistory(listener: (progress: HistoryProgress) => void): () => void;
+    /** Every MLS message A archives while this runs, received or sent, for the tail. */
+    noteMessage(message: HistoryNotedMessage): void;
     /** A scanned QR, or a typed code. */
     claim(input: {
         qr: string;

package/dist/pairing/approver.js

@@ -1,7 +1,22 @@
 import { base64Url, base64UrlDecode, createPairingKey, decodePairingSessionId, encodePairingEnvelope, encodePairingSessionId, parsePairingCode, parsePairingQr, startApproverSession, } from "@gryt/crypto";
-import { mailbox, openJson, PairingEnded, reasonFor, systemClock } from "./channel.js";
+import { mailbox, openJson, PairingEnded, reasonFor, sealJson, systemClock } from "./channel.js";
+import { createHistorySender, createTailRecorder } from "./historySender.js";
 import { PAIRING_APPROVAL_MS } from "./newDevice.js";
 const NOT_LISTED_RETRIES = 5;
+/** How long Approve may spend sealing history before the envelope goes, so it lands in N's window. */
+const ENVELOPE_BUDGET_MS = 5_000;
+const HISTORY_LATE_WINDOW_MS = 60_000;
+/** 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;
@@ -13,6 +28,15 @@ export function createApproverPairing(options) {
     let current = null;
     let device = null;
     let confirming = null;
+    let deadline = 0;
+    let history = null;
+    const historyListeners = new Set();
+    const tail = createTailRecorder();
+    const setHistory = (progress) => {
+        history = progress;
+        for (const l of historyListeners)
+            l(progress);
+    };
     const set = (next) => {
         if (state.phase === "ended" || state.phase === "done")
             return;
@@ -75,7 +99,7 @@ export function createApproverPairing(options) {
         const hello = openJson(current.session, await box.next(abort.signal, clock.now() + approvalMs), "hello");
         const text = (v) => (typeof v === "string" ? v.slice(0, 100) : "");
         device = { name: text(hello.name), app: text(hello.app), platform: text(hello.platform) };
-        const deadline = clock.now() + approvalMs;
+        deadline = clock.now() + approvalMs;
         set({ phase: "confirming", device, location: claimed.location, yourLocation: claimed.yourLocation, emoji: current.session.emoji, deadline });
         // N sends nothing more until A approves, so a message or a close here means something's off.
         confirming = new AbortController();
@@ -107,7 +131,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 = {};
@@ -132,9 +157,37 @@ export function createApproverPairing(options) {
         }
         return added;
     }
+    /** Each group's cursor on every server in the envelope: the snapshot covers up to there. */
+    async function positions(envelope) {
+        const snap = new Map();
+        for (const { host } of envelope.servers) {
+            const driver = devices(host);
+            if (driver)
+                snap.set(host, new Map((await driver.groupPositions()).map((p) => [p.conversationId, p.seq])));
+        }
+        return snap;
+    }
+    function startHistory(archive) {
+        const { id, token, session } = current;
+        return createHistorySender({
+            relay, id, token, archive, clock, signal: abort.signal,
+            post: (message) => relay.post(id, token, { type: "sealed", body: sealJson(session, message) }),
+            onProgress: setHistory,
+        });
+    }
     async function approve(envelope, accessToken) {
         const { id, token, box, session } = current;
         set({ phase: envelope.account ? "signing_in" : "waiting_ready", device: device });
+        let sender = null;
+        let snap = new Map();
+        if (options.history) {
+            // Recording starts before the positions are read, so nothing lands between the two unseen.
+            tail.start();
+            snap = await positions(envelope);
+            sender = startHistory(options.history);
+            const chunks = await sender.forEnvelope(Math.min(clock.now() + ENVELOPE_BUDGET_MS, deadline - 10_000));
+            envelope = { ...envelope, history: { key: sender.key, manifest: { v: 1, chunks } } };
+        }
         await relay.post(id, token, { type: "sealed", body: base64Url(session.seal(encodePairingEnvelope(envelope))) });
         if (envelope.account && accessToken) {
             const message = await box.next(abort.signal, clock.now() + approvalMs);
@@ -151,10 +204,20 @@ export function createApproverPairing(options) {
         const ready = openJson(session, await box.next(abort.signal), "ready");
         const list = Array.isArray(ready.devices) ? ready.devices : [];
         const named = list.filter((d) => typeof d?.host === "string" && typeof d?.deviceId === "string");
+        sender?.startPaging();
         const added = await addEverywhere(named);
+        if (!sender) {
+            set({ phase: "done", device: device, added });
+            session.close();
+            return void (await closeQuietly());
+        }
+        set({ phase: "sending", device: device, added });
+        await sender.send(tail.take(snap, added), false);
+        await clock.sleep(options.lateWindowMs ?? HISTORY_LATE_WINDOW_MS, abort.signal);
+        await sender.send(tail.take(snap, added), true);
+        // N closes the session once it has every chunk; closing here would delete them.
         set({ phase: "done", device: device, added });
         session.close();
-        await closeQuietly();
     }
     return {
         get state() {
@@ -164,6 +227,14 @@ export function createApproverPairing(options) {
             listeners.add(listener);
             return () => void listeners.delete(listener);
         },
+        get history() {
+            return history;
+        },
+        subscribeHistory(listener) {
+            historyListeners.add(listener);
+            return () => void historyListeners.delete(listener);
+        },
+        noteMessage: (message) => tail.note(message),
         claim(input) {
             if (state.phase !== "idle")
                 throw new Error("This pairing has claimed a session already.");

package/dist/pairing/channel.d.ts

@@ -10,7 +10,7 @@ export declare const systemClock: PairingClock;
 export declare function reasonFor(error: unknown): PairingEndReason;
 export declare function sealJson(session: PairingSession, value: Record<string, unknown>): string;
 /** The next sealed message as JSON with a `t`, or a throw that ends the pairing as tampered. */
-export declare function openJson(session: PairingSession, message: RelayMessage | null, t: string): Record<string, unknown>;
+export declare function openJson(session: PairingSession, message: RelayMessage | null, t?: string): Record<string, unknown>;
 /** The other side's messages in order, long-polling the relay. `next` gives null once `deadline` passes. */
 export declare function mailbox(relay: PairingRelay, id: string, token: string, clock: PairingClock): {
     next(signal: AbortSignal, deadline?: number): Promise<RelayMessage | null>;

package/dist/pairing/channel.js

@@ -41,7 +41,8 @@ export function openJson(session, message, t) {
         if (message?.type !== "sealed" || !message.body)
             throw new Error();
         const value = JSON.parse(new TextDecoder().decode(session.open(base64UrlDecode(message.body))));
-        if (value && typeof value === "object" && value.t === t)
+        const got = value && typeof value === "object" ? value.t : undefined;
+        if (typeof got === "string" && (t === undefined || got === t))
             return value;
     }
     catch {

package/dist/pairing/historyReceiver.d.ts

@@ -0,0 +1,34 @@
+import { type HistoryChunkEntry } from "@gryt/crypto";
+import type { HistoryProgress, HistorySink, PairingClock } from "./interfaces.js";
+import { type PairingRelay } from "./relayClient.ts.js";
+export interface HistoryReceiverOptions {
+    relay: PairingRelay;
+    id: string;
+    token: string;
+    key: Uint8Array;
+    sink: HistorySink;
+    clock: PairingClock;
+    signal: AbortSignal;
+    onProgress(progress: HistoryProgress): void;
+}
+/** N: fetches each listed chunk newest first, checks it against its entry, and stores each message once. */
+export declare function createHistoryReceiver(options: HistoryReceiverOptions): {
+    done: Promise<void>;
+    progress: () => {
+        messages: number;
+        total: number | null;
+        chunks: number;
+        listed: number;
+        missing: number;
+        refused: number;
+        truncated: boolean;
+        oldest: number | null;
+        complete: boolean;
+    };
+    /** The envelope's manifest: slots 0 onwards, in order. */
+    listManifest(chunks: readonly HistoryChunkEntry[]): void;
+    /** One of A's history messages. Throws `tampered` for anything off. */
+    list(message: Record<string, unknown>): void;
+    /** The session is gone: whatever is still listed won't arrive. */
+    abandon: () => void;
+};

package/dist/pairing/historyReceiver.js

@@ -0,0 +1,139 @@
+import { openHistoryChunk, parseHistoryChunkEntry } from "@gryt/crypto";
+import { PairingEnded } from "./channel.js";
+import { emptyProgress } from "./historySender.js";
+import { PairingRelayError } from "./relayClient.js";
+const MAX_NETWORK_RETRIES = 5;
+const messageKey = (r) => JSON.stringify([r.scope, r.conversationId, r.messageId]);
+/** N: fetches each listed chunk newest first, checks it against its entry, and stores each message once. */
+export function createHistoryReceiver(options) {
+    const { relay, id, token, key, sink, clock, signal } = options;
+    const progress = emptyProgress();
+    const pending = new Map();
+    const slots = new Set();
+    const chunkIds = new Set();
+    const stored = new Set();
+    let final = false;
+    let stopped = false;
+    let wake = null;
+    const report = () => options.onProgress({ ...progress });
+    const nudge = () => (wake?.(), (wake = null));
+    function add(n, value) {
+        let entry;
+        try {
+            entry = parseHistoryChunkEntry(value);
+        }
+        catch {
+            throw new PairingEnded("tampered");
+        }
+        // A slot or chunk listed twice is either a replay or a bug; neither gets a second look.
+        if (!Number.isSafeInteger(n) || n < 0 || slots.has(n) || chunkIds.has(entry.id))
+            throw new PairingEnded("tampered");
+        slots.add(n);
+        chunkIds.add(entry.id);
+        pending.set(n, entry);
+        progress.listed++;
+    }
+    async function fetchChunk(n) {
+        for (let failures = 0;;) {
+            try {
+                return await relay.getChunk(id, token, n, signal);
+            }
+            catch (e) {
+                if (e instanceof PairingRelayError && e.status === 404)
+                    return "missing";
+                if (e instanceof PairingRelayError && e.status === 410)
+                    return "gone";
+                if (!(e instanceof PairingRelayError && e.code === "network") || ++failures > MAX_NETWORK_RETRIES)
+                    throw e;
+                await clock.sleep(2000, signal);
+            }
+        }
+    }
+    /** The newest listed chunk, so recent conversations fill in first. */
+    function next() {
+        let best = null;
+        for (const item of pending)
+            if (!best || item[1].last > best[1].last)
+                best = item;
+        return best;
+    }
+    function abandon() {
+        progress.missing += pending.size;
+        pending.clear();
+        stopped = true;
+        report();
+        nudge();
+    }
+    async function run() {
+        for (;;) {
+            if (signal.aborted || stopped)
+                return;
+            const item = next();
+            if (!item) {
+                if (final)
+                    return void ((progress.complete = true), report());
+                await new Promise((resolve) => (wake = resolve));
+                continue;
+            }
+            const [n, entry] = item;
+            const sealed = await fetchChunk(n);
+            if (sealed === "gone")
+                return abandon();
+            pending.delete(n);
+            if (sealed === "missing") {
+                progress.missing++;
+                report();
+                continue;
+            }
+            let records;
+            try {
+                records = openHistoryChunk(key, entry, sealed);
+            }
+            catch {
+                progress.refused++;
+                report();
+                continue;
+            }
+            const fresh = records.filter((r) => !stored.has(messageKey(r)));
+            if (fresh.length > 0)
+                await sink.put(fresh);
+            for (const r of fresh)
+                stored.add(messageKey(r));
+            progress.chunks++;
+            progress.messages += fresh.length;
+            progress.oldest = Math.min(progress.oldest ?? entry.first, entry.first);
+            report();
+            relay.deleteChunk(id, token, n).catch(() => undefined);
+        }
+    }
+    signal.addEventListener("abort", nudge, { once: true });
+    const done = run();
+    done.catch(() => undefined);
+    return {
+        done,
+        progress: () => ({ ...progress }),
+        /** The envelope's manifest: slots 0 onwards, in order. */
+        listManifest(chunks) {
+            chunks.forEach((entry, n) => add(n, entry));
+            report();
+            nudge();
+        },
+        /** One of A's history messages. Throws `tampered` for anything off. */
+        list(message) {
+            if (final || !Array.isArray(message.chunks))
+                throw new PairingEnded("tampered");
+            for (const chunk of message.chunks)
+                add(chunk?.n, chunk);
+            if (Number.isSafeInteger(message.total))
+                progress.total = message.total;
+            if (message.truncated === true)
+                progress.truncated = true;
+            if (message.final === true)
+                final = true;
+            report();
+            nudge();
+        },
+        /** The session is gone: whatever is still listed won't arrive. */
+        abandon,
+    };
+}

package/dist/pairing/historySender.d.ts

@@ -0,0 +1,65 @@
+import { type HistoryChunkEntry, type HistoryRecord } from "@gryt/crypto";
+import type { MlsOwnDeviceAdd } from "../mls/interfaces.js";
+import type { HistoryArchive, HistoryNotedMessage, HistoryProgress, PairingClock } from "./interfaces.js";
+import { type PairingRelay } from "./relayClient.ts.js";
+/** The relay's 256 MiB per session, less room for the tail. */
+export declare const HISTORY_SNAPSHOT_MAX_BYTES: number;
+/** Entries in the envelope's manifest and in each later message, which keep under 256 and 64 KiB. */
+export declare const HISTORY_ENVELOPE_ENTRIES = 400;
+export declare const HISTORY_PAGE_ENTRIES = 180;
+/** One chunk as a history message lists it: its relay slot and its manifest entry. */
+export interface ListedChunk extends HistoryChunkEntry {
+    n: number;
+}
+/** What A posts after the envelope, sealed. `final` says nothing more is coming. */
+export interface HistoryMessage {
+    t: "history";
+    chunks: ListedChunk[];
+    total?: number;
+    truncated?: boolean;
+    final?: boolean;
+}
+export declare const emptyProgress: () => HistoryProgress;
+export interface HistorySenderOptions {
+    relay: PairingRelay;
+    id: string;
+    token: string;
+    archive: HistoryArchive;
+    clock: PairingClock;
+    signal: AbortSignal;
+    /** Seals and posts one message. The sender calls it one at a time, in order. */
+    post(message: HistoryMessage): Promise<void>;
+    onProgress(progress: HistoryProgress): void;
+    maxBytes?: number;
+}
+/** A: seals the archive into chunks newest first, uploads each, then lists it to N. */
+export declare function createHistorySender(options: HistorySenderOptions): {
+    key: Uint8Array<ArrayBufferLike>;
+    progress: () => {
+        messages: number;
+        total: number | null;
+        chunks: number;
+        listed: number;
+        missing: number;
+        refused: number;
+        truncated: boolean;
+        oldest: number | null;
+        complete: boolean;
+    };
+    /** Waits until `until` or the end of the snapshot, whichever is first, and hands over what's up. */
+    forEnvelope(until: number): Promise<HistoryChunkEntry[]>;
+    /** After N's "ready": list what's waiting, and keep listing as pages fill. */
+    startPaging(): void;
+    /** The tail: records past the snapshot. `final` waits for the snapshot and says that's all. */
+    send(records: HistoryRecord[], final: boolean): Promise<void>;
+};
+/**
+ * A's record of MLS messages it archived during the transfer. The tail is every one past the
+ * snapshot that N can't read: before N's add, or sent in an older epoch that landed after it.
+ */
+export declare function createTailRecorder(): {
+    start: () => undefined;
+    note(message: HistoryNotedMessage): void;
+    /** Everything noted since the last call that N needs. `snap` and `added` are per host. */
+    take(snap: Map<string, Map<string, number>>, added: Record<string, MlsOwnDeviceAdd[]>): HistoryRecord[];
+};