@chisquare-tech/yan-ngx-apps-messages 0.0.0-stage → 0.1.0

package/fesm2022/chisquare-tech-yan-ngx-apps-messages-chisquare-tech-yan-ngx-apps-messages-BtQC73sF.mjs

@@ -0,0 +1,1357 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable, NgZone, signal, computed } from '@angular/core';
+import { HttpClient, HttpErrorResponse } from '@angular/common/http';
+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-L0fDp0gv.mjs').then((m) => m.MessagesPage) },
+    { path: 'requests', loadComponent: () => import('./chisquare-tech-yan-ngx-apps-messages-messages.page-L0fDp0gv.mjs').then((m) => m.MessagesPage) },
+    { path: 'to/:userId', loadComponent: () => import('./chisquare-tech-yan-ngx-apps-messages-start.page-gJ1cJDfy.mjs').then((m) => m.StartPage) },
+    { path: ':id', loadComponent: () => import('./chisquare-tech-yan-ngx-apps-messages-messages.page-L0fDp0gv.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
+// (never in the URL), subscribe, answer pings, and on a drop reconnect with backoff and resume from the last seq.
+// Frames carry ids, never content.
+class DmSocket {
+    constructor(o) {
+        this.ws = null;
+        this.attempt = 0;
+        this.timer = null;
+        this.closed = false;
+        this.o = o;
+    }
+    start() {
+        this.closed = false;
+        void this.connect();
+    }
+    stop() {
+        this.closed = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.ws?.close();
+        this.ws = null;
+    }
+    async connect() {
+        if (this.closed)
+            return;
+        const token = await this.o.token().catch(() => null);
+        if (!token || this.closed)
+            return this.retry();
+        let ws;
+        try {
+            ws = new WebSocket(this.o.url());
+        }
+        catch {
+            return this.retry();
+        }
+        this.ws = ws;
+        ws.onopen = () => ws.send(JSON.stringify({ v: 1, t: 'auth', token, device: this.o.device() }));
+        ws.onmessage = (e) => {
+            let f;
+            try {
+                f = JSON.parse(String(e.data));
+            }
+            catch {
+                return;
+            }
+            if (f.t === 'ping')
+                return ws.send(JSON.stringify({ v: 1, t: 'pong' }));
+            if (f.t === 'ready') {
+                const since = this.seq;
+                return ws.send(JSON.stringify(since === undefined ? { v: 1, t: 'sub', ch: 'dm' } : { v: 1, t: 'sub', ch: 'dm', since }));
+            }
+            if (f.ch !== 'dm')
+                return;
+            if (f.t === 'subscribed') {
+                this.attempt = 0;
+                const cur = f.seq ?? 0;
+                if (this.seq === undefined)
+                    this.seq = cur; // first time: from now on
+                else if (cur < this.seq) {
+                    // the server restarted and its numbering with it: what we missed can't be replayed
+                    this.seq = cur;
+                    this.o.onResync();
+                }
+                // otherwise the frames after our seq are replayed next
+                return;
+            }
+            if (f.t === 'resync') {
+                this.seq = f.seq;
+                return this.o.onResync();
+            }
+            if (f.t === 'error')
+                return;
+            if (typeof f.seq === 'number') {
+                if (this.seq !== undefined && f.seq > this.seq + 1)
+                    this.o.onResync();
+                this.seq = Math.max(this.seq ?? 0, f.seq);
+            }
+            this.o.onEvent({ t: f.t, id: f.id, d: f.d });
+        };
+        ws.onclose = () => {
+            if (this.ws === ws)
+                this.ws = null;
+            this.retry();
+        };
+    }
+    retry() {
+        if (this.closed || this.timer)
+            return;
+        const delay = Math.min(30_000, 1000 * 2 ** this.attempt) * (0.5 + Math.random() / 2);
+        this.attempt = Math.min(this.attempt + 1, 6);
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.connect();
+        }, delay);
+    }
+}
+
+// End-to-end encryption for Yan's DMs (PLAN P1.7, TRD §5.8; owner decision 2026-11-06: Olm/Megolm via vodozemac,
+// @chisquare-tech/yan-e2ee). Framework-free, so the same code runs in the browser and in node tests: the wasm module,
+// storage, the server API and the lock are all passed in.
+//
+// The model is Matrix's:
+//  - Each device has an Olm account. It publishes signed identity keys, signed one-time keys and a fallback key.
+//  - Each device sending to a conversation has a Megolm group session per epoch (the server bumps the epoch on every
+//    membership change), rotated after ROTATE_AFTER messages. Its key goes to every member device over Olm, through
+//    that device's to-device inbox, before the first message that device should read.
+//  - Messages are Megolm ciphertext. The server stores and relays what it can't read.
+//
+// Envelopes (version 1). The Android and iOS clients must produce exactly these:
+//  - to-device body: JSON {"v":1,"type":0|1,"body":"<olm ciphertext>"} (type 0 is a pre-key message)
+//  - 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"}
+// 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.
+const OLM = 'm.olm.v1.curve25519-aes-sha2';
+const MEGOLM = 'm.megolm.v1.aes-sha2';
+/** One-time keys a device keeps on the server; topped up when it falls below half. */
+const KEY_TARGET = 50;
+/** Messages per group session before a new one (Matrix's default is 100 too). */
+const ROTATE_AFTER = 100;
+/** A lock for one process. */
+function localLock() {
+    let tail = Promise.resolve();
+    return (fn) => {
+        const run = tail.then(fn, fn);
+        tail = run.catch(() => undefined);
+        return run;
+    };
+}
+// ---- pure rules (also used by tests) ----
+const deviceSigningText = (userId, deviceId, curve, ed) => `yan.device.v1|${userId}|${deviceId}|${curve}|${ed}`;
+const keySigningText = (userId, deviceId, keyId, key, fallback) => `yan.${fallback ? 'fallback' : 'otk'}.v1|${userId}|${deviceId}|${keyId}|${key}`;
+/** A room key that arrived from `from` is for `me` and really from that device. */
+function roomKeyProblem(k, me, from) {
+    const r = k;
+    if (!r || r.t !== 'yan.room_key')
+        return 'not a room key';
+    if (typeof r.conversationId !== 'string' || typeof r.sessionId !== 'string' || typeof r.sessionKey !== 'string')
+        return 'malformed';
+    if (!same(r.recipient, me))
+        return 'meant for another device';
+    if (!same(r.sender, from))
+        return 'sender mismatch';
+    return null;
+}
+const same = (a, b) => !!a && a.userId === b.userId && a.deviceId === b.deviceId && a.ed25519 === b.ed25519;
+/** Keys to generate so the server holds about KEY_TARGET: none until it falls below half. */
+function keysToGenerate(onServer, target = KEY_TARGET) {
+    return onServer >= target / 2 ? 0 : target - onServer;
+}
+const MAX_OLM_PER_PEER = 5;
+/** One person's encryption on one device. */
+class E2eeMachine {
+    constructor(o) {
+        /** devices as the server published them and we checked them, per user, for this page's life */
+        this.deviceCache = new Map();
+        /** sessionId → message index → message id: a reused index is a replay */
+        this.seen = new Map();
+        this.w = o.wasm;
+        this.api = o.transport;
+        this.store = o.store;
+        this.key = o.pickleKey;
+        this.lock = o.lock ?? localLock();
+        this.log = o.log ?? (() => undefined);
+        this.userId = o.userId;
+        this.deviceName = o.deviceName;
+        this.newId = o.newDeviceId ?? randomDeviceId;
+    }
+    /** Loads this device's account, or makes and publishes a new one; then makes sure the server has its keys. */
+    static async open(o) {
+        const m = new E2eeMachine(o);
+        await m.lock(() => m.boot());
+        return m;
+    }
+    get deviceId() {
+        return this.dev.deviceId;
+    }
+    get ed25519() {
+        return this.ed;
+    }
+    async boot() {
+        const raw = await this.store.get('device');
+        this.dev = raw ? JSON.parse(raw) : this.fresh();
+        for (let attempt = 0;; attempt++) {
+            const acct = this.account();
+            this.ed = acct.ed25519;
+            this.curve = acct.curve25519;
+            if (!this.dev.registered) {
+                const ok = await this.api.registerDevice(this.dev.deviceId, {
+                    curve25519: this.curve,
+                    ed25519: this.ed,
+                    signature: acct.sign(deviceSigningText(this.userId, this.dev.deviceId, this.curve, this.ed)),
+                    name: this.deviceName,
+                });
+                if (!ok) {
+                    acct.free();
+                    if (attempt > 0)
+                        throw new Error('the server refused this device');
+                    this.log('device refused; starting a new one');
+                    await this.wipe();
+                    this.dev = this.fresh();
+                    continue;
+                }
+                this.dev.registered = true;
+                await this.saveDevice(acct);
+            }
+            acct.free();
+            const count = await this.api.keyCount(this.dev.deviceId);
+            if (!count) {
+                if (attempt > 0)
+                    throw new Error('the server forgot this device');
+                this.log('device unknown to the server; starting a new one');
+                await this.wipe();
+                this.dev = this.fresh();
+                continue;
+            }
+            await this.topUp(count);
+            break;
+        }
+    }
+    fresh() {
+        const acct = new this.w.Account();
+        const rec = { deviceId: this.newId(), account: acct.pickle(this.key), registered: false };
+        acct.free();
+        return rec;
+    }
+    async wipe() {
+        await this.store.del('device');
+        await this.store.del('inboxAfter');
+    }
+    account() {
+        return this.w.Account.from_pickle(this.dev.account, this.key);
+    }
+    async saveDevice(acct) {
+        this.dev.account = acct.pickle(this.key);
+        await this.store.set('device', JSON.stringify(this.dev));
+    }
+    /** Publishes one-time keys when the server is running low, and a fallback key when it has none. */
+    async topUp(count) {
+        const c = count ?? (await this.api.keyCount(this.dev.deviceId));
+        if (!c)
+            return;
+        const n = keysToGenerate(c.oneTimeKeys);
+        if (!n && c.fallback)
+            return;
+        const acct = this.account();
+        try {
+            if (n)
+                acct.generate_one_time_keys(Math.min(n, acct.max_one_time_keys()));
+            if (!c.fallback)
+                acct.generate_fallback_key();
+            const sign = (fallback) => ([keyId, key]) => ({
+                keyId,
+                key,
+                signature: acct.sign(keySigningText(this.userId, this.dev.deviceId, keyId, key, fallback)),
+            });
+            const otks = Object.entries(acct.one_time_keys()).map(sign(false));
+            const [fallbackKey] = Object.entries(acct.fallback_key()).map(sign(true));
+            if (!otks.length && !fallbackKey)
+                return;
+            // saved before upload: if the upload is lost, the same keys go next time (the server ignores repeats)
+            await this.saveDevice(acct);
+            await this.api.uploadKeys(this.dev.deviceId, { oneTimeKeys: otks, fallbackKey });
+            acct.mark_keys_as_published();
+            await this.saveDevice(acct);
+        }
+        finally {
+            acct.free();
+        }
+    }
+    // ---- devices ----
+    /** A user's devices whose keys are signed by themselves and match what this device saw before (trust on first use). */
+    devicesOf(userId) {
+        let p = this.deviceCache.get(userId);
+        if (!p) {
+            p = this.loadDevices(userId);
+            this.deviceCache.set(userId, p);
+            p.catch(() => this.deviceCache.delete(userId));
+        }
+        return p;
+    }
+    async loadDevices(userId) {
+        const out = [];
+        for (const d of await this.api.devices(userId)) {
+            if (d.userId !== userId)
+                continue;
+            if (!this.w.verify_ed25519(d.ed25519, deviceSigningText(userId, d.deviceId, d.curve25519, d.ed25519), d.signature)) {
+                this.log(`device ${userId}/${d.deviceId}: bad signature`);
+                continue;
+            }
+            const pinKey = `pin:${userId}|${d.deviceId}`;
+            const pinned = await this.store.get(pinKey);
+            const now = `${d.curve25519}|${d.ed25519}`;
+            if (pinned && pinned !== now) {
+                this.log(`device ${userId}/${d.deviceId}: keys changed`);
+                continue;
+            }
+            if (!pinned)
+                await this.store.set(pinKey, now);
+            out.push(d);
+        }
+        return out;
+    }
+    /** Forget cached device lists (someone signed in on a new device, or a membership changed). */
+    forgetDevices(userId) {
+        if (userId)
+            this.deviceCache.delete(userId);
+        else
+            this.deviceCache.clear();
+    }
+    // ---- Olm sessions ----
+    async olmSessions(curve) {
+        const raw = await this.store.get(`olm:${curve}`);
+        return raw ? JSON.parse(raw) : { sessions: [] };
+    }
+    async saveOlm(curve, s, rec) {
+        const r = rec ?? (await this.olmSessions(curve));
+        const id = s.session_id;
+        const rest = r.sessions.filter((x) => x.id !== id);
+        r.sessions = [{ id, pickle: s.pickle(this.key) }, ...rest].slice(0, MAX_OLM_PER_PEER);
+        await this.store.set(`olm:${curve}`, JSON.stringify(r));
+    }
+    /** Olm sessions to each device, opening new ones from claimed one-time keys where there are none yet. */
+    async olmTo(devices) {
+        const out = new Map();
+        const need = [];
+        for (const d of devices) {
+            const rec = await this.olmSessions(d.curve25519);
+            if (rec.sessions.length)
+                out.set(d.curve25519, this.w.Session.from_pickle(rec.sessions[0].pickle, this.key));
+            else
+                need.push(d);
+        }
+        if (!need.length)
+            return out;
+        const claimed = await this.api.claim(need.map((d) => ({ userId: d.userId, deviceId: d.deviceId })));
+        const acct = this.account();
+        try {
+            for (const k of claimed) {
+                const d = need.find((x) => x.userId === k.userId && x.deviceId === k.deviceId);
+                if (!d)
+                    continue;
+                if (!this.w.verify_ed25519(d.ed25519, keySigningText(d.userId, d.deviceId, k.keyId, k.key, !!k.fallback), k.signature)) {
+                    this.log(`claimed key for ${d.userId}/${d.deviceId}: bad signature`);
+                    continue;
+                }
+                const s = acct.create_outbound_session(d.curve25519, k.key);
+                await this.saveOlm(d.curve25519, s);
+                out.set(d.curve25519, s);
+            }
+        }
+        finally {
+            acct.free();
+        }
+        return out;
+    }
+    // ---- sending ----
+    /** Encrypts a message for a conversation, first sending the group session's key to every device that lacks it. */
+    encrypt(conv, plain) {
+        return this.lock(async () => {
+            const outKey = `out:${conv.id}`;
+            const raw = await this.store.get(outKey);
+            let rec = raw ? JSON.parse(raw) : null;
+            if (!rec || rec.epoch !== conv.epoch || rec.sent >= ROTATE_AFTER)
+                rec = await this.newOutbound(conv);
+            const group = this.w.GroupSession.from_pickle(rec.pickle, this.key);
+            try {
+                await this.share(conv, group, rec);
+                const ciphertext = group.encrypt(JSON.stringify({ v: 1, conversationId: conv.id, kind: plain.kind, text: plain.text }));
+                rec.sent++;
+                rec.pickle = group.pickle(this.key);
+                await this.store.set(outKey, JSON.stringify(rec));
+                return { senderDevice: this.dev.deviceId, algorithm: MEGOLM, sessionId: rec.sessionId, ciphertext };
+            }
+            finally {
+                group.free();
+            }
+        });
+    }
+    async newOutbound(conv) {
+        const g = new this.w.GroupSession();
+        // our own copy, so this device reads what it sent
+        const ib = new this.w.InboundGroupSession(g.session_key);
+        const mine = { pickle: ib.pickle(this.key), conversationId: conv.id, senderUserId: this.userId, senderDeviceId: this.dev.deviceId, firstIndex: ib.first_known_index };
+        await this.store.set(`in:${g.session_id}`, JSON.stringify(mine));
+        const rec = { epoch: conv.epoch, sessionId: g.session_id, pickle: g.pickle(this.key), sent: 0, shared: [] };
+        ib.free();
+        g.free();
+        return rec;
+    }
+    async share(conv, group, rec) {
+        const readers = [...new Set(conv.members.filter((m) => m.state === 'active' || m.state === 'request').map((m) => m.userId))];
+        if (!readers.includes(this.userId))
+            readers.push(this.userId); // our other devices
+        const targets = [];
+        for (const u of readers) {
+            for (const d of await this.devicesOf(u)) {
+                if (u === this.userId && d.deviceId === this.dev.deviceId)
+                    continue;
+                if (!rec.shared.includes(`${u}|${d.deviceId}|${d.curve25519}`))
+                    targets.push(d);
+            }
+        }
+        if (!targets.length)
+            return;
+        const sessions = await this.olmTo(targets);
+        const sessionKey = group.session_key; // from the current index: a new reader can't open what came before
+        const messages = [];
+        const done = [];
+        for (const d of targets) {
+            const s = sessions.get(d.curve25519);
+            if (!s)
+                continue; // no keys to claim: that device reads nothing until it publishes some
+            const k = {
+                t: 'yan.room_key',
+                conversationId: conv.id,
+                epoch: conv.epoch,
+                sessionId: rec.sessionId,
+                sessionKey,
+                sender: { userId: this.userId, deviceId: this.dev.deviceId, ed25519: this.ed },
+                recipient: { userId: d.userId, deviceId: d.deviceId, ed25519: d.ed25519 },
+            };
+            const sealed = s.encrypt(JSON.stringify(k));
+            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 }) });
+            done.push(`${d.userId}|${d.deviceId}|${d.curve25519}`);
+        }
+        for (let i = 0; i < messages.length; i += 200)
+            await this.api.sendToDevice(this.dev.deviceId, messages.slice(i, i + 200));
+        rec.shared.push(...done);
+    }
+    // ---- receiving ----
+    /** Reads this device's to-device inbox: room keys from other devices. Answers how many new keys arrived. */
+    sync() {
+        return this.lock(() => this.syncLocked());
+    }
+    async syncLocked() {
+        let after = Number((await this.store.get('inboxAfter')) ?? 0);
+        let added = 0;
+        let usedOneTimeKey = false;
+        for (;;) {
+            const items = await this.api.inbox(this.dev.deviceId, after);
+            if (!items.length)
+                break;
+            for (const it of items) {
+                try {
+                    const r = await this.receive(it);
+                    added += r.added;
+                    usedOneTimeKey ||= r.newSession;
+                }
+                catch (e) {
+                    this.log(`to-device ${it.id} from ${it.senderUserId}/${it.senderDeviceId}: ${e.message}`);
+                }
+                after = Math.max(after, it.id);
+            }
+            await this.store.set('inboxAfter', String(after));
+            await this.api.ackInbox(this.dev.deviceId, after);
+        }
+        if (usedOneTimeKey)
+            await this.topUp();
+        return added;
+    }
+    async receive(it) {
+        if (it.type !== OLM)
+            return { added: 0, newSession: false };
+        const env = JSON.parse(it.body);
+        if (env.v !== 1)
+            throw new Error('unknown envelope');
+        const find = async () => (await this.devicesOf(it.senderUserId)).find((d) => d.deviceId === it.senderDeviceId);
+        let from = await find();
+        if (!from) {
+            // a device that signed in after we last looked
+            this.forgetDevices(it.senderUserId);
+            from = await find();
+        }
+        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);
+                await this.saveOlm(from.curve25519, sess, rec);
+                break;
+            }
+            catch {
+                // not this session
+            }
+            finally {
+                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();
+            }
+        }
+        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 });
+        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 };
+        }
+        finally {
+            ib.free();
+        }
+    }
+    /** Decrypts a message; when its key hasn't arrived, reads the inbox once and tries again. */
+    decrypt(msg) {
+        return this.lock(async () => {
+            let raw = await this.store.get(`in:${msg.sessionId}`);
+            if (!raw) {
+                await this.syncLocked();
+                raw = await this.store.get(`in:${msg.sessionId}`);
+            }
+            if (!raw)
+                return { ok: false, reason: 'missing-key' };
+            const rec = JSON.parse(raw);
+            if (msg.algorithm !== MEGOLM || rec.conversationId !== msg.conversationId || rec.senderUserId !== msg.senderId || rec.senderDeviceId !== msg.senderDeviceId) {
+                return { ok: false, reason: 'invalid' };
+            }
+            const ib = this.w.InboundGroupSession.from_pickle(rec.pickle, this.key);
+            try {
+                const d = ib.decrypt(msg.ciphertext);
+                const seen = this.seen.get(msg.sessionId) ?? new Map();
+                this.seen.set(msg.sessionId, seen);
+                const prior = seen.get(d.message_index);
+                if (prior && prior !== msg.id)
+                    return { ok: false, reason: 'invalid' };
+                seen.set(d.message_index, msg.id);
+                const p = JSON.parse(d.plaintext);
+                if (p.v !== 1 || p.conversationId !== msg.conversationId || typeof p.text !== 'string')
+                    return { ok: false, reason: 'invalid' };
+                return { ok: true, kind: p.kind || 'text', text: p.text };
+            }
+            catch {
+                return { ok: false, reason: 'invalid' };
+            }
+            finally {
+                ib.free();
+            }
+        });
+    }
+}
+/** web_ + 16 random hex characters. */
+function randomDeviceId() {
+    const b = new Uint8Array(8);
+    crypto.getRandomValues(b);
+    return 'web_' + [...b].map((x) => x.toString(16).padStart(2, '0')).join('');
+}
+
+// The browser side of the encryption's storage: one IndexedDB database, keys prefixed by the person's id (several
+// people can use one browser). Every pickle is already encrypted by vodozemac with a 32-byte pickle key; that key is
+// stored wrapped by a non-extractable AES-GCM key, so its bytes never sit in storage in the clear.
+const DB = 'yan-e2ee';
+const KV = 'kv';
+const KEYS = 'keys';
+let dbp = null;
+function db() {
+    dbp ??= new Promise((resolve, reject) => {
+        const r = indexedDB.open(DB, 1);
+        r.onupgradeneeded = () => {
+            r.result.createObjectStore(KV);
+            r.result.createObjectStore(KEYS);
+        };
+        r.onsuccess = () => resolve(r.result);
+        r.onerror = () => reject(r.error);
+    });
+    dbp.catch(() => (dbp = null));
+    return dbp;
+}
+function req(store, mode, fn) {
+    return db().then((d) => new Promise((resolve, reject) => {
+        const tx = d.transaction(store, mode);
+        const r = fn(tx.objectStore(store));
+        tx.oncomplete = () => resolve(r.result);
+        tx.onerror = () => reject(tx.error);
+        tx.onabort = () => reject(tx.error);
+    }));
+}
+/** One person's encryption storage. */
+function idbStore(userId) {
+    const k = (key) => `${userId}/${key}`;
+    return {
+        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))),
+    };
+}
+/** This person's pickle key on this browser, made on first use. */
+async function pickleKey(userId) {
+    const have = await req(KEYS, 'readonly', (s) => s.get(userId));
+    if (have)
+        return new Uint8Array(await crypto.subtle.decrypt({ name: 'AES-GCM', iv: have.iv }, have.wrapper, have.sealed));
+    const raw = crypto.getRandomValues(new Uint8Array(32));
+    const wrapper = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']);
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const sealed = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, wrapper, raw);
+    await req(KEYS, 'readwrite', (s) => s.put({ wrapper, iv, sealed }, userId));
+    return raw;
+}
+/** Everything this browser holds for a person (signing out of messaging here). */
+async function forget(userId) {
+    const d = await db();
+    await new Promise((resolve, reject) => {
+        const tx = d.transaction([KV, KEYS], 'readwrite');
+        tx.objectStore(KV).delete(IDBKeyRange.bound(`${userId}/`, `${userId}/￿`));
+        tx.objectStore(KEYS).delete(userId);
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    });
+}
+/** One operation at a time across every tab of this person (a ratchet must never fork); in-tab only without Web Locks. */
+function tabLock(userId, fallback) {
+    const locks = navigator.locks;
+    if (!locks)
+        return fallback;
+    return (fn) => locks.request(`yan-e2ee:${userId}`, fn);
+}
+
+// Pure display rules for Messages (prototype Messages screen, PRD DM-1–8). No Angular, so node tests run them.
+/** How a person is shown: display name, else @username, else "Someone". */
+function personName(p) {
+    if (!p)
+        return 'Someone';
+    return p.displayName || (p.username ? '@' + p.username : 'Someone');
+}
+/** The other people in a conversation who are still in it. */
+function others(c, me) {
+    return c.members.filter((m) => m.userId !== me && (m.state === 'active' || m.state === 'request'));
+}
+/** A direct conversation is named after the other person; a group by its title, else its members. */
+function conversationName(c, me, people) {
+    if (c.kind === 'group' && c.title)
+        return c.title;
+    const names = others(c, me).map((m) => personName(people[m.userId]));
+    if (!names.length)
+        return c.kind === 'group' ? 'Group' : 'Just you';
+    if (c.kind === 'direct')
+        return names[0];
+    return names.length <= 3 ? names.join(', ') : `${names.slice(0, 2).join(', ')} and ${names.length - 2} others`;
+}
+/** The prototype's kind eyebrow. */
+function kindLabel(c) {
+    return c.kind === 'group' ? 'Group' : 'Direct';
+}
+/** Every DM and group is end-to-end encrypted (the email and community rows, which aren't, come with P2). */
+const E2EE_LABEL = { cls: 'yan-security--e2ee', icon: 'shield-lock', text: 'End-to-end encrypted' };
+/** The Requests row's second line. */
+function requestsLine(count, firstFrom) {
+    if (!count)
+        return 'No requests';
+    return `${count} waiting · ${firstFrom ?? 'Someone'}`;
+}
+/** Who will see your messages under Requests, until they accept (DM-3). */
+function pendingFor(c, me, people) {
+    const waiting = c.members.filter((m) => m.userId !== me && m.state === 'request');
+    if (!waiting.length)
+        return null;
+    if (c.kind === 'direct')
+        return `${personName(people[waiting[0].userId])} isn't in your network yet. Your messages go to their Requests until they accept.`;
+    return waiting.length === 1
+        ? `${personName(people[waiting[0].userId])} hasn't accepted yet and sees this under Requests.`
+        : `${waiting.length} people haven't accepted yet and see this under Requests.`;
+}
+/** Days left on a request (DM-3: 7), for "Expires in 3 days". */
+function expiresIn(until, now = Date.now()) {
+    if (!until)
+        return '';
+    const ms = new Date(until).getTime() - now;
+    if (ms <= 0)
+        return 'Expired';
+    const h = Math.ceil(ms / 3_600_000);
+    if (h < 24)
+        return `Expires in ${h} hour${h === 1 ? '' : 's'}`;
+    const d = Math.ceil(h / 24);
+    return `Expires in ${d} day${d === 1 ? '' : 's'}`;
+}
+/**
+ * "Seen" under your last message, when everyone else has read up to it or later. `order` is the thread's message
+ * ids, oldest first.
+ */
+function seen(c, me, order, lastMine) {
+    if (!lastMine)
+        return false;
+    const at = order.indexOf(lastMine);
+    if (at < 0)
+        return false;
+    const rest = others(c, me).filter((m) => m.state === 'active');
+    if (!rest.length)
+        return false;
+    return rest.every((m) => !!m.lastReadMessageId && order.indexOf(m.lastReadMessageId) >= at);
+}
+/** What a message that can't be shown says instead. */
+function unreadableText(reason) {
+    return reason === 'missing-key' ? "Can't be read on this device" : "Couldn't be verified, so it isn't shown";
+}
+/** A preview line for the list: the text, else a word for the kind. */
+function previewText(kind, text) {
+    if (text)
+        return text;
+    const words = { image: 'Photo', video: 'Video', file: 'File', voice: 'Voice message', link: 'Link', reaction: 'Reaction' };
+    return words[kind] ?? 'Message';
+}
+
+const MESSAGES_HOST = new InjectionToken('MESSAGES_HOST', {
+    providedIn: 'root',
+    factory: () => ({
+        userId: () => null,
+        accessToken: async () => null,
+        requestSignIn: () => undefined,
+        wsUrl: () => location.origin.replace(/^http/, 'ws') + '/ws',
+        deviceName: () => 'Web',
+    }),
+});
+/** Host-provided: base URL of the messaging API. */
+const MESSAGES_API_BASE = new InjectionToken('MESSAGES_API_BASE', {
+    providedIn: 'root',
+    factory: () => '/api/apps/messaging',
+});
+/** Host-provided: base URL of the social API (names for people known only by id). */
+const MESSAGES_SOCIAL_BASE = new InjectionToken('MESSAGES_SOCIAL_BASE', {
+    providedIn: 'root',
+    factory: () => '/api/apps/social',
+});
+/** Host-provided: where the encryption module (yan_e2ee_bg.wasm from @chisquare-tech/yan-e2ee) is served. */
+const MESSAGES_E2EE_WASM = new InjectionToken('MESSAGES_E2EE_WASM', {
+    providedIn: 'root',
+    factory: () => '/e2ee/yan_e2ee_bg.wasm',
+});
+
+/** yan-gox-apps/libs/messaging over HTTP: the conversation API, and the device-key API the encryption needs. */
+class MessagingApi {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.base = inject(MESSAGES_API_BASE);
+        this.social = inject(MESSAGES_SOCIAL_BASE);
+    }
+    async get(path, params) {
+        const p = {};
+        for (const [k, v] of Object.entries(params ?? {}))
+            if (v !== undefined && v !== '')
+                p[k] = String(v);
+        return (await firstValueFrom(this.http.get(this.base + path, { params: p }))).data;
+    }
+    async send(method, path, body) {
+        return (await firstValueFrom(this.http.request(method, this.base + path, { body }))).data;
+    }
+    // ---- conversations ----
+    conversations(box = 'inbox') {
+        return this.get('/conversations', { box: box === 'inbox' ? undefined : box });
+    }
+    conversation(id) {
+        return this.get(`/conversations/${encodeURIComponent(id)}`);
+    }
+    startDirect(userId) {
+        return this.send('POST', '/conversations', { kind: 'direct', userId });
+    }
+    accept(id) {
+        return this.send('POST', `/conversations/${encodeURIComponent(id)}/accept`, {});
+    }
+    decline(id) {
+        return this.send('POST', `/conversations/${encodeURIComponent(id)}/decline`, {});
+    }
+    messages(id, before, limit = 50) {
+        return this.get(`/conversations/${encodeURIComponent(id)}/messages`, { before, limit });
+    }
+    sendMessage(id, body) {
+        return this.send('POST', `/conversations/${encodeURIComponent(id)}/messages`, body);
+    }
+    markRead(id, messageId) {
+        return this.send('PUT', `/conversations/${encodeURIComponent(id)}/read`, { messageId });
+    }
+    typing(id) {
+        return this.send('POST', `/conversations/${encodeURIComponent(id)}/typing`, {});
+    }
+    /** Names for people known only by id; an empty list asks nothing. */
+    async people(ids) {
+        const unique = [...new Set(ids)].slice(0, 100);
+        if (!unique.length)
+            return [];
+        return (await firstValueFrom(this.http.get(`${this.social}/people`, { params: { ids: unique.join(',') } }))).data;
+    }
+    // ---- E2eeTransport ----
+    async registerDevice(deviceId, body) {
+        try {
+            await this.send('PUT', `/devices/${encodeURIComponent(deviceId)}`, body);
+            return true;
+        }
+        catch (e) {
+            if (e instanceof HttpErrorResponse && e.status === 409)
+                return false;
+            throw e;
+        }
+    }
+    uploadKeys(deviceId, body) {
+        return this.send('POST', `/devices/${encodeURIComponent(deviceId)}/keys`, body);
+    }
+    async keyCount(deviceId) {
+        try {
+            return await this.get(`/devices/${encodeURIComponent(deviceId)}/keys/count`);
+        }
+        catch (e) {
+            if (e instanceof HttpErrorResponse && e.status === 404)
+                return null;
+            throw e;
+        }
+    }
+    devices(userId) {
+        return this.get(`/users/${encodeURIComponent(userId)}/devices`);
+    }
+    claim(devices) {
+        return this.send('POST', '/keys/claim', { devices });
+    }
+    async sendToDevice(senderDevice, messages) {
+        return (await this.send('POST', '/to-device', { senderDevice, messages })).sent;
+    }
+    inbox(deviceId, after) {
+        return this.get(`/devices/${encodeURIComponent(deviceId)}/inbox`, { after, limit: 100 });
+    }
+    async ackInbox(deviceId, upTo) {
+        await this.send('POST', `/devices/${encodeURIComponent(deviceId)}/inbox/ack`, { upTo });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: MessagingApi, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: MessagingApi, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: MessagingApi, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+/** A server error's message for people, or a fallback. */
+function errorText(e, fallback) {
+    const m = e?.error?.message;
+    return m && m.length < 200 ? m : fallback;
+}
+/** An error's code from the server (e.g. cant_message), if any. */
+function errorCode(e) {
+    return e?.error?.code;
+}
+
+const PREVIEW_LIMIT = 30;
+/**
+ * Messages for the signed-in person: the lists, each open thread (decrypted on this device), sending, Requests, and
+ * live updates over the dm WebSocket channel. The server only ever sees ciphertext.
+ */
+class MessagesStore {
+    constructor() {
+        this.api = inject(MessagingApi);
+        this.host = inject(MESSAGES_HOST);
+        this.wasmUrl = inject(MESSAGES_E2EE_WASM);
+        this.zone = inject(NgZone);
+        this.inbox = signal([], ...(ngDevMode ? [{ debugName: "inbox" }] : /* istanbul ignore next */ []));
+        this.requests = signal([], ...(ngDevMode ? [{ debugName: "requests" }] : /* istanbul ignore next */ []));
+        this.loaded = signal(false, ...(ngDevMode ? [{ debugName: "loaded" }] : /* istanbul ignore next */ []));
+        this.failed = signal(false, ...(ngDevMode ? [{ debugName: "failed" }] : /* istanbul ignore next */ []));
+        this.people = signal({}, ...(ngDevMode ? [{ debugName: "people" }] : /* istanbul ignore next */ []));
+        this.previews = signal({}, ...(ngDevMode ? [{ debugName: "previews" }] : /* istanbul ignore next */ []));
+        /** 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 */ []));
+        this.threads = new Map();
+        this.machine = null;
+        this.machineUser = null;
+        this.socket = null;
+        this.refreshTimer = null;
+        this.typingTimers = new Map();
+        this.lastTypingSent = new Map();
+    }
+    me() {
+        return this.host.userId();
+    }
+    // ---- lifecycle ----
+    /** Loads the lists (enough for the nav badge). */
+    async loadLists() {
+        if (!this.me())
+            return;
+        try {
+            const [inbox, requests] = await Promise.all([this.api.conversations('inbox'), this.api.conversations('requests')]);
+            this.inbox.set(inbox);
+            this.requests.set(requests);
+            this.failed.set(false);
+            this.loaded.set(true);
+            await this.loadPeople([...inbox, ...requests].flatMap((c) => c.members.map((m) => m.userId)));
+            void this.loadPreviews([...requests, ...inbox]);
+        }
+        catch {
+            this.failed.set(true);
+        }
+    }
+    /** Everything Messages needs: the lists, this device's encryption, and live updates. */
+    async start() {
+        const me = this.me();
+        if (!me)
+            return;
+        if (this.machineUser && this.machineUser !== me)
+            this.stop();
+        void this.loadLists();
+        void this.ensureMachine().then(() => this.openSocket(), () => undefined);
+    }
+    /** Signing out, or another person signing in. */
+    stop() {
+        this.socket?.stop();
+        this.socket = null;
+        this.machine = null;
+        this.machineUser = null;
+        this.crypto.set('idle');
+        this.threads.clear();
+        this.inbox.set([]);
+        this.requests.set([]);
+        this.previews.set({});
+        this.loaded.set(false);
+    }
+    /** This device's encryption: loads the wasm module, then opens (or makes and publishes) the device's keys. */
+    ensureMachine() {
+        const me = this.me();
+        if (!me)
+            return Promise.reject(new Error('signed out'));
+        if (this.machine && this.machineUser === me)
+            return this.machine;
+        this.machineUser = me;
+        this.crypto.set('starting');
+        this.machine = (async () => {
+            const wasm = await import('@chisquare-tech/yan-e2ee');
+            await wasm.default({ module_or_path: this.wasmUrl });
+            return E2eeMachine.open({
+                wasm,
+                transport: this.api,
+                store: idbStore(me),
+                pickleKey: await pickleKey(me),
+                userId: me,
+                deviceName: this.host.deviceName(),
+                lock: tabLock(me, localLock()),
+                log: (m) => console.debug('[yan-e2ee]', m),
+            });
+        })();
+        this.machine.then(() => this.crypto.set('ready'), (e) => {
+            console.warn('[yan-e2ee] could not start', e);
+            this.machine = null;
+            this.crypto.set('failed');
+        });
+        return this.machine;
+    }
+    retryCrypto() {
+        void this.start();
+    }
+    openSocket() {
+        if (this.socket)
+            return;
+        const machine = this.machine;
+        if (!machine)
+            return;
+        let device = '';
+        void machine.then((m) => (device = m.deviceId));
+        this.zone.runOutsideAngular(() => {
+            this.socket = new DmSocket({
+                url: () => this.host.wsUrl(),
+                token: () => this.host.accessToken(),
+                device: () => device,
+                onEvent: (e) => this.zone.run(() => void this.onEvent(e)),
+                onResync: () => this.zone.run(() => void this.resync()),
+            });
+            this.socket.start();
+        });
+    }
+    // ---- people and previews ----
+    async loadPeople(ids) {
+        const have = this.people();
+        const missing = [...new Set(ids)].filter((id) => !have[id]);
+        if (!missing.length)
+            return;
+        try {
+            const got = await this.api.people(missing);
+            this.people.update((p) => ({ ...p, ...Object.fromEntries(got.map((x) => [x.userId, x])) }));
+        }
+        catch {
+            // names fall back to "Someone"
+        }
+    }
+    async loadPreviews(convs) {
+        let machine;
+        try {
+            machine = await this.ensureMachine();
+        }
+        catch {
+            return;
+        }
+        const want = convs.filter((c) => c.lastMessageId && this.previews()[c.id + '|' + c.lastMessageId] === undefined).slice(0, PREVIEW_LIMIT);
+        await Promise.all(want.map(async (c) => {
+            try {
+                const page = await this.api.messages(c.id, undefined, 1);
+                const m = page.items[0];
+                if (!m)
+                    return;
+                const o = await machine.decrypt(m);
+                const line = o.ok ? previewText(o.kind, o.text) : 'Encrypted message';
+                const mine = m.senderId === this.me();
+                this.previews.update((p) => ({ ...p, [c.id + '|' + c.lastMessageId]: (mine ? 'You: ' : '') + line }));
+            }
+            catch {
+                // no preview
+            }
+        }));
+    }
+    preview(c) {
+        if (!c.lastMessageId)
+            return 'No messages yet';
+        return this.previews()[c.id + '|' + c.lastMessageId] ?? '';
+    }
+    // ---- threads ----
+    thread(id) {
+        let t = this.threads.get(id);
+        if (!t) {
+            t = signal({ conv: this.known(id), items: [], loading: true, failed: false, missing: false });
+            this.threads.set(id, t);
+        }
+        return t;
+    }
+    known(id) {
+        return this.inbox().find((c) => c.id === id) ?? this.requests().find((c) => c.id === id) ?? null;
+    }
+    /** Loads a conversation and its newest messages, decrypted. */
+    async openThread(id) {
+        const t = this.thread(id);
+        t.update((s) => ({ ...s, loading: true, failed: false }));
+        try {
+            const [conv, page] = await Promise.all([this.api.conversation(id), this.api.messages(id)]);
+            void this.loadPeople(conv.members.map((m) => m.userId));
+            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);
+        }
+        catch (e) {
+            const status = e.status;
+            t.update((s) => ({ ...s, loading: false, failed: status !== 404, missing: status === 404 }));
+        }
+    }
+    async loadOlder(id) {
+        const t = this.thread(id);
+        const s = t();
+        if (!s.next || s.loading)
+            return;
+        t.update((x) => ({ ...x, loading: true }));
+        try {
+            const page = await this.api.messages(id, s.next);
+            const older = await this.open(page.items.slice().reverse());
+            t.update((x) => ({ ...x, items: [...older, ...x.items], next: page.next, loading: false }));
+        }
+        catch {
+            t.update((x) => ({ ...x, loading: false }));
+        }
+    }
+    /** Pending sends survive a reload of the thread. */
+    keepPending(before, now) {
+        const sent = new Set(now.map((b) => b.sealed?.clientMsgId));
+        return [...now, ...before.filter((b) => (b.state === 'pending' || b.state === 'failed') && !sent.has(b.clientMsgId))];
+    }
+    async open(msgs) {
+        let machine = null;
+        try {
+            machine = await this.ensureMachine();
+        }
+        catch {
+            // shown as unreadable until encryption starts
+        }
+        const me = this.me();
+        const out = [];
+        for (const m of msgs) {
+            const o = machine ? await machine.decrypt(m) : { ok: false, reason: 'missing-key' };
+            out.push({
+                id: m.id,
+                senderId: m.senderId,
+                mine: m.senderId === me,
+                kind: o.ok ? o.kind : m.kind,
+                text: o.ok ? o.text : unreadableText(o.reason),
+                state: o.ok ? 'ok' : 'unreadable',
+                unreadable: o.ok ? undefined : o.reason,
+                createdAt: m.createdAt,
+                sealed: m,
+            });
+        }
+        return out;
+    }
+    markRead(conv, items) {
+        const last = [...items].reverse().find((b) => b.state !== 'pending' && b.state !== 'failed');
+        if (!last || conv.myState !== 'active')
+            return;
+        const mine = conv.members.find((m) => m.userId === this.me());
+        if (mine?.lastReadMessageId === last.id && !conv.unread)
+            return;
+        void this.api.markRead(conv.id, last.id).then(() => {
+            this.inbox.update((l) => l.map((c) => (c.id === conv.id ? { ...c, unread: 0 } : c)));
+        }, () => undefined);
+    }
+    // ---- sending ----
+    async send(id, text) {
+        const body = text.trim();
+        if (!body)
+            return;
+        const t = this.thread(id);
+        const conv = t().conv;
+        if (!conv)
+            return;
+        const clientMsgId = 'c_' + randomHex(12);
+        const bubble = { id: clientMsgId, clientMsgId, senderId: this.me() ?? '', mine: true, kind: 'text', text: body, state: 'pending', createdAt: new Date().toISOString(), outgoing: { kind: 'text', text: body } };
+        t.update((s) => ({ ...s, items: [...s.items, bubble] }));
+        await this.deliver(id, bubble);
+    }
+    retry(id, b) {
+        this.thread(id).update((s) => ({ ...s, items: s.items.map((x) => (x.clientMsgId === b.clientMsgId ? { ...x, state: 'pending', error: undefined } : x)) }));
+        return this.deliver(id, b);
+    }
+    async deliver(id, b) {
+        const t = this.thread(id);
+        const patch = (p) => t.update((s) => ({ ...s, items: s.items.map((x) => (x.clientMsgId === b.clientMsgId ? { ...x, ...p } : x)) }));
+        let body = b.outgoing?.body;
+        try {
+            if (!body) {
+                // fresh members and epoch: someone added a moment ago must get this session's key
+                const conv = await this.api.conversation(id);
+                t.update((s) => ({ ...s, conv }));
+                const machine = await this.ensureMachine();
+                const enc = await machine.encrypt(keysOf(conv), { kind: b.outgoing?.kind ?? 'text', text: b.outgoing?.text ?? b.text });
+                body = { clientMsgId: b.clientMsgId, kind: b.outgoing?.kind ?? 'text', ...enc };
+                patch({ outgoing: { ...b.outgoing, body } });
+            }
+            const sent = await this.api.sendMessage(id, body);
+            // the push for it may have arrived first
+            t.update((s) => {
+                const already = s.items.some((x) => x.id === sent.id && x.clientMsgId !== b.clientMsgId);
+                const items = already
+                    ? s.items.filter((x) => x.clientMsgId !== b.clientMsgId)
+                    : s.items.map((x) => (x.clientMsgId === b.clientMsgId ? { ...x, id: sent.id, state: 'ok', sealed: sent, createdAt: sent.createdAt, outgoing: undefined } : x));
+                return { ...s, items };
+            });
+            this.bump(id, sent.id, 'You: ' + previewText(body.kind, b.outgoing?.text ?? b.text));
+        }
+        catch (e) {
+            const code = errorCode(e);
+            patch({ state: 'failed', error: code === 'cant_message' ? "You can't message this person." : this.crypto() === 'failed' ? "Messages can't be encrypted in this browser." : errorText(e, 'Not sent.') });
+        }
+    }
+    bump(id, messageId, line) {
+        const now = new Date().toISOString();
+        this.previews.update((p) => ({ ...p, [id + '|' + messageId]: line }));
+        this.inbox.update((l) => {
+            const c = l.find((x) => x.id === id);
+            if (!c)
+                return l;
+            return [{ ...c, lastMessageId: messageId, lastMessageAt: now }, ...l.filter((x) => x.id !== id)];
+        });
+    }
+    /** Starts (or finds) the direct conversation with someone. */
+    async startDirect(userId) {
+        const c = await this.api.startDirect(userId);
+        if (!this.inbox().some((x) => x.id === c.id))
+            this.inbox.update((l) => [c, ...l]);
+        this.thread(c.id).update((s) => ({ ...s, conv: c }));
+        void this.loadPeople(c.members.map((m) => m.userId));
+        return c;
+    }
+    // ---- requests ----
+    async accept(id) {
+        const c = await this.api.accept(id);
+        this.requests.update((l) => l.filter((x) => x.id !== id));
+        this.inbox.update((l) => [c, ...l.filter((x) => x.id !== id)]);
+        this.thread(id).update((s) => ({ ...s, conv: c }));
+    }
+    async decline(id) {
+        await this.api.decline(id);
+        this.requests.update((l) => l.filter((x) => x.id !== id));
+        this.threads.delete(id);
+    }
+    // ---- typing ----
+    typed(id) {
+        const now = Date.now();
+        if (now - (this.lastTypingSent.get(id) ?? 0) < 4000)
+            return;
+        this.lastTypingSent.set(id, now);
+        void this.api.typing(id).catch(() => undefined);
+    }
+    // ---- live ----
+    async onEvent(e) {
+        const conv = typeof e.d?.['conversationId'] === 'string' ? e.d['conversationId'] : undefined;
+        switch (e.t) {
+            case 'message':
+                if (conv) {
+                    // their message is here: they've stopped typing
+                    this.typing.update((t) => { const { [conv]: _, ...rest } = t; return rest; });
+                    await this.newer(conv);
+                }
+                this.refreshSoon();
+                break;
+            case 'to-device':
+                await this.keysArrived();
+                break;
+            case 'membership':
+                (await this.machine)?.forgetDevices();
+                if (conv)
+                    await this.reloadConversation(conv);
+                this.refreshSoon();
+                break;
+            case 'receipt':
+                if (conv && e.d?.['userId'] !== this.me())
+                    await this.reloadConversation(conv);
+                break;
+            case 'typing': {
+                const who = e.d?.['userId'];
+                if (!conv || typeof who !== 'string' || who === this.me())
+                    break;
+                this.typing.update((t) => ({ ...t, [conv]: who }));
+                clearTimeout(this.typingTimers.get(conv));
+                this.typingTimers.set(conv, setTimeout(() => this.typing.update((t) => { const { [conv]: _, ...rest } = t; return rest; }), 5000));
+                break;
+            }
+        }
+    }
+    /** New messages in a loaded thread. */
+    async newer(id) {
+        const t = this.threads.get(id);
+        if (!t || t().loading && !t().items.length)
+            return;
+        try {
+            const page = await this.api.messages(id, undefined, 20);
+            const have = new Set(t().items.map((b) => b.id));
+            const fresh = await this.open(page.items.filter((m) => !have.has(m.id)).reverse());
+            if (!fresh.length)
+                return;
+            t.update((s) => {
+                const byClient = new Map(fresh.filter((f) => f.mine).map((f) => [f.sealed?.clientMsgId, f]));
+                const items = s.items.filter((b) => !(b.clientMsgId && byClient.has(b.clientMsgId)));
+                const insertAt = items.findIndex((b) => b.state === 'pending' || b.state === 'failed');
+                if (insertAt < 0)
+                    return { ...s, items: [...items, ...fresh] };
+                return { ...s, items: [...items.slice(0, insertAt), ...fresh, ...items.slice(insertAt)] };
+            });
+            const c = t().conv;
+            if (c)
+                this.markRead(c, t().items);
+        }
+        catch {
+            // the next event or a reload catches up
+        }
+    }
+    /** Room keys arrived: messages that couldn't be read may open now. */
+    async keysArrived() {
+        const m = await this.machine?.catch(() => null);
+        if (!m)
+            return;
+        await m.sync().catch(() => 0);
+        for (const t of this.threads.values()) {
+            if (!t().items.some((b) => b.state === 'unreadable'))
+                continue;
+            const items = await Promise.all(t().items.map(async (b) => {
+                if (b.state !== 'unreadable' || !b.sealed)
+                    return b;
+                const o = await m.decrypt(b.sealed);
+                return o.ok ? { ...b, state: 'ok', unreadable: undefined, kind: o.kind, text: o.text } : b;
+            }));
+            t.update((s) => ({ ...s, items }));
+        }
+        void this.loadPreviews([...this.requests(), ...this.inbox()]);
+    }
+    async reloadConversation(id) {
+        const t = this.threads.get(id);
+        if (!t)
+            return;
+        try {
+            const conv = await this.api.conversation(id);
+            t.update((s) => ({ ...s, conv }));
+        }
+        catch {
+            // keep what we have
+        }
+    }
+    async resync() {
+        await this.loadLists();
+        await this.keysArrived();
+        for (const id of this.threads.keys())
+            await this.newer(id);
+    }
+    refreshSoon() {
+        if (this.refreshTimer)
+            return;
+        this.refreshTimer = setTimeout(() => {
+            this.refreshTimer = null;
+            void this.loadLists();
+        }, 400);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: MessagesStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: MessagesStore, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.12", ngImport: i0, type: MessagesStore, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+/** What the encryption needs to know about a conversation. */
+function keysOf(c) {
+    return { id: c.id, epoch: c.epoch, members: c.members.map((m) => ({ userId: m.userId, state: m.state })) };
+}
+function randomHex(n) {
+    const b = new Uint8Array(Math.ceil(n / 2));
+    crypto.getRandomValues(b);
+    return [...b].map((x) => x.toString(16).padStart(2, '0')).join('').slice(0, n);
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+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-BtQC73sF.mjs.map