@chisquare-tech/yan-ngx-apps-messages 0.1.1 → 0.2.0

package/fesm2022/{chisquare-tech-yan-ngx-apps-messages-chisquare-tech-yan-ngx-apps-messages-BYCxC81Q.mjs → chisquare-tech-yan-ngx-apps-messages-chisquare-tech-yan-ngx-apps-messages-BBsDA0CG.mjs}

@@ -5,10 +5,10 @@ import { firstValueFrom } from 'rxjs';
 
 /** Mounted at `messages`. `to/:userId` opens (or starts) the direct conversation with someone, then replaces itself. */
 const MESSAGES_ROUTES = [
-    { path: '', pathMatch: 'full', loadComponent: () => import('./chisquare-tech-yan-ngx-apps-messages-messages.page-Dy0RhQwj.mjs').then((m) => m.MessagesPage) },
-    { path: 'requests', loadComponent: () => import('./chisquare-tech-yan-ngx-apps-messages-messages.page-Dy0RhQwj.mjs').then((m) => m.MessagesPage) },
-    { path: 'to/:userId', loadComponent: () => import('./chisquare-tech-yan-ngx-apps-messages-start.page-D97JIFrb.mjs').then((m) => m.StartPage) },
-    { path: ':id', loadComponent: () => import('./chisquare-tech-yan-ngx-apps-messages-messages.page-Dy0RhQwj.mjs').then((m) => m.MessagesPage) },
+    { path: '', pathMatch: 'full', loadComponent: () => import('./chisquare-tech-yan-ngx-apps-messages-messages.page-Dc4cpq4L.mjs').then((m) => m.MessagesPage) },
+    { path: 'requests', loadComponent: () => import('./chisquare-tech-yan-ngx-apps-messages-messages.page-Dc4cpq4L.mjs').then((m) => m.MessagesPage) },
+    { path: 'to/:userId', loadComponent: () => import('./chisquare-tech-yan-ngx-apps-messages-start.page-Dnv52Der.mjs').then((m) => m.StartPage) },
+    { path: ':id', loadComponent: () => import('./chisquare-tech-yan-ngx-apps-messages-messages.page-Dc4cpq4L.mjs').then((m) => m.MessagesPage) },
 ];
 
 // The `dm` channel of Yan's one WebSocket (/ws, cloud/server/realtime): auth with an access token in the first frame
@@ -124,6 +124,15 @@ class DmSocket {
 //  - its plaintext:  {"t":"yan.room_key","conversationId","epoch","sessionId","sessionKey",
 //                     "sender":{"userId","deviceId","ed25519"},"recipient":{"userId","deviceId","ed25519"}}
 //  - a message's Megolm plaintext: {"v":1,"conversationId","kind","text"}
+//  - history for a new device of yours (owner-approved, "Verifying a new device" in the yan-e2ee README):
+//      new → old  {"t":"yan.history_request","requestId","commitment":sha256(n2),"requester":Party}
+//      old → new  {"t":"yan.history_challenge","requestId","nonce":n1,"approver":Party,"recipient":Party}
+//      new → old  {"t":"yan.history_reveal","requestId","nonce":n2,"requester":Party,"recipient":Party}
+//      both show verification_code("yan.verify.v1|user|newDevice|newEd|oldDevice|oldEd|n1|n2"); the person allows
+//      it on the old device, which then sends
+//      old → new  {"t":"yan.forwarded_room_keys","requestId","keys":[{conversationId,sessionId,senderUserId,
+//                  senderDeviceId,exported}],"sender":Party,"recipient":Party}
+//    The commitment means neither side (nor a server posing as one) can steer the code.
 // A room key is accepted only when it names this device as the recipient and its sender matches the device that
 // sent it (its keys as the server published them, signed by itself). A message is shown only when its session's
 // conversation and sender match the message's own.
@@ -164,6 +173,9 @@ function keysToGenerate(onServer, target = KEY_TARGET) {
     return onServer >= target / 2 ? 0 : target - onServer;
 }
 const MAX_OLM_PER_PEER = 5;
+/** forwarded sessions per to-device message (each well under the server's 64 KB) */
+const KEYS_PER_MESSAGE = 40;
+const verifyText = (userId, requester, approver, n1, n2) => `yan.verify.v1|${userId}|${requester.deviceId}|${requester.ed25519}|${approver.deviceId}|${approver.ed25519}|${n1}|${n2}`;
 /** One person's encryption on one device. */
 class E2eeMachine {
     constructor(o) {
@@ -479,6 +491,27 @@ class E2eeMachine {
     async receive(it) {
         if (it.type !== OLM)
             return { added: 0, newSession: false };
+        const { from, plaintext, newSession } = await this.openOlm(it);
+        const msg = JSON.parse(plaintext);
+        const me = { userId: this.userId, deviceId: this.dev.deviceId, ed25519: this.ed };
+        const sender = { userId: from.userId, deviceId: from.deviceId, ed25519: from.ed25519 };
+        switch (msg.t) {
+            case 'yan.room_key':
+                return { added: await this.roomKey(msg, me, sender), newSession };
+            case 'yan.history_request':
+            case 'yan.history_challenge':
+            case 'yan.history_reveal':
+            case 'yan.forwarded_room_keys':
+                // only between your own devices
+                if (from.userId !== this.userId || from.deviceId === this.dev.deviceId)
+                    throw new Error('history from someone else');
+                return { added: await this.history(msg, me, sender, from), newSession };
+            default:
+                throw new Error('unknown payload');
+        }
+    }
+    /** Decrypts an Olm to-device payload from a device whose keys check out. */
+    async openOlm(it) {
         const env = JSON.parse(it.body);
         if (env.v !== 1)
             throw new Error('unknown envelope');
@@ -491,15 +524,13 @@ class E2eeMachine {
         }
         if (!from)
             throw new Error('unknown sender device');
-        let plaintext = null;
-        let newSession = false;
         const rec = await this.olmSessions(from.curve25519);
         for (const s of rec.sessions) {
             const sess = this.w.Session.from_pickle(s.pickle, this.key);
             try {
-                plaintext = sess.decrypt(env.type, env.body);
+                const plaintext = sess.decrypt(env.type, env.body);
                 await this.saveOlm(from.curve25519, sess, rec);
-                break;
+                return { from, plaintext, newSession: false };
             }
             catch {
                 // not this session
@@ -508,47 +539,248 @@ class E2eeMachine {
                 sess.free();
             }
         }
-        if (plaintext === null) {
-            if (env.type !== 0)
-                throw new Error('no session for this message');
-            const acct = this.account();
-            try {
-                const inbound = acct.create_inbound_session(from.curve25519, env.type, env.body);
-                plaintext = inbound.plaintext;
-                const sess = inbound.take_session();
-                await this.saveDevice(acct); // its one-time key is spent
-                await this.saveOlm(from.curve25519, sess, rec);
-                sess.free();
-                newSession = true;
-            }
-            finally {
-                acct.free();
-            }
+        if (env.type !== 0)
+            throw new Error('no session for this message');
+        const acct = this.account();
+        try {
+            const inbound = acct.create_inbound_session(from.curve25519, env.type, env.body);
+            const plaintext = inbound.plaintext;
+            const sess = inbound.take_session();
+            await this.saveDevice(acct); // its one-time key is spent
+            await this.saveOlm(from.curve25519, sess, rec);
+            sess.free();
+            return { from, plaintext, newSession: true };
+        }
+        finally {
+            acct.free();
         }
-        const k = JSON.parse(plaintext);
-        const problem = roomKeyProblem(k, { userId: this.userId, deviceId: this.dev.deviceId, ed25519: this.ed }, { userId: from.userId, deviceId: from.deviceId, ed25519: from.ed25519 });
+    }
+    async roomKey(k, me, from) {
+        const problem = roomKeyProblem(k, me, from);
         if (problem)
             throw new Error(problem);
         const ib = new this.w.InboundGroupSession(k.sessionKey);
         try {
             if (ib.session_id !== k.sessionId)
                 throw new Error('session id mismatch');
-            const existing = await this.store.get(`in:${k.sessionId}`);
-            if (existing) {
-                const e = JSON.parse(existing);
-                if (e.senderUserId !== from.userId || e.senderDeviceId !== from.deviceId || e.conversationId !== k.conversationId)
-                    throw new Error('session claimed by another sender');
-                if (e.firstIndex <= ib.first_known_index)
-                    return { added: 0, newSession };
-            }
-            const r = { pickle: ib.pickle(this.key), conversationId: k.conversationId, senderUserId: from.userId, senderDeviceId: from.deviceId, firstIndex: ib.first_known_index };
-            await this.store.set(`in:${k.sessionId}`, JSON.stringify(r));
-            return { added: 1, newSession };
+            return await this.keep(ib, k.conversationId, from.userId, from.deviceId);
         }
         finally {
             ib.free();
         }
     }
+    /** Stores an inbound session unless we hold one that opens as much or more. */
+    async keep(ib, conversationId, senderUserId, senderDeviceId) {
+        const id = ib.session_id;
+        const existing = await this.store.get(`in:${id}`);
+        if (existing) {
+            const e = JSON.parse(existing);
+            if (e.senderUserId !== senderUserId || e.senderDeviceId !== senderDeviceId || e.conversationId !== conversationId)
+                throw new Error('session claimed by another sender');
+            if (e.firstIndex <= ib.first_known_index)
+                return 0;
+        }
+        const r = { pickle: ib.pickle(this.key), conversationId, senderUserId, senderDeviceId, firstIndex: ib.first_known_index };
+        await this.store.set(`in:${id}`, JSON.stringify(r));
+        return 1;
+    }
+    // ---- history for a new device of yours ----
+    async sendOlm(to, payload) {
+        const sessions = await this.olmTo(to);
+        const messages = [];
+        const sent = [];
+        for (const d of to) {
+            const s = sessions.get(d.curve25519);
+            if (!s)
+                continue;
+            const sealed = s.encrypt(JSON.stringify(payload(d)));
+            await this.saveOlm(d.curve25519, s);
+            s.free();
+            messages.push({ userId: d.userId, deviceId: d.deviceId, type: OLM, body: JSON.stringify({ v: 1, type: sealed.message_type, body: sealed.body }) });
+            sent.push(d.deviceId);
+        }
+        for (let i = 0; i < messages.length; i += 200)
+            await this.api.sendToDevice(this.dev.deviceId, messages.slice(i, i + 200));
+        return sent;
+    }
+    party(d) {
+        return { userId: d.userId, deviceId: d.deviceId, ed25519: d.ed25519 };
+    }
+    /**
+     * Asks your other devices for the keys to messages sent before this one was set up. Each that answers agrees a code
+     * with this device; you allow it there after checking the codes match. Answers false when there's nobody to ask.
+     */
+    requestHistory() {
+        return this.lock(async () => {
+            this.forgetDevices(this.userId);
+            const mine = (await this.devicesOf(this.userId)).filter((d) => d.deviceId !== this.dev.deviceId);
+            if (!mine.length) {
+                await this.store.set('history:out', JSON.stringify({ requestId: '', nonce: '', startedAt: new Date().toISOString(), asked: [], codes: {}, received: 0 }));
+                return false;
+            }
+            const req = { requestId: 'h_' + randomB64(12), nonce: randomB64(16), startedAt: new Date().toISOString(), asked: [], codes: {}, received: 0 };
+            const me = { userId: this.userId, deviceId: this.dev.deviceId, ed25519: this.ed };
+            req.asked = await this.sendOlm(mine, () => ({ t: 'yan.history_request', requestId: req.requestId, commitment: this.w.sha256_base64(req.nonce), requester: me }));
+            await this.store.set('history:out', JSON.stringify(req));
+            return req.asked.length > 0;
+        });
+    }
+    /** Where this device's request for history stands. */
+    historyStatus() {
+        return this.lock(async () => {
+            const raw = await this.store.get('history:out');
+            if (!raw)
+                return { state: 'none', codes: [], received: 0 };
+            const r = JSON.parse(raw);
+            if (!r.requestId)
+                return { state: 'alone', codes: [], received: 0 };
+            const names = new Map((await this.devicesOf(this.userId)).map((d) => [d.deviceId, d.name || 'Another device']));
+            return {
+                state: r.done ? 'received' : 'asked',
+                codes: Object.entries(r.codes).map(([deviceId, code]) => ({ deviceId, deviceName: names.get(deviceId) ?? 'Another device', code })),
+                received: r.received,
+            };
+        });
+    }
+    /** New devices of yours waiting for you to allow them here, each with the code it should be showing. */
+    pendingApprovals() {
+        return this.lock(async () => {
+            const out = [];
+            const devices = await this.devicesOf(this.userId);
+            for (const k of await this.store.keys('history:in:')) {
+                const r = JSON.parse((await this.store.get(k)));
+                if (r.state !== 'ready' || !r.code)
+                    continue;
+                const d = devices.find((x) => x.deviceId === r.requester.deviceId && x.ed25519 === r.requester.ed25519);
+                if (!d)
+                    continue; // signed out since
+                out.push({ requestId: r.requestId, deviceId: d.deviceId, deviceName: d.name || 'A new device', code: r.code, createdAt: r.createdAt });
+            }
+            return out;
+        });
+    }
+    /** You checked the codes match: send that device every session key this one holds. Answers how many. */
+    approveHistory(requestId) {
+        return this.lock(async () => {
+            const key = `history:in:${requestId}`;
+            const raw = await this.store.get(key);
+            if (!raw)
+                throw new Error('no such request');
+            const r = JSON.parse(raw);
+            if (r.state !== 'ready')
+                throw new Error('this request is not waiting');
+            const d = (await this.devicesOf(this.userId)).find((x) => x.deviceId === r.requester.deviceId && x.ed25519 === r.requester.ed25519);
+            if (!d)
+                throw new Error('that device is gone');
+            const keys = [];
+            for (const k of await this.store.keys('in:')) {
+                const rec = JSON.parse((await this.store.get(k)));
+                const ib = this.w.InboundGroupSession.from_pickle(rec.pickle, this.key);
+                keys.push({ conversationId: rec.conversationId, sessionId: ib.session_id, senderUserId: rec.senderUserId, senderDeviceId: rec.senderDeviceId, exported: ib.export() });
+                ib.free();
+            }
+            const me = { userId: this.userId, deviceId: this.dev.deviceId, ed25519: this.ed };
+            // at least one message, so the new device hears back even when there's nothing to forward
+            for (let i = 0; i === 0 || i < keys.length; i += KEYS_PER_MESSAGE) {
+                await this.sendOlm([d], () => ({ t: 'yan.forwarded_room_keys', requestId, keys: keys.slice(i, i + KEYS_PER_MESSAGE), sender: me, recipient: this.party(d) }));
+            }
+            r.state = 'sent';
+            await this.store.set(key, JSON.stringify(r));
+            return keys.length;
+        });
+    }
+    /** Not yours, or you don't want it to read your history: nothing is sent. */
+    denyHistory(requestId) {
+        return this.lock(async () => {
+            const key = `history:in:${requestId}`;
+            const raw = await this.store.get(key);
+            if (!raw)
+                return;
+            await this.store.set(key, JSON.stringify({ ...JSON.parse(raw), state: 'denied' }));
+        });
+    }
+    async history(m, me, sender, from) {
+        const requestId = typeof m['requestId'] === 'string' ? m['requestId'] : '';
+        if (!/^h_[A-Za-z0-9+/]{16}$/.test(requestId))
+            throw new Error('bad request id');
+        switch (m.t) {
+            case 'yan.history_request': {
+                // an existing device: a new one of yours asks; answer with our nonce, then wait for theirs
+                if (!same(m['requester'], sender))
+                    throw new Error('requester mismatch');
+                const key = `history:in:${requestId}`;
+                if (await this.store.get(key))
+                    return 0;
+                const r = { requestId, requester: sender, commitment: String(m['commitment'] ?? ''), nonce: randomB64(16), state: 'challenged', createdAt: new Date().toISOString() };
+                await this.store.set(key, JSON.stringify(r));
+                await this.sendOlm([from], () => ({ t: 'yan.history_challenge', requestId, nonce: r.nonce, approver: me, recipient: sender }));
+                return 0;
+            }
+            case 'yan.history_challenge': {
+                // the new device: an existing one answered; reveal our nonce, and show the code
+                if (!same(m['approver'], sender) || !same(m['recipient'], me))
+                    throw new Error('challenge mismatch');
+                const raw = await this.store.get('history:out');
+                const out = raw ? JSON.parse(raw) : null;
+                if (!out || out.requestId !== requestId || out.codes[sender.deviceId])
+                    return 0;
+                out.codes[sender.deviceId] = this.w.verification_code(verifyText(this.userId, me, sender, String(m['nonce']), out.nonce));
+                await this.store.set('history:out', JSON.stringify(out));
+                await this.sendOlm([from], () => ({ t: 'yan.history_reveal', requestId, nonce: out.nonce, requester: me, recipient: sender }));
+                return 0;
+            }
+            case 'yan.history_reveal': {
+                // an existing device: check the nonce against the commitment; the request now waits for you to allow it
+                if (!same(m['requester'], sender) || !same(m['recipient'], me))
+                    throw new Error('reveal mismatch');
+                const key = `history:in:${requestId}`;
+                const raw = await this.store.get(key);
+                const r = raw ? JSON.parse(raw) : null;
+                if (!r || r.state !== 'challenged' || !same(r.requester, sender))
+                    return 0;
+                const n2 = String(m['nonce'] ?? '');
+                if (this.w.sha256_base64(n2) !== r.commitment) {
+                    r.state = 'denied';
+                    await this.store.set(key, JSON.stringify(r));
+                    throw new Error('the nonce does not match its commitment');
+                }
+                r.code = this.w.verification_code(verifyText(this.userId, sender, me, r.nonce, n2));
+                r.state = 'ready';
+                await this.store.set(key, JSON.stringify(r));
+                return 0;
+            }
+            case 'yan.forwarded_room_keys': {
+                // the new device: only from a device we agreed a code with, for our request
+                if (!same(m['sender'], sender) || !same(m['recipient'], me))
+                    throw new Error('forward mismatch');
+                const raw = await this.store.get('history:out');
+                const out = raw ? JSON.parse(raw) : null;
+                if (!out || out.requestId !== requestId || !out.codes[sender.deviceId])
+                    throw new Error('keys nobody asked for');
+                let added = 0;
+                for (const k of m['keys'] ?? []) {
+                    let ib = null;
+                    try {
+                        ib = this.w.InboundGroupSession.import(k.exported);
+                        if (ib.session_id !== k.sessionId)
+                            continue;
+                        added += await this.keep(ib, k.conversationId, k.senderUserId, k.senderDeviceId);
+                    }
+                    catch (e) {
+                        this.log(`forwarded key ${k.sessionId}: ${e.message}`);
+                    }
+                    finally {
+                        ib?.free();
+                    }
+                }
+                out.received += added;
+                out.done = true;
+                await this.store.set('history:out', JSON.stringify(out));
+                return added;
+            }
+        }
+        return 0;
+    }
     /** Decrypts a message; when its key hasn't arrived, reads the inbox once and tries again. */
     decrypt(msg) {
         return this.lock(async () => {
@@ -586,6 +818,11 @@ class E2eeMachine {
         });
     }
 }
+function randomB64(bytes) {
+    const b = new Uint8Array(bytes);
+    crypto.getRandomValues(b);
+    return btoa(String.fromCharCode(...b)).replace(/=+$/, '');
+}
 /** web_ + 16 random hex characters. */
 function randomDeviceId() {
     const b = new Uint8Array(8);
@@ -629,6 +866,10 @@ function idbStore(userId) {
         get: (key) => req(KV, 'readonly', (s) => s.get(k(key))),
         set: (key, value) => req(KV, 'readwrite', (s) => s.put(value, k(key))),
         del: (key) => req(KV, 'readwrite', (s) => s.delete(k(key))),
+        keys: async (prefix) => {
+            const all = await req(KV, 'readonly', (s) => s.getAllKeys(IDBKeyRange.bound(k(prefix), k(prefix) + '\uffff')));
+            return all.map((x) => String(x).slice(userId.length + 1));
+        },
     };
 }
 /** This person's pickle key on this browser, made on first use. */
@@ -840,6 +1081,10 @@ class MessagingApi {
     uploadKeys(deviceId, body) {
         return this.send('POST', `/devices/${encodeURIComponent(deviceId)}/keys`, body);
     }
+    /** Signs this device out of messaging: its keys and inbox go from the server. */
+    async revokeDevice(deviceId) {
+        await this.send('DELETE', `/devices/${encodeURIComponent(deviceId)}`);
+    }
     async keyCount(deviceId) {
         try {
             return await this.get(`/devices/${encodeURIComponent(deviceId)}/keys/count`);
@@ -902,8 +1147,12 @@ class MessagesStore {
         /** conversation id → who is typing there */
         this.typing = signal({}, ...(ngDevMode ? [{ debugName: "typing" }] : /* istanbul ignore next */ []));
         this.crypto = signal('idle', ...(ngDevMode ? [{ debugName: "crypto" }] : /* istanbul ignore next */ []));
-        /** For the nav badge: unread conversations plus waiting requests. */
-        this.badge = computed(() => this.inbox().reduce((n, c) => n + (c.unread > 0 ? 1 : 0), 0) + this.requests().length, ...(ngDevMode ? [{ debugName: "badge" }] : /* istanbul ignore next */ []));
+        /** New devices of yours asking, here, for your message history. */
+        this.approvals = signal([], ...(ngDevMode ? [{ debugName: "approvals" }] : /* istanbul ignore next */ []));
+        /** This device's request for history (when it can't read older messages). */
+        this.history = signal({ state: 'none', codes: [], received: 0 }, ...(ngDevMode ? [{ debugName: "history" }] : /* istanbul ignore next */ []));
+        /** For the nav badge: unread conversations, waiting requests, and devices asking for your history. */
+        this.badge = computed(() => this.inbox().reduce((n, c) => n + (c.unread > 0 ? 1 : 0), 0) + this.requests().length + this.approvals().length, ...(ngDevMode ? [{ debugName: "badge" }] : /* istanbul ignore next */ []));
         this.threads = new Map();
         this.machine = null;
         this.machineUser = null;
@@ -941,7 +1190,33 @@ class MessagesStore {
         if (this.machineUser && this.machineUser !== me)
             this.stop();
         void this.loadLists();
-        void this.ensureMachine().then(() => this.openSocket(), () => undefined);
+        void this.ensureMachine().then(async (m) => {
+            this.openSocket();
+            // what arrived while this device was away (room keys, history requests)
+            await m.sync().catch(() => 0);
+            await this.refreshHistory();
+        }, () => undefined);
+    }
+    /**
+     * Signing out on purpose: this device leaves messaging (the server drops its keys and inbox) and the browser forgets
+     * its keys, so nobody using it next can read your messages. Signing in again makes a new device, which reads older
+     * messages once you allow it from another device.
+     */
+    async signOutDevice() {
+        const me = this.me();
+        if (!me)
+            return;
+        this.stop();
+        try {
+            const raw = await idbStore(me).get('device');
+            const id = raw ? JSON.parse(raw).deviceId : undefined;
+            if (id)
+                await this.api.revokeDevice(id).catch(() => undefined);
+            await forget(me);
+        }
+        catch {
+            // storage unavailable: nothing was kept here
+        }
     }
     /** Signing out, or another person signing in. */
     stop() {
@@ -954,6 +1229,8 @@ class MessagesStore {
         this.inbox.set([]);
         this.requests.set([]);
         this.previews.set({});
+        this.approvals.set([]);
+        this.history.set({ state: 'none', codes: [], received: 0 });
         this.loaded.set(false);
     }
     /** This device's encryption: loads the wasm module, then opens (or makes and publishes) the device's keys. */
@@ -1074,6 +1351,8 @@ class MessagesStore {
             const items = await this.open(page.items.slice().reverse());
             t.set({ conv, items: this.keepPending(t().items, items), next: page.next, loading: false, failed: false, missing: false });
             this.markRead(conv, items);
+            if (items.some((b) => b.unreadable === 'missing-key'))
+                void this.askForHistory();
         }
         catch (e) {
             const status = e.status;
@@ -1216,6 +1495,35 @@ class MessagesStore {
         this.requests.update((l) => l.filter((x) => x.id !== id));
         this.threads.delete(id);
     }
+    // ---- history for a new device ----
+    /** Asks your other devices for older messages' keys, once per page load unless you ask again. */
+    async askForHistory(again = false) {
+        const m = await this.machine?.catch(() => null);
+        if (!m)
+            return;
+        const st = await m.historyStatus();
+        if (!again && st.state !== 'none')
+            return void this.history.set(st);
+        await m.requestHistory().catch(() => false);
+        await this.refreshHistory();
+    }
+    async approve(requestId) {
+        const m = await this.ensureMachine();
+        await m.approveHistory(requestId);
+        await this.refreshHistory();
+    }
+    async deny(requestId) {
+        const m = await this.ensureMachine();
+        await m.denyHistory(requestId);
+        await this.refreshHistory();
+    }
+    async refreshHistory() {
+        const m = await this.machine?.catch(() => null);
+        if (!m)
+            return;
+        this.approvals.set(await m.pendingApprovals().catch(() => []));
+        this.history.set(await m.historyStatus().catch(() => this.history()));
+    }
     // ---- typing ----
     typed(id) {
         const now = Date.now();
@@ -1293,6 +1601,7 @@ class MessagesStore {
         if (!m)
             return;
         await m.sync().catch(() => 0);
+        await this.refreshHistory();
         for (const t of this.threads.values()) {
             if (!t().items.some((b) => b.state === 'unreadable'))
                 continue;
@@ -1354,4 +1663,4 @@ function randomHex(n) {
  */
 
 export { E2EE_LABEL as E, MessagesStore as M, OLM as O, MESSAGES_HOST as a, personName as b, conversationName as c, errorText as d, expiresIn as e, errorCode as f, E2eeMachine as g, MEGOLM as h, MESSAGES_API_BASE as i, MESSAGES_E2EE_WASM as j, kindLabel as k, MESSAGES_ROUTES as l, MESSAGES_SOCIAL_BASE as m, MessagingApi as n, others as o, pendingFor as p, forget as q, requestsLine as r, seen as s };
-//# sourceMappingURL=chisquare-tech-yan-ngx-apps-messages-chisquare-tech-yan-ngx-apps-messages-BYCxC81Q.mjs.map
+//# sourceMappingURL=chisquare-tech-yan-ngx-apps-messages-chisquare-tech-yan-ngx-apps-messages-BBsDA0CG.mjs.map