@wirecat/cli-core 0.381.0 → 0.383.0

package/dist/services/chats.js

@@ -9,7 +9,7 @@ import { codeOf, guardedWrite } from "../sends/guarded.js";
 import { newOperationId } from "../sends/send-id.js";
 import { CHAT_COLUMNS, queryFilter, } from "../store/store.js";
 import { chatStats } from "./chat-stats.js";
-import { accountStore, accountStoreIfOpen, fromStore, nothingStored } from "./deps.js";
+import { accountStore, accountStoreIfOpen, fromStore, nothingStored, unlessBusy } from "./deps.js";
 import { memberEvents } from "./member-history.js";
 import { AUDIT_BUDGET, AUDIT_MIN_SCORE, AUDIT_PAGE, AUDIT_PAUSE_MS, auditMembers, } from "./members-audit.js";
 import { chatIdIn } from "./message-resolution.js";
@@ -249,7 +249,7 @@ export const chatsService = (deps) => ({
             const markTopicRead = capability(connection, "markTopicRead", "mark a forum topic read");
             act = (chatId) => markTopicRead(chatId, threadId, until);
         }
-        const { id: chatId } = await connection.resolve(chat);
+        const { id: chatId, kind } = await connection.resolve(chat);
         const operationId = newOperationId();
         await guardedWrite(deps.guard, {
             operationId,
@@ -258,9 +258,23 @@ export const chatsService = (deps) => ({
             ...(until === undefined ? {} : { messageId: until }),
             ...(threadId === undefined ? {} : { threadId }),
         }, () => act(chatId));
+        if (deps.reads === "store" && threadId === undefined)
+            await readInStore(deps, chatId, kind, until);
         return { operationId, chatId, until: until ?? null, ...(threadId === undefined ? {} : { threadId }) };
     },
 });
+/**
+ * Where `inbox` reads the store, the store learns of a read the owner made here at once: the messenger may never say.
+ * A read up to an older message from someone else leaves the count, which the store cannot split.
+ */
+const readInStore = async (deps, chatId, kind, until) => {
+    const store = await accountStoreIfOpen(deps);
+    if (!store)
+        return;
+    const [newest] = (await store.messages.messages(chatId, { limit: 1, outgoing: false })).items;
+    if (newest !== undefined && (until === undefined || newest.id === until))
+        await unlessBusy(() => store.chats.saveChats([{ id: chatId, kind, unreadCount: 0, markedUnread: false }]));
+};
 /** Each sender's first stored message in the chat; `undefined` when the store holds none of it. */
 const storedFacts = async (store, chatId) => {
     const chat = (await store.chats.chats({})).items.find((one) => one.id === chatId);

package/dist/services/deps.d.ts

@@ -52,6 +52,8 @@ export declare const accountStore: (deps: Pick<ServiceDeps, "store" | "account">
  * `reason` says which, so every such read is found by searching for this name.
  */
 export declare const crossAccount: (deps: Pick<ServiceDeps, "store">, _reason: string) => Promise<MessageStore>;
+/** A store write after the messenger already did the work: a store busy past its timeout leaves it unwritten. */
+export declare const unlessBusy: <T>(work: () => Promise<T>) => Promise<T | undefined>;
 /** `accountStore`, or nothing when there is no store to read or the account is not known yet. */
 export declare const accountStoreIfOpen: (deps: ServiceDeps) => Promise<AccountStore | undefined>;
 /**

package/dist/services/deps.js

@@ -33,6 +33,8 @@ const unless = async (work, expected) => {
         throw error;
     }
 };
+/** A store write after the messenger already did the work: a store busy past its timeout leaves it unwritten. */
+export const unlessBusy = (work) => unless(work, storeAbsent);
 /** `accountStore`, or nothing when there is no store to read or the account is not known yet. */
 export const accountStoreIfOpen = async (deps) => {
     const held = await storeIfOpen(deps);

package/dist/services/documents/block-diff.d.ts

@@ -0,0 +1,24 @@
+import { type Block } from "../../documents/blocks.js";
+/** `base[from, to)` is replaced by `blocks`; an empty range is an insert, an empty `blocks` a delete. */
+export interface BlockHunk {
+    from: number;
+    to: number;
+    blocks: Block[];
+}
+/** The edits that turn `base` into `next`, leaving every unchanged block in place. */
+export declare const diffBlocks: (base: Block[], next: Block[]) => BlockHunk[];
+export type Reconciled = {
+    status: "clean";
+    blocks: Block[];
+    ticksKept: number;
+} | {
+    status: "conflict";
+};
+/**
+ * What a push may write. `recorded` is what the last push wrote and read back, `current` the remote
+ * now, `local` the file now and `lastLocal` the file as the last push read it. Any remote change other
+ * than a checklist tick is a conflict, so the push never overwrites someone's edit. A tick follows the
+ * side that changed it: the local file when its tick differs from `lastLocal`, the remote otherwise —
+ * judged on every push, so a remote tick is not undone once the remote and `recorded` agree again.
+ */
+export declare const reconcileBlocks: (recorded: Block[], current: Block[], local: Block[], lastLocal: Block[]) => Reconciled;

package/dist/services/documents/block-diff.js

@@ -0,0 +1,91 @@
+import { blockKey, blockShape } from "../../documents/blocks.js";
+const MAX_CELLS = 4_000_000;
+/** Longest common subsequence: index pairs [inA, inB] of blocks with equal keys, in order. */
+const matches = (a, b, keyOf) => {
+    const ka = a.map(keyOf);
+    const kb = b.map(keyOf);
+    let start = 0;
+    while (start < ka.length && start < kb.length && ka[start] === kb[start])
+        start++;
+    let endA = ka.length;
+    let endB = kb.length;
+    while (endA > start && endB > start && ka[endA - 1] === kb[endB - 1]) {
+        endA--;
+        endB--;
+    }
+    const rows = endA - start;
+    const cols = endB - start;
+    const pairs = [];
+    for (let i = 0; i < start; i++)
+        pairs.push([i, i]);
+    if (rows * cols > MAX_CELLS) {
+        // Too large to align: the changed middle is rewritten as one block of edits.
+    }
+    else if (rows && cols) {
+        const table = new Uint32Array((rows + 1) * (cols + 1));
+        for (let i = rows - 1; i >= 0; i--)
+            for (let j = cols - 1; j >= 0; j--)
+                table[i * (cols + 1) + j] =
+                    ka[start + i] === kb[start + j]
+                        ? table[(i + 1) * (cols + 1) + j + 1] + 1
+                        : Math.max(table[(i + 1) * (cols + 1) + j], table[i * (cols + 1) + j + 1]);
+        let i = 0;
+        let j = 0;
+        while (i < rows && j < cols) {
+            if (ka[start + i] === kb[start + j]) {
+                pairs.push([start + i, start + j]);
+                i++;
+                j++;
+            }
+            else if (table[(i + 1) * (cols + 1) + j] >= table[i * (cols + 1) + j + 1])
+                i++;
+            else
+                j++;
+        }
+    }
+    for (let offset = 0; offset < ka.length - endA; offset++)
+        pairs.push([endA + offset, endB + offset]);
+    return pairs;
+};
+/** The edits that turn `base` into `next`, leaving every unchanged block in place. */
+export const diffBlocks = (base, next) => {
+    const hunks = [];
+    let a = 0;
+    let b = 0;
+    for (const [i, j] of [...matches(base, next, blockKey), [base.length, next.length]]) {
+        if (i > a || j > b)
+            hunks.push({ from: a, to: i, blocks: next.slice(b, j) });
+        a = i + 1;
+        b = j + 1;
+    }
+    return hunks;
+};
+const isCheck = (block) => block?.kind === "item" && block.list === "check";
+/**
+ * What a push may write. `recorded` is what the last push wrote and read back, `current` the remote
+ * now, `local` the file now and `lastLocal` the file as the last push read it. Any remote change other
+ * than a checklist tick is a conflict, so the push never overwrites someone's edit. A tick follows the
+ * side that changed it: the local file when its tick differs from `lastLocal`, the remote otherwise —
+ * judged on every push, so a remote tick is not undone once the remote and `recorded` agree again.
+ */
+export const reconcileBlocks = (recorded, current, local, lastLocal) => {
+    const sameShape = recorded.length === current.length &&
+        recorded.every((block, index) => blockShape(block) === blockShape(current[index]));
+    if (!sameShape)
+        return { status: "conflict" };
+    const before = new Map(matches(local, lastLocal, blockShape));
+    const blocks = local.map((block) => ({ ...block }));
+    let ticksKept = 0;
+    for (const [i, j] of matches(current, local, blockShape)) {
+        const remote = current[i];
+        const mine = blocks[j];
+        const last = lastLocal[before.get(j) ?? -1];
+        if (!isCheck(remote) || !isCheck(mine) || !isCheck(last))
+            continue;
+        if (Boolean(mine.checked) === Boolean(last.checked) && Boolean(remote.checked) !== Boolean(mine.checked)) {
+            mine.checked = Boolean(remote.checked);
+            ticksKept++;
+        }
+    }
+    return { status: "clean", blocks, ticksKept };
+};

package/dist/services/documents/push.d.ts

@@ -0,0 +1,60 @@
+import { CliError } from "@wirecat/cli-base";
+import type { DocumentTarget, LocalDocument, PushPlan, PushState, PushStatePort } from "../../documents/push-model.js";
+export interface PushOptions<S> {
+    /** Absolute path of the local folder being mirrored. */
+    root: string;
+    /** Remote folder id the mirror writes into. */
+    folder: string;
+    target: DocumentTarget<S>;
+    state: PushStatePort<S>;
+    principal: string;
+    force?: boolean;
+    dryRun?: boolean;
+    /** Runs one remote write behind the provider's permission checks and write journal. */
+    guard<T>(attempt: {
+        action: "create" | "update" | "folder";
+        path: string;
+        operationId: string;
+    }, act: () => Promise<T>): Promise<T>;
+    operationId(): string;
+    errorOf(error: unknown): CliError;
+    assertHeld(): void;
+    signal?: AbortSignal;
+    maxFiles?: number;
+    now?(): number;
+}
+export interface PushResult {
+    created: string[];
+    updated: string[];
+    unchanged: number;
+    conflicts: {
+        path: string;
+        url: string;
+        reason: string;
+    }[];
+    missing: string[];
+    orphans: {
+        path: string;
+        url: string;
+    }[];
+    errors: {
+        path: string;
+        code: string;
+        message: string;
+    }[];
+    unsupported: number;
+    plan?: {
+        create: string[];
+        update: string[];
+        orphans: string[];
+    };
+    stopped?: true;
+}
+/** Files under `root` the target pushes. Hidden files, editor leftovers and symbolic links are never followed. */
+export declare const scanLocal: (root: string, kindOf: (path: string) => string | undefined, maxFiles?: number) => Promise<{
+    files: LocalDocument[];
+    unsupported: number;
+}>;
+/** What a push would do, from the local files and the last push alone: no remote read. */
+export declare const planPush: <S>(files: LocalDocument[], state: PushState<S>) => PushPlan;
+export declare const pushDocuments: <S>(options: PushOptions<S>) => Promise<PushResult>;

package/dist/services/documents/push.js

@@ -0,0 +1,218 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { join, posix } from "node:path";
+import { CliError, isCliError } from "@wirecat/cli-base";
+const SKIPPED = /^(\.|node_modules$|~\$)|(~|\.swp|\.tmp)$/;
+const hashFile = (path) => new Promise((done, fail) => {
+    const hash = createHash("sha256");
+    createReadStream(path)
+        .on("data", (chunk) => hash.update(chunk))
+        .on("error", fail)
+        .on("end", () => done(hash.digest("hex")));
+});
+/** Files under `root` the target pushes. Hidden files, editor leftovers and symbolic links are never followed. */
+export const scanLocal = async (root, kindOf, maxFiles = 10_000) => {
+    const files = [];
+    let unsupported = 0;
+    const walk = async (relative) => {
+        const entries = await readdir(join(root, relative), { withFileTypes: true });
+        for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+            if (SKIPPED.test(entry.name) || entry.isSymbolicLink())
+                continue;
+            const path = relative ? posix.join(relative, entry.name) : entry.name;
+            if (entry.isDirectory())
+                await walk(path);
+            else if (entry.isFile()) {
+                const kind = kindOf(path);
+                if (!kind) {
+                    unsupported++;
+                    continue;
+                }
+                if (files.length >= maxFiles)
+                    throw new CliError("validation_error", `the folder holds more than ${maxFiles} files to push`, {
+                        reason: "push.too-many-files",
+                    });
+                const absolute = join(root, path);
+                files.push({ path, absolute, kind, hash: await hashFile(absolute) });
+            }
+        }
+    };
+    try {
+        await walk("");
+    }
+    catch (error) {
+        if (isCliError(error))
+            throw error;
+        throw new CliError("validation_error", "the folder to push could not be read", { reason: "push.unreadable" });
+    }
+    return { files, unsupported };
+};
+/** What a push would do, from the local files and the last push alone: no remote read. */
+export const planPush = (files, state) => {
+    const plan = { create: [], update: [], unchanged: [], orphans: [] };
+    const seen = new Set();
+    for (const file of files) {
+        seen.add(file.path);
+        const entry = state.entries[file.path];
+        if (!entry)
+            plan.create.push(file);
+        else if (entry.hash !== file.hash)
+            plan.update.push(file);
+        else
+            plan.unchanged.push(file);
+    }
+    plan.orphans = Object.keys(state.entries).filter((path) => !seen.has(path));
+    return plan;
+};
+const originOf = (principal, root, folder, path) => createHash("sha256")
+    .update(JSON.stringify([principal, root, folder, path]))
+    .digest("hex")
+    .slice(0, 32);
+export const pushDocuments = async (options) => {
+    const { root, folder, target, principal, force = false, signal } = options;
+    const now = options.now ?? Date.now;
+    if (signal?.aborted)
+        throw new CliError("cancelled", "push was cancelled");
+    if ((await target.identity()) !== principal)
+        throw new CliError("authentication_error", "signed-in account does not match this profile", {
+            reason: "profile.wrong-account",
+        });
+    const state = options.state.read();
+    if (state.principal !== principal || state.root !== root || state.target !== folder)
+        throw new CliError("configuration_error", "push state belongs to another account or mirror");
+    const save = () => options.state.save(state);
+    if (!options.dryRun)
+        for (const [path, pending] of Object.entries(state.pending)) {
+            const found = await target.findByOrigin(pending.origin);
+            // An empty hash makes this pass update the found file from the local one.
+            if (found)
+                state.entries[path] = { ...found, kind: target.kindOf(path) ?? "", hash: "", pushedAt: "" };
+            delete state.pending[path];
+            save();
+        }
+    const { files, unsupported } = await scanLocal(root, (path) => target.kindOf(path), options.maxFiles);
+    const plan = planPush(files, state);
+    const result = {
+        created: [],
+        updated: [],
+        unchanged: plan.unchanged.length,
+        conflicts: [],
+        missing: [],
+        orphans: plan.orphans.map((path) => ({ path, url: state.entries[path]?.url ?? "" })),
+        errors: [],
+        unsupported,
+    };
+    if (options.dryRun) {
+        result.plan = {
+            create: plan.create.map((file) => file.path),
+            update: plan.update.map((file) => file.path),
+            orphans: plan.orphans,
+        };
+        return result;
+    }
+    const folderOf = async (path) => {
+        const directory = posix.dirname(path);
+        if (directory === ".")
+            return folder;
+        const known = state.folders[directory];
+        if (known)
+            return known;
+        const parent = await folderOf(directory);
+        const operationId = options.operationId();
+        options.assertHeld();
+        const id = await options.guard({ action: "folder", path: directory, operationId }, () => target.ensureFolder({
+            parent,
+            name: posix.basename(directory),
+            origin: originOf(principal, root, folder, `${directory}/`),
+        }));
+        state.folders[directory] = id;
+        save();
+        return id;
+    };
+    const create = async (file) => {
+        const parent = await folderOf(file.path);
+        const operationId = options.operationId();
+        const origin = originOf(principal, root, folder, file.path);
+        state.pending[file.path] = { origin, operationId };
+        save();
+        options.assertHeld();
+        const pushed = await options.guard({ action: "create", path: file.path, operationId }, () => target.create({
+            file,
+            name: posix.basename(file.path),
+            parent,
+            origin,
+            operationId,
+            ...(signal ? { signal } : {}),
+        }));
+        state.entries[file.path] = { ...pushed, kind: file.kind, hash: file.hash, pushedAt: new Date(now()).toISOString() };
+        delete state.pending[file.path];
+        save();
+        result.created.push(file.path);
+    };
+    const work = [
+        ...plan.create.map((file) => ({ file, create: true })),
+        ...plan.update.map((file) => ({ file, create: false })),
+    ];
+    for (const job of work.sort((a, b) => a.file.path.localeCompare(b.file.path))) {
+        if (signal?.aborted) {
+            result.stopped = true;
+            break;
+        }
+        const { file } = job;
+        try {
+            const entry = state.entries[file.path];
+            if (job.create || !entry) {
+                await create(file);
+                continue;
+            }
+            const prepared = await target.prepare({
+                id: entry.id,
+                file,
+                recorded: entry.snapshot,
+                force,
+                ...(signal ? { signal } : {}),
+            });
+            if ("conflict" in prepared) {
+                result.conflicts.push({ path: file.path, url: entry.url, reason: prepared.conflict });
+                continue;
+            }
+            if ("missing" in prepared) {
+                if (!force) {
+                    result.missing.push(file.path);
+                    continue;
+                }
+                delete state.entries[file.path];
+                await create(file);
+                continue;
+            }
+            let pushed;
+            if ("unchanged" in prepared) {
+                pushed = prepared.unchanged;
+                result.unchanged++;
+            }
+            else {
+                const operationId = options.operationId();
+                options.assertHeld();
+                pushed = await options.guard({ action: "update", path: file.path, operationId }, () => prepared.write());
+                result.updated.push(file.path);
+            }
+            state.entries[file.path] = {
+                ...pushed,
+                kind: file.kind,
+                hash: file.hash,
+                pushedAt: new Date(now()).toISOString(),
+            };
+            save();
+        }
+        catch (error) {
+            const failure = options.errorOf(error);
+            if (failure.code === "cancelled") {
+                result.stopped = true;
+                break;
+            }
+            result.errors.push({ path: file.path, code: failure.code, message: failure.message });
+        }
+    }
+    return result;
+};

package/dist/services/inbox.d.ts

@@ -39,6 +39,7 @@ export declare const capped: (chats: Chat[], most: number) => {
  * Other people's unread messages, as the messenger counts them: for each chat with a count, its
  * newest that many. Reading marks nothing read, so the same messages come back until they are read
  * somewhere else — right for a person, wrong for a scheduled run, which is what `since` is for.
+ * A chat the owner marked unread is there with no count too, with its newest message from someone else.
  *
  * Muted and archived chats are left out unless `all`, or they mention the owner: on a busy account
  * they are most of what is unread, and they would take the history reads a person's chat needs.

package/dist/services/inbox.js

@@ -15,8 +15,8 @@ export const REVIEW_DAYS = 3;
 export const UNANSWERED_HOURS = 24;
 export const reviewStart = (now = Date.now()) => now - REVIEW_DAYS * 86_400_000;
 export const byRecency = (chats) => chats.toSorted((a, b) => Date.parse(b.lastMessageAt ?? "") - Date.parse(a.lastMessageAt ?? ""));
-/** Muted or archived, and nothing in it mentions the owner or replies to them. */
-const isQuiet = (chat) => (chat.muted === true || chat.archived === true) && (chat.unreadMentions ?? 0) === 0;
+/** Muted or archived, and nothing in it mentions the owner or replies to them; one the owner marked unread never is. */
+const isQuiet = (chat) => (chat.muted === true || chat.archived === true) && (chat.unreadMentions ?? 0) === 0 && chat.markedUnread !== true;
 export const heard = (chats, all) => all
     ? { heard: chats, quiet: 0 }
     : { heard: chats.filter((chat) => !isQuiet(chat)), quiet: chats.filter(isQuiet).length };
@@ -75,17 +75,24 @@ export const capped = (chats, most) => ({
  * Other people's unread messages, as the messenger counts them: for each chat with a count, its
  * newest that many. Reading marks nothing read, so the same messages come back until they are read
  * somewhere else — right for a person, wrong for a scheduled run, which is what `since` is for.
+ * A chat the owner marked unread is there with no count too, with its newest message from someone else.
  *
  * Muted and archived chats are left out unless `all`, or they mention the owner: on a busy account
  * they are most of what is unread, and they would take the history reads a person's chat needs.
  */
 export const unreadIn = async (adapter, { limit, all = false, kinds }) => {
     const page = await everyChat(adapter);
-    const { heard: waiting, quiet } = heard(byRecency(ofKinds(page.items, kinds).filter((chat) => (chat.unreadCount ?? 0) > 0)), all);
+    const { heard: waiting, quiet } = heard(byRecency(ofKinds(page.items, kinds).filter((chat) => (chat.unreadCount ?? 0) > 0 || chat.markedUnread === true)), all);
     const { read, skipped } = capped(waiting, INBOX_CHATS);
     const chats = [];
     for (const { id, title, kind, unreadCount } of read) {
         const count = unreadCount ?? 0;
+        if (count === 0) {
+            const newest = (await adapter.history(id, { limit })).items.findLast((message) => !message.outgoing);
+            if (newest)
+                chats.push({ id, title, kind, unreadCount, messages: [newest], more: false });
+            continue;
+        }
         const wanted = Math.min(count, limit);
         const { items } = await adapter.history(id, { limit: wanted });
         const theirs = items.slice(-wanted).filter((message) => !message.outgoing);

package/dist/store/keys.d.ts

@@ -10,7 +10,7 @@ export declare const keysOver: (context: StoreContext) => {
     chatPkFor: (accountKey: number, chatId: Id) => number;
     answeredChatPk: (accountKey: number, chatId: Id, typed: Id) => number;
     identityPk: (accountKey: number, provider: Provider, nativeId: Id, name: string | null, facts?: Omit<PersonFacts, "id" | "name">) => number;
-    upsertMessage: (key: AccountKey, accountKey: number, chatKey: number, message: Message, via: string, seenAt?: number) => void;
+    upsertMessage: (key: AccountKey, accountKey: number, chatKey: number, message: Message, via: string, seenAt?: number) => boolean;
     writeMembers: (key: AccountKey, accountKey: number, chatId: Id, memberIds: Id[]) => void;
     writeState: (accountKey: number, name: string, value: string) => void;
 };

package/dist/store/messages.d.ts

@@ -1,5 +1,5 @@
 import type { CounterObservations } from "../domain/counters.js";
-import type { Id, Message, Page, PersonReaction, PollVote, Reactions, WindowedMessage } from "../domain/models.js";
+import type { Delivery, Id, Message, Page, PersonReaction, PollVote, Reactions, WindowedMessage } from "../domain/models.js";
 import { type DocumentLinkMessage } from "./sqlite/document-links.js";
 import type { StoreContext } from "./sqlite/open.js";
 import type { AccountKey, DeletionScope, IngestedVia, MessageFilter, SenderChatStats, StoredHit } from "./types.js";
@@ -15,6 +15,9 @@ export interface AccountMessages {
      *
      * `typedChatId` is the id the owner wrote to when the messenger answered `chatId`: a chat row made for `chatId`
      * takes the typed row's title, kind and privacy, and is never more visible than it.
+     *
+     * `countUnread` raises the chat's unread count by each message from someone else stored for the first time and sent
+     * after the messenger's count was taken — for a messenger whose store counts (`MessengerTraits.unreadCounts`).
      */
     saveMessages(key: AccountKey, chatId: Id, messages: Message[], options: {
         via: IngestedVia;
@@ -32,6 +35,7 @@ export interface AccountMessages {
             starred: boolean;
         }[];
         typedChatId?: Id;
+        countUnread?: boolean;
     }): Promise<void>;
     /** Oldest to newest, like a provider's history page. */
     /**
@@ -108,6 +112,8 @@ export interface AccountMessages {
     saveReaction(key: AccountKey, chatId: Id, messageId: Id, reaction: PersonReaction): Promise<void>;
     /** The owner's star on a message, or its removal; answers whether the message is held at all. */
     saveStar(key: AccountKey, chatId: Id, messageId: Id, starred: boolean): Promise<boolean>;
+    /** A receipt for the owner's own message; the state never moves back. Answers whether such a message is held. */
+    saveDelivery(key: AccountKey, chatId: Id, messageId: Id, delivery: Delivery): Promise<boolean>;
     /** One voter's vote in the poll a message carries, unless the store holds a newer one of theirs; no answers is a take-back. */
     saveVote(key: AccountKey, chatId: Id, messageId: Id, vote: PollVote): Promise<void>;
     /** Each voter's newest vote in the poll a message carries, newest first. */

package/dist/store/messages.js

@@ -11,12 +11,14 @@ export const accountMessagesOver = (context) => {
     const { database } = context;
     const { accountPk, findAccountPk, findChatPk, chatKeyOf, chatPkFor, answeredChatPk, upsertMessage } = keysOver(context);
     return {
-        saveMessages: async (key, chatId, messages, { via, seenAt, votes = [], reactions = [], stars = [], typedChatId }) => write(database, () => {
+        saveMessages: async (key, chatId, messages, { via, seenAt, votes = [], reactions = [], stars = [], typedChatId, countUnread = false }) => write(database, () => {
             const accountKey = accountPk(key);
             const chatKey = typedChatId === undefined ? chatPkFor(accountKey, chatId) : answeredChatPk(accountKey, chatId, typedChatId);
             for (const message of messages) {
-                if (message.scheduledFor === undefined)
-                    upsertMessage(key, accountKey, chatKey, message, via, seenAt);
+                if (message.scheduledFor !== undefined)
+                    continue;
+                if (upsertMessage(key, accountKey, chatKey, message, via, seenAt) && countUnread)
+                    messageWrites.countUnread(context, chatKey, message);
             }
             for (const { messageId, vote } of votes)
                 messageWrites.saveVote(context, accountKey, key.provider, chatKey, messageId, vote);
@@ -85,6 +87,17 @@ export const accountMessagesOver = (context) => {
             });
             return saved;
         },
+        saveDelivery: async (key, chatId, messageId, delivery) => {
+            const accountKey = findAccountPk(key);
+            const chatKey = accountKey === undefined ? undefined : findChatPk(accountKey, chatId);
+            if (chatKey === undefined)
+                return false;
+            let saved = false;
+            write(database, () => {
+                saved = messageWrites.saveDelivery(context, chatKey, messageId, delivery);
+            });
+            return saved;
+        },
         saveReaction: async (key, chatId, messageId, reaction) => write(database, () => {
             const accountKey = accountPk(key);
             messageWrites.saveReaction(context, accountKey, key.provider, chatPkFor(accountKey, chatId), messageId, reaction);

package/dist/store/sqlite/chat-rekey.js

@@ -86,10 +86,13 @@ const absorb = (context, kept, gone) => {
     const threads = database.prepare("UPDATE messages SET thread_root_id = ? WHERE thread_root_id = ?");
     // Without a time on either star, the kept copy's word stands and the absorbed one only fills a gap.
     const star = database.prepare("UPDATE messages SET starred = (SELECT starred FROM messages WHERE id = ?) WHERE id = ? AND starred IS NULL");
+    // A receipt only moves a message forward, so the copy that got further wins.
+    const delivery = database.prepare("UPDATE messages SET delivery = nullif(max(coalesce(delivery, 0), coalesce((SELECT delivery FROM messages WHERE id = ?), 0)), 0) WHERE id = ? AND outgoing = 1");
     const links = ["message_id", "parent_id"].map((column) => database.prepare(`UPDATE OR IGNORE message_links SET ${column} = ? WHERE ${column} = ?`));
     for (const pair of pairs) {
         threads.run(pair.kept, pair.gone);
         star.run(pair.gone, pair.kept);
+        delivery.run(pair.gone, pair.kept);
         // Both copies become tombstones before anything moves, so only what a deletion keeps (the owner's links) moves.
         if (pair.deleted) {
             tombstone(context, pair.gone);
@@ -160,6 +163,10 @@ const privacyOf = (row) => ({
 const MESSENGER_FIELDS = [
     "title",
     "unread_count",
+    "unread_counted_at",
+    "muted",
+    "archived",
+    "marked_unread",
     "participants_count",
     "metadata",
     "username",
@@ -206,8 +213,9 @@ const moveChat = (context, key, accountKey, old, twin, from, to) => {
         // Left only when both were: a complete chat list that named the new id before the re-key marked the old one.
         `UPDATE chats SET ${fields}, kind = CASE WHEN kind = 'unknown' THEN ? ELSE kind END,
            membership_state = CASE WHEN ? IS NULL THEN nullif(membership_state, 'left') ELSE coalesce(nullif(?, 'left'), membership_state) END,
+           muted_until = CASE WHEN ? IS NULL THEN muted_until ELSE ? END,
            searchable = ?, scope = ?, last_message_at = ?, updated_at = ? WHERE id = ?`)
-            .run(...MESSENGER_FIELDS.map((field) => scalar(twin[field])), scalar(twin.kind), scalar(twin.membership_state), scalar(twin.membership_state), strict.searchable, strict.scope, latest(old.last_message_at, twin.last_message_at), context.now(), kept);
+            .run(...MESSENGER_FIELDS.map((field) => scalar(twin[field])), scalar(twin.kind), scalar(twin.membership_state), scalar(twin.membership_state), scalar(twin.muted), scalar(twin.muted_until), strict.searchable, strict.scope, latest(old.last_message_at, twin.last_message_at), context.now(), kept);
     }
     context.database.prepare("UPDATE chats SET external_id = ?, updated_at = ? WHERE id = ?").run(to, context.now(), kept);
     renameText(context, key, accountKey, from, to);

package/dist/store/sqlite/chats.d.ts

@@ -61,7 +61,7 @@ export declare const leftChats: ({ orm }: StoreContext, accountKey: number) => {
 };
 /** These chats and everything under them, children before parents: the foreign keys are enforced. */
 export declare const purgeChats: ({ orm }: StoreContext, pks: number[]) => void;
-export declare const chatsWith: ({ orm }: StoreContext, accountKey: number, key: AccountKey, memberId: Id) => Chat[];
+export declare const chatsWith: ({ orm, now }: StoreContext, accountKey: number, key: AccountKey, memberId: Id) => Chat[];
 /**
  * How the store answers a chat list's query. `title:` goes through the trigram index, so it matches part of a
  * title, three characters or more, whatever the case.
@@ -96,7 +96,7 @@ export declare const CHAT_COLUMNS: {
 };
 /** `title:*book*` and `title:book` ask the same: the title holds "book". */
 export declare const titlePart: (value: string) => string;
-export declare const listChats: ({ orm }: StoreContext, accountKey: number, { limit, offset, ...filter }: {
+export declare const listChats: ({ orm, now }: StoreContext, accountKey: number, { limit, offset, ...filter }: {
     limit?: number;
     offset?: number;
 } & StoredChatFilter) => Page<Chat>;