@gryt/core 0.24.0 → 0.26.0

package/dist/import/discordImportJob.d.ts

@@ -27,6 +27,8 @@ export interface ImportDeps {
     store: ImportFileStore;
     sleep: (ms: number) => Promise<void>;
     newId: () => string;
+    /** Downloads and uploads running together. A phone holding each file in memory wants fewer. */
+    transfersAtOnce?: number;
 }
 export interface ImportProgress {
     messages: {

package/dist/import/discordImportJob.js

@@ -1,5 +1,5 @@
 import { importBatches } from "../mls/content.js";
-const DOWNLOADS_AT_ONCE = 4;
+const TRANSFERS_AT_ONCE = 16;
 /** `mls:send` allows about one send every two seconds sustained (RL_SEND in the server). */
 const SEND_GAP_MS = 2_000;
 const FILE_BATCH = 20;
@@ -51,7 +51,6 @@ export async function runDiscordImport(messages, deps, control, report) {
     };
     await sendAll(messages.filter((m) => m.attachments.length === 0).map((m) => ({ id: importId(m.discordId), sentAt: m.sentAt, text: m.text })));
     const missing = new Set();
-    let next = 0;
     let clearAt = 0;
     const downloadFile = async (url) => {
         for (let attempt = 0; attempt <= DOWNLOAD_RETRIES && !control.stopped(); attempt++) {
@@ -66,47 +65,51 @@ export async function runDiscordImport(messages, deps, control, report) {
         }
         return null;
     };
-    const worker = async () => {
-        while (!control.stopped()) {
-            await hold();
-            if (next >= urls.length)
-                break;
-            const url = urls[next++];
-            if (!(await deps.store.has(url))) {
-                const file = await downloadFile(url);
-                if (file) {
-                    p.bytes += file.bytes.length;
-                    await deps.store.put(url, file);
-                }
-                else {
-                    missing.add(url);
-                    p.missing = missing.size;
-                }
+    const eachAtOnce = async (run) => {
+        let next = 0;
+        await Promise.all(Array.from({ length: deps.transfersAtOnce ?? TRANSFERS_AT_ONCE }, async () => {
+            while (!control.stopped()) {
+                await hold();
+                if (next >= urls.length)
+                    break;
+                await run(urls[next++]);
             }
-            p.downloaded.done++;
-            tick();
-        }
+        }));
     };
-    await Promise.all(Array.from({ length: DOWNLOADS_AT_ONCE }, worker));
+    await eachAtOnce(async (url) => {
+        if (!(await deps.store.has(url))) {
+            const file = await downloadFile(url);
+            if (file) {
+                p.bytes += file.bytes.length;
+                await deps.store.put(url, file);
+            }
+            else {
+                missing.add(url);
+                p.missing = missing.size;
+            }
+        }
+        p.downloaded.done++;
+        tick();
+    });
     const uploaded = new Map();
+    await eachAtOnce(async (url) => {
+        const stored = missing.has(url) ? null : await deps.store.take(url);
+        if (stored) {
+            uploaded.set(url, await deps.upload({ name: nameOf(url), ...stored }));
+            await deps.store.drop(url);
+        }
+        p.sent.done++;
+        tick();
+    });
     let pending = [];
     for (const m of withFiles) {
         if (control.stopped())
             break;
         const attachments = {};
         for (const url of m.attachments) {
-            await hold();
-            let up = uploaded.get(url);
-            const stored = up || missing.has(url) ? null : await deps.store.take(url);
-            if (stored) {
-                up = await deps.upload({ name: nameOf(url), ...stored });
-                uploaded.set(url, up);
-                await deps.store.drop(url);
-            }
+            const up = uploaded.get(url);
             if (up)
                 attachments[up.id] = up.key;
-            p.sent.done++;
-            tick();
         }
         const lost = m.attachments.length - Object.keys(attachments).length;
         const note = lost ? `${lost === 1 ? "A file" : `${lost} files`} from Discord couldn’t be downloaded.` : "";

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { agreementAt, createTermsGate, GUIDELINES_URL, TERMS_STORAGE_KEY, TERMS_
 export { createMlsDmDriver, MlsDriverError, type MlsDriverErrorCode } from "./mls/dmDriver.js";
 export { mlsPinsFromPeerPins } from "./mls/pins.js";
 export { reencryptedId, reencryptMine, type ReencryptCandidate, type ReencryptDeps } from "./mls/reencrypt.js";
-export { decodeMlsDmContent, encodeMlsDmContent, acceptImport, historyBatches, importBatches, MAX_HISTORY_BATCH_BYTES, MLS_DM_CONTENT_VERSION, type MlsDmContent, type MlsHistoryEntry, type MlsImportEntry, readMlsDmContent, } from "./mls/content.js";
+export { decodeMlsDmContent, encodeMlsDmContent, acceptImport, historyBatches, importBatches, MAX_HISTORY_BATCH_BYTES, MLS_DM_CONTENT_VERSION, type MlsDmContent, type MlsHistoryEntry, type MlsHistoryReaction, type MlsImportEntry, readMlsDmContent, } from "./mls/content.js";
 export { applyMlsReaction, mlsReactionAction, type MlsReaction } from "./mls/reactions.js";
 export { type DiscordPackageDm, type DiscordPackageMessage, isDiscordPackage, linksExpireAt, listDiscordDms, type PackageFiles, readDiscordDm, } from "./import/discordPackage.js";
 export { inflateRaw, openZipBytes } from "./import/unzip.js";

package/dist/mls/content.d.ts

@@ -9,6 +9,13 @@ export interface MlsHistoryEntry {
     text: string;
     replyTo?: string;
     attachments?: Record<string, SealedAttachmentKey>;
+    /** Who reacted, as the sender's record has it. A claim, like the rest of a shared copy. */
+    reactions?: MlsHistoryReaction[];
+}
+export interface MlsHistoryReaction {
+    /** A Unicode emoji or `:name:`, what `chat:react` carries. */
+    emoji: string;
+    users: string[];
 }
 /** One message from the sender's own Discord data. Who wrote it is never in here: the reader takes the MLS sender. */
 export interface MlsImportEntry {

package/dist/mls/content.js

@@ -17,6 +17,8 @@ const isText = (v) => typeof v === "string" && v.length <= MAX_TEXT;
 const isCount = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
 const isLabel = (v) => typeof v === "string" && v.length <= MAX_LABEL;
 const MAX_HISTORY_ENTRIES = 200;
+const MAX_HISTORY_REACTIONS = 20;
+const MAX_REACTION_USERS = 50;
 /** Under what one `mls:send` takes once sealed and padded. */
 export const MAX_HISTORY_BATCH_BYTES = 48 * 1024;
 /** One emoji's worth of emoji characters, so a peer can't put a sentence on a message as a reaction. */
@@ -115,6 +117,8 @@ function historyBody(e) {
         out.replyTo = e.replyTo;
     if (e.attachments && Object.keys(e.attachments).length > 0)
         out.attachments = e.attachments;
+    if (e.reactions?.length)
+        out.reactions = e.reactions;
     return out;
 }
 function importBody(e) {
@@ -176,6 +180,25 @@ function readHistoryEntry(v) {
             return null;
         out.attachments = attachments;
     }
+    if (v.reactions !== undefined) {
+        const reactions = readHistoryReactions(v.reactions);
+        if (!reactions)
+            return null;
+        out.reactions = reactions;
+    }
+    return out;
+}
+function readHistoryReactions(v) {
+    if (!Array.isArray(v) || v.length === 0 || v.length > MAX_HISTORY_REACTIONS)
+        return null;
+    const out = [];
+    for (const r of v) {
+        if (!isObject(r) || !isReactionEmoji(r.emoji) || !Array.isArray(r.users))
+            return null;
+        if (r.users.length === 0 || r.users.length > MAX_REACTION_USERS || !r.users.every(isId))
+            return null;
+        out.push({ emoji: r.emoji, users: r.users });
+    }
     return out;
 }
 function readImportEntry(v) {

package/dist/mls/reencrypt.d.ts

@@ -11,7 +11,10 @@ export interface ReencryptCandidate {
     sealed?: string | null;
     mls_placeholder?: object | null;
     attachments?: readonly string[] | null;
-    reactions?: readonly object[] | null;
+    reactions?: readonly {
+        src: string;
+        users?: readonly string[];
+    }[] | null;
     poll?: object | null;
     pinned_at?: string | Date | null;
     thread_id?: string | null;

package/dist/mls/reencrypt.js

@@ -3,10 +3,11 @@ import { historyBatches } from "./content.js";
 const DELETE_GAP_MS = 3_100;
 const FETCH_GAP_MS = 700;
 export const reencryptedId = (messageId) => `re-${messageId}`;
-/** Plain text only: files, reactions, polls and pins can't travel in a history entry, so they stay. */
+/* Files stay: an MLS file is deleted after the server's retention, a plaintext one isn't.
+   Polls and pins live on the server's row. */
 function canMove(m, me) {
     return m.sender_server_id === me && !!m.text && !m.mls && !m.sealed && !m.mls_placeholder
-        && !m.attachments?.length && !m.reactions?.length && !m.poll && !m.pinned_at && !m.thread_id;
+        && !m.attachments?.length && !m.poll && !m.pinned_at && !m.thread_id;
 }
 async function plaintextOfMine(deps, me) {
     const out = [];
@@ -30,12 +31,14 @@ export async function reencryptMine(deps, me) {
     const originals = new Map(mine.map((m) => [reencryptedId(m.message_id), m.message_id]));
     const entries = mine.map((m) => {
         const reply = m.reply_to_message_id;
+        const reactions = (m.reactions ?? []).flatMap((r) => (r.users?.length ? [{ emoji: r.src, users: [...r.users] }] : []));
         return {
             id: reencryptedId(m.message_id),
             senderId: me,
             sentAt: new Date(m.created_at).getTime(),
             text: m.text ?? "",
             ...(reply ? { replyTo: ids.has(reply) ? reencryptedId(reply) : reply } : {}),
+            ...(reactions.length ? { reactions } : {}),
         };
     });
     const batches = historyBatches(entries, deps.newId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gryt/core",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "description": "Gryt's shared application logic: one implementation of the things the desktop and mobile apps both do.",
   "license": "AGPL-3.0-only",
   "repository": {