@wirecat/cli-core 0.380.0 → 0.382.0

package/dist/store/messages.d.ts

@@ -1,5 +1,5 @@
 import type { CounterObservations } from "../domain/counters.js";
-import type { Id, Message, Page, 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";
@@ -10,10 +10,14 @@ export interface AccountMessages {
      * `seenAt` is when the messenger was asked: a message it still returned is not deleted, so a
      * tombstone older than that is lifted. A tombstone set after it stays — the deletion is newer.
      *
-     * `votes` and `stars` are saved after the messages in the same transaction, as `saveVote` and `saveStar` save each.
+     * `votes`, `reactions` and `stars` are saved after the messages in the same transaction, as `saveVote`,
+     * `saveReaction` and `saveStar` save each.
      *
      * `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;
@@ -22,11 +26,16 @@ export interface AccountMessages {
             messageId: Id;
             vote: PollVote;
         }[];
+        reactions?: {
+            messageId: Id;
+            reaction: PersonReaction;
+        }[];
         stars?: {
             messageId: Id;
             starred: boolean;
         }[];
         typedChatId?: Id;
+        countUnread?: boolean;
     }): Promise<void>;
     /** Oldest to newest, like a provider's history page. */
     /**
@@ -89,12 +98,22 @@ export interface AccountMessages {
         chatId?: Id;
         among?: DeletionScope;
     }): Promise<number>;
-    /** A message's reactions as they are now; answers whether the message is held at all. */
+    /**
+     * A message's reactions as they are now; answers whether the message is held at all. Ignored where the store holds
+     * people's own reactions to it (`saveReaction`): the totals come from those.
+     */
     saveReactions(key: AccountKey, chatId: Id, messageId: Id, reactions: Reactions, options?: {
         observation?: CounterObservations["reactions"];
     }): Promise<boolean>;
+    /**
+     * One person's reaction to a message, unless the store holds a newer one of theirs; a `null` reaction is a take-back.
+     * The message's `reactions` become the totals of every person's newest, whenever the message is held.
+     */
+    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,15 +11,19 @@ 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 = [], 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);
+            for (const { messageId, reaction } of reactions)
+                messageWrites.saveReaction(context, accountKey, key.provider, chatKey, messageId, reaction);
             for (const { messageId, starred } of stars)
                 messageWrites.saveStar(context, chatKey, messageId, starred);
         }),
@@ -83,6 +87,21 @@ 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);
+        }),
         saveVote: async (key, chatId, messageId, vote) => write(database, () => {
             const accountKey = accountPk(key);
             messageWrites.saveVote(context, accountKey, key.provider, chatPkFor(accountKey, chatId), messageId, vote);

package/dist/store/sqlite/accounts.js

@@ -1,7 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { and, asc, eq, inArray, sql } from "./drizzle/core.js";
 import { pointerPairs } from "./entity-types.js";
-import { accountIdentities, accounts, aliases, botUpdates, chatEventPeople, chatEvents, chatMembers, chats, chunks, fetchLeases, involvements, memberCounts, memberObservationMembers, memberObservations, memberStays, messageRevisions, messages, messageTranscripts, pollVotes, projects, syncCursors, syncRanges, syncs, } from "./schema.js";
+import { accountIdentities, accounts, aliases, botUpdates, chatEventPeople, chatEvents, chatMembers, chats, chunks, fetchLeases, involvements, memberCounts, memberObservationMembers, memberObservations, memberStays, messageReactions, messageRevisions, messages, messageTranscripts, pollVotes, projects, syncCursors, syncRanges, syncs, } from "./schema.js";
 /** An account's row, made on first sight; a name only replaces what was known when there is one. */
 export const accountPk = ({ orm, now }, { provider, account, scope }, name = null) => Number(orm
     .insert(accounts)
@@ -67,6 +67,7 @@ export const purgeAccount = ({ orm, database }, accountKey) => {
     orm.delete(syncs).where(eq(syncs.accountId, accountKey)).run();
     orm.delete(messageTranscripts).where(inArray(messageTranscripts.chatId, chatsOf)).run();
     orm.delete(pollVotes).where(inArray(pollVotes.chatId, chatsOf)).run();
+    orm.delete(messageReactions).where(inArray(messageReactions.chatId, chatsOf)).run();
     orm
         .delete(chatEventPeople)
         .where(inArray(chatEventPeople.chatEventId, orm.select({ id: chatEvents.id }).from(chatEvents).where(inArray(chatEvents.chatId, chatsOf))))

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

@@ -2,7 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import { formatLocator } from "../../domain/locator.js";
 import { purgeChats, revisedBy, stricterPrivacy } from "./chats.js";
 import { pointerPairs } from "./entity-types.js";
-import { tombstone } from "./messages.js";
+import { tombstone, writeDerivedReactions } from "./messages.js";
 import { targetKey } from "./notes.js";
 import { write } from "./transaction.js";
 const chatRow = (context, accountKey, chatId) => context.database.prepare("SELECT * FROM chats WHERE account_id = ? AND external_id = ?").get(accountKey, chatId);
@@ -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);
@@ -106,6 +109,9 @@ const absorb = (context, kept, gone) => {
     database
         .prepare("DELETE FROM poll_votes WHERE chat_id = ? AND EXISTS (SELECT 1 FROM poll_votes g WHERE g.chat_id = ? AND g.message_external_id = poll_votes.message_external_id AND g.identity_id = poll_votes.identity_id AND g.voted_at > poll_votes.voted_at)")
         .run(kept, gone);
+    database
+        .prepare("DELETE FROM message_reactions WHERE chat_id = ? AND EXISTS (SELECT 1 FROM message_reactions g WHERE g.chat_id = ? AND g.message_external_id = message_reactions.message_external_id AND g.identity_id = message_reactions.identity_id AND g.reacted_at > message_reactions.reacted_at)")
+        .run(kept, gone);
     // The absorbed copy of an event both chats hold is purged, so the people only it named move first.
     database
         .prepare("INSERT OR IGNORE INTO chat_event_people (chat_event_id, identity_id) SELECT k.id, p.identity_id FROM chat_events g JOIN chat_events k ON k.chat_id = ? AND k.source_id = g.source_id JOIN chat_event_people p ON p.chat_event_id = g.id WHERE g.chat_id = ?")
@@ -113,6 +119,7 @@ const absorb = (context, kept, gone) => {
     foldOpenStays(context, kept, gone);
     for (const table of [
         "poll_votes",
+        "message_reactions",
         "chat_revisions",
         "chat_events",
         "message_transcripts",
@@ -131,6 +138,10 @@ const absorb = (context, kept, gone) => {
     database
         .prepare("DELETE FROM message_transcripts WHERE chat_id = ? AND message_id IN (SELECT id FROM messages WHERE chat_id = ? AND deleted_at IS NOT NULL)")
         .run(kept, kept);
+    for (const { id } of database
+        .prepare("SELECT DISTINCT message_external_id AS id FROM message_reactions WHERE chat_id = ?")
+        .all(kept))
+        writeDerivedReactions(context, kept, id);
     database.prepare("UPDATE chats SET parent_chat_id = ? WHERE parent_chat_id = ?").run(kept, gone);
     pointerMover(context, "chat")(gone, kept);
     purgeChats(context, [gone]);
@@ -152,6 +163,10 @@ const privacyOf = (row) => ({
 const MESSENGER_FIELDS = [
     "title",
     "unread_count",
+    "unread_counted_at",
+    "muted",
+    "archived",
+    "marked_unread",
     "participants_count",
     "metadata",
     "username",
@@ -198,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>;

package/dist/store/sqlite/chats.js

@@ -2,7 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import { and, eq, inArray, or, sql } from "./drizzle/core.js";
 import { identityPk } from "./identities.js";
 import { bound } from "./query-filter.js";
-import { chatEventPeople, chatEvents, chatMembers, chats, chunks, fetchLeases, identities, involvements, memberCounts, memberObservationMembers, memberObservations, memberStays, messageRevisions, messages, messageTranscripts, pollVotes, syncRanges, } from "./schema.js";
+import { chatEventPeople, chatEvents, chatMembers, chats, chunks, fetchLeases, identities, involvements, memberCounts, memberObservationMembers, memberObservations, memberStays, messageReactions, messageRevisions, messages, messageTranscripts, pollVotes, syncRanges, } from "./schema.js";
 import { ensureTag } from "./tags.js";
 import { parsed, present, toIso, toMs } from "./values.js";
 /** The chat's own id, when the store key is a chat of this account. */
@@ -137,6 +137,7 @@ export const upsertChat = (context, accountKey, chat) => {
         participantsCount: chat.participantsCount ?? null,
         metadata: mergedMetadata(stored?.metadata ?? null, chat.providerMetadata),
         membershipState: chat.membershipState === "member" ? null : (chat.membershipState ?? null),
+        ...stateOf(chat, now()),
         createdAt: now(),
         updatedAt: now(),
     })
@@ -147,16 +148,33 @@ export const upsertChat = (context, accountKey, chat) => {
             ...(chat.parentChatId === undefined ? {} : { parentChatId: sql `excluded.parent_chat_id` }),
             scope: sql `coalesce(excluded.scope, ${chats.scope})`,
             ...(chat.title === undefined ? {} : { title: sql `excluded.title` }),
-            ...(chat.unreadCount === undefined ? {} : { unreadCount: sql `excluded.unread_count` }),
+            ...(chat.unreadCount === undefined
+                ? {}
+                : { unreadCount: sql `excluded.unread_count`, unreadCountedAt: sql `excluded.unread_counted_at` }),
             ...(chat.lastMessageAt === undefined ? {} : { lastMessageAt: sql `excluded.last_message_at` }),
             ...(chat.participantsCount === undefined ? {} : { participantsCount: sql `excluded.participants_count` }),
             metadata: sql `excluded.metadata`,
             ...membershipSet(chat.membershipState),
+            ...(chat.muted === undefined ? {} : { muted: sql `excluded.muted`, mutedUntil: sql `excluded.muted_until` }),
+            ...(chat.archived === undefined ? {} : { archived: sql `excluded.archived` }),
+            ...(chat.markedUnread === undefined ? {} : { markedUnread: sql `excluded.marked_unread` }),
             updatedAt: sql `excluded.updated_at`,
         },
     })
         .run();
 };
+const bit = (value) => (value === undefined ? null : value ? 1 : 0);
+/**
+ * The count is taken as of the chat's newest message where the update names it, else as of now: a message the store
+ * saves later and sent after that point is one the count does not hold yet.
+ */
+const stateOf = (chat, at) => ({
+    unreadCountedAt: chat.unreadCount === undefined ? null : (toMs(chat.lastMessageAt) ?? at),
+    muted: bit(chat.muted),
+    mutedUntil: chat.muted === true ? toMs(chat.mutedUntil) : null,
+    archived: bit(chat.archived),
+    markedUnread: bit(chat.markedUnread),
+});
 const membershipSet = (state) => {
     if (state === undefined)
         return {};
@@ -262,6 +280,7 @@ export const purgeChats = ({ orm }, pks) => {
         .run();
     orm.delete(messageTranscripts).where(inArray(messageTranscripts.chatId, pks)).run();
     orm.delete(pollVotes).where(inArray(pollVotes.chatId, pks)).run();
+    orm.delete(messageReactions).where(inArray(messageReactions.chatId, pks)).run();
     orm
         .delete(chatEventPeople)
         .where(inArray(chatEventPeople.chatEventId, orm.select({ id: chatEvents.id }).from(chatEvents).where(inArray(chatEvents.chatId, pks))))
@@ -285,7 +304,7 @@ export const purgeChats = ({ orm }, pks) => {
     orm.delete(messages).where(inArray(messages.chatId, pks)).run();
     orm.delete(chats).where(inArray(chats.id, pks)).run();
 };
-export const chatsWith = ({ orm }, accountKey, key, memberId) => {
+export const chatsWith = ({ orm, now }, accountKey, key, memberId) => {
     const rows = orm
         .select({ chat: chats })
         .from(chats)
@@ -299,7 +318,7 @@ export const chatsWith = ({ orm }, accountKey, key, memberId) => {
         .orderBy(...byRecency)
         .all()
         .map(({ chat }) => chat);
-    return toChats(orm, rows);
+    return toChats(orm, rows, now());
 };
 const chatsWhere = (accountKey, { where, includeLeft }) => and(eq(chats.accountId, accountKey), includeLeft ? undefined : notLeft, where === undefined ? undefined : bound(where));
 /**
@@ -323,7 +342,7 @@ export const CHAT_COLUMNS = {
 };
 /** `title:*book*` and `title:book` ask the same: the title holds "book". */
 export const titlePart = (value) => value.replace(/^\*+|\*+$/g, "").trim();
-export const listChats = ({ orm }, accountKey, { limit, offset = 0, ...filter }) => {
+export const listChats = ({ orm, now }, accountKey, { limit, offset = 0, ...filter }) => {
     const rows = orm
         .select()
         .from(chats)
@@ -332,10 +351,10 @@ export const listChats = ({ orm }, accountKey, { limit, offset = 0, ...filter })
         .limit(limit === undefined ? -1 : limit + 1)
         .offset(offset)
         .all();
-    return { items: toChats(orm, rows.slice(0, limit)), hasMore: limit !== undefined && rows.length > limit };
+    return { items: toChats(orm, rows.slice(0, limit), now()), hasMore: limit !== undefined && rows.length > limit };
 };
 export const countChats = ({ orm }, accountKey, filter) => Number(orm.select({ n: sql `count(*)` }).from(chats).where(chatsWhere(accountKey, filter)).get()?.n);
-const toChats = (orm, rows) => {
+const toChats = (orm, rows, at) => {
     const ids = [...new Set(rows.flatMap((row) => (row.parentChatId === null ? [] : [row.parentChatId])))];
     const parents = new Map(ids.length === 0
         ? []
@@ -345,9 +364,10 @@ const toChats = (orm, rows) => {
             .where(inArray(chats.id, ids))
             .all()
             .map((row) => [row.pk, row.externalId]));
-    return rows.map((row) => toChat(row, row.parentChatId === null ? undefined : parents.get(row.parentChatId)));
+    return rows.map((row) => toChat(row, at, row.parentChatId === null ? undefined : parents.get(row.parentChatId)));
 };
-const toChat = (row, parentId) => ({
+const flag = (stored) => (stored === null ? undefined : stored === 1);
+const toChat = (row, at, parentId) => ({
     id: row.externalId,
     title: row.title,
     kind: row.kind,
@@ -360,7 +380,17 @@ const toChat = (row, parentId) => ({
         membershipState: row.membershipState,
         providerMetadata: parsed(row.metadata),
     }),
+    ...muteOf(row, at),
+    ...present({ archived: flag(row.archived), markedUnread: flag(row.markedUnread) }),
 });
+// A mute is read against the clock, so one that ran out needs no write to end.
+const muteOf = ({ muted, mutedUntil }, at) => {
+    if (muted === null)
+        return {};
+    if (muted !== 1 || (mutedUntil !== null && mutedUntil <= at))
+        return { muted: false };
+    return mutedUntil === null ? { muted: true } : { muted: true, mutedUntil: toIso(mutedUntil) };
+};
 const metadataChatPk = ({ database }, key, chatId) => {
     const row = database
         .prepare("SELECT c.id FROM chats c JOIN accounts a ON a.id=c.account_id WHERE a.provider=? AND a.external_id=? AND c.external_id=?")

package/dist/store/sqlite/manifest.js

@@ -31,6 +31,9 @@ export const MANIFEST = [
     { name: "20261018063952_version-24-message-stars-index", version: 24, minCompatible: 1 },
     { name: "20261019115025_version-25-chat-revisions", version: 25, minCompatible: 1 },
     { name: "20261019115027_version-25-chat-revisions-triggers", version: 25, minCompatible: 1 },
+    { name: "20261021214318_version-26-message-reactions", version: 26, minCompatible: 1 },
+    { name: "20261021221808_version-27-message-delivery", version: 27, minCompatible: 1 },
+    { name: "20261021224625_version-28-chat-state", version: 28, minCompatible: 1 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/meeting-hit-query.js

@@ -21,7 +21,7 @@ const speakers = (database, accountId) => {
         found.set(key, speaker);
     };
     const participants = database
-        .prepare(`SELECT p.id,p.identity_id,p.display_name,i.name AS identity_name,l.person_id,person.name AS person_name
+        .prepare(`SELECT p.id,p.identity_id,p.display_name,p.email,i.external_id AS identity_key,i.name AS identity_name,l.person_id,person.name AS person_name
        FROM meeting_participants p JOIN meetings m ON m.id=p.meeting_id
        LEFT JOIN identities i ON i.id=p.identity_id LEFT JOIN identity_links l ON l.identity_id=p.identity_id
        LEFT JOIN persons person ON person.id=l.person_id WHERE m.account_id=? AND m.deleted_at IS NULL`)
@@ -34,11 +34,26 @@ const speakers = (database, accountId) => {
             const others = personNames.all(Number(row.person_id)).map((one) => (one.name === null ? null : String(one.name)));
             add(`person:${row.person_id}`, String(row.person_name ?? label), [...names, ...others], Number(row.id));
         }
-        else if (row.identity_id !== null && row.identity_id !== undefined)
-            add(`identity:${row.identity_id}`, label, names, Number(row.id));
+        else if (row.identity_id !== null &&
+            row.identity_id !== undefined &&
+            !String(row.identity_key).startsWith("name:"))
+            add(`identity:${row.identity_id}`, row.email ? `${label} <${row.email}>` : label, names, Number(row.id));
+        // A participant known only by name is keyed per meeting (`name:…@account/occurrence:n`); across meetings the name is all there is.
         else
             add(`name:${fold(label)}`, label, names, Number(row.id));
     }
+    // A name heard in one meeting is the identified speaker of that name, when exactly one has it.
+    for (const [key, speaker] of found) {
+        if (!key.startsWith("name:"))
+            continue;
+        const named = [...found].filter(([other, one]) => !other.startsWith("name:") && one.names.has(key.slice(5)));
+        const [only] = named;
+        if (named.length !== 1 || !only)
+            continue;
+        for (const participant of speaker.participants)
+            only[1].participants.add(participant);
+        found.delete(key);
+    }
     const unlinked = database
         .prepare(`SELECT DISTINCT r.speaker_name AS name FROM meeting_transcript_rows r
        JOIN meeting_transcripts t ON t.id=r.meeting_transcript_id JOIN meetings m ON m.id=t.meeting_id

package/dist/store/sqlite/meetings.js

@@ -166,14 +166,65 @@ export const saveAttachment = (database, type, parentId, a, now) => upsert(datab
     content_sha256: a.contentSha256,
     extracted_at: a.extractedAt,
 }, now);
+const FILE_SOURCE = "file";
+const SAME_OCCURRENCE_MS = 15 * 60_000;
+/** The account's record of this occurrence under another key: same series, the nearest start within 15 minutes. */
+const sameOccurrence = (database, meeting, seriesKey) => {
+    if (!seriesKey || meeting.startedAt === null)
+        return undefined;
+    const row = database
+        .prepare(`SELECT m.id,m.external_id,m.meeting_series_id,
+       EXISTS (SELECT 1 FROM meeting_transcripts t WHERE t.meeting_id=m.id AND t.source=?) AND
+       NOT EXISTS (SELECT 1 FROM meeting_transcripts t WHERE t.meeting_id=m.id AND t.source!=?) AS from_file
+       FROM meetings m JOIN meeting_series s ON s.id=m.meeting_series_id
+       WHERE m.account_id=? AND s.account_id=? AND s.external_id=? AND m.deleted_at IS NULL
+       AND m.started_at BETWEEN ? AND ? ORDER BY abs(m.started_at-?),m.id LIMIT 1`)
+        .get(FILE_SOURCE, FILE_SOURCE, meeting.accountId, meeting.accountId, seriesKey, meeting.startedAt - SAME_OCCURRENCE_MS, meeting.startedAt + SAME_OCCURRENCE_MS, meeting.startedAt);
+    return row
+        ? {
+            id: row.id,
+            externalId: row.external_id,
+            seriesId: row.meeting_series_id,
+            fromFile: Number(row.from_file) === 1,
+        }
+        : undefined;
+};
+/** A file's copy of an occurrence the provider already gave: its transcript only, and only where there is none. */
+const fillGap = (context, input, meetingId) => {
+    const { database } = context;
+    const held = database
+        .prepare("SELECT 1 FROM meeting_transcripts WHERE meeting_id = ? AND superseded_at IS NULL AND deleted_at IS NULL")
+        .get(meetingId);
+    if (held || !input.transcripts?.length)
+        return meetingId;
+    const participantIds = (input.participants ?? []).map(({ identity, ...p }) => upsert(database, "meeting_participants", {
+        meeting_id: meetingId,
+        identity_id: meetingIdentityPk({ ...context, now: () => input.now }, input.meeting.accountId, identity),
+    }, { display_name: p.displayName, email: p.email, role: p.role, external_id: p.externalId }, input.now));
+    saveTranscripts(database, meetingId, input.transcripts, (position) => (position === null ? null : (participantIds[position] ?? null)), input.now);
+    return meetingId;
+};
 const save = (context, input) => {
     const { database } = context;
     const { meeting: { series: seriesInput, ...meeting }, now, } = input;
     if (!Number.isSafeInteger(meeting.accountId) || meeting.accountId <= 0 || !meeting.externalId)
         throw new Error("Invalid meeting key");
-    const existing = database
+    let existing = database
         .prepare("SELECT id, meeting_series_id FROM meetings WHERE account_id = ? AND external_id = ?")
         .get(meeting.accountId, meeting.externalId);
+    const same = existing ? undefined : sameOccurrence(database, meeting, seriesInput?.externalId);
+    if (same?.fromFile === false && input.fromFile)
+        return fillGap(context, input, Number(same.id));
+    if (same && (same.fromFile || input.fromFile)) {
+        // A provider record takes over a record made from files; two files of one occurrence share the first one's key.
+        if (input.fromFile)
+            meeting.externalId = String(same.externalId);
+        else
+            database
+                .prepare("UPDATE meetings SET external_id = ?, updated_at = ? WHERE id = ?")
+                .run(meeting.externalId, now, Number(same.id));
+        existing = { id: same.id, meeting_series_id: same.seriesId };
+    }
     let seriesId = existing ? int(existing.meeting_series_id) : null;
     if (seriesInput) {
         if (!seriesInput.externalId)
@@ -228,6 +279,10 @@ const save = (context, input) => {
         return id;
     };
     saveTranscripts(database, meetingId, input.transcripts ?? [], participantId, now);
+    if ((input.transcripts ?? []).some((transcript) => transcript.source !== FILE_SOURCE))
+        database
+            .prepare("UPDATE meeting_transcripts SET superseded_at = ?, updated_at = ? WHERE meeting_id = ? AND source = ? AND superseded_at IS NULL")
+            .run(now, now, meetingId, FILE_SOURCE);
     for (const { senderParticipantPosition, ...line } of input.chat ?? []) {
         const values = {
             sent_at: line.sentAt,

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

@@ -1,17 +1,32 @@
-import type { Id, Message, PollVote, Provider, Reactions } from "../../domain/models.js";
+import type { Delivery, Id, Message, PersonReaction, PollVote, Provider, Reactions } from "../../domain/models.js";
 import type { AccountKey, DeletionScope } from "../types.js";
 import type { StoreContext } from "./open.js";
-export declare const upsertMessage: (context: StoreContext, key: AccountKey, accountKey: number, chatKey: number, message: Message, via: string, seenAt?: number) => void;
+export declare const upsertMessage: (context: StoreContext, key: AccountKey, accountKey: number, chatKey: number, message: Message, via: string, seenAt?: number) => boolean;
+/**
+ * One more unread for a message from someone else that the store first saw now, sent after the messenger's count was
+ * taken. A chat the messenger never gave a count for is left alone: the store would count its whole history.
+ */
+export declare const countUnread: ({ database }: StoreContext, chatKey: number, message: Message) => void;
 /**
  * The owner's ruling (NEED-393 A): a deleted message keeps its row, so a later sync cannot bring it
  * back, and leaves no text — not in the row, the search copy, the edit history, a transcript or a vector.
  */
 export declare const tombstone: (context: StoreContext, pk: number) => number;
-/** Whether the message is held at all. */
-export declare const saveReactions: ({ orm }: StoreContext, chatKey: number, messageId: Id, reactions: Reactions) => boolean;
+/** Whether the message is held at all. Where people's own reactions are held, the totals come from them instead. */
+export declare const saveReactions: (context: StoreContext, chatKey: number, messageId: Id, reactions: Reactions) => boolean;
 /** Answers whether the message is held; a deleted one keeps no star. */
 export declare const saveStar: ({ orm }: StoreContext, chatKey: number, messageId: Id, starred: boolean) => boolean;
+/** Answers whether the owner's own message is held. A receipt is for a message the owner sent, so another's keeps none. */
+export declare const saveDelivery: ({ orm }: StoreContext, chatKey: number, messageId: Id, delivery: Delivery) => boolean;
 export declare const markDeleted: (context: StoreContext, accountKey: number, messageIds: Id[], chatId: Id | undefined, among?: DeletionScope) => number;
 /** A vote older than the one held for that voter is dropped, and so is any vote in a deleted poll. */
 export declare const saveVote: (context: StoreContext, accountKey: number, provider: Provider, chatKey: number, messageId: Id, { person, answers, votedAt }: PollVote) => void;
 export declare const pollVotes: ({ database }: StoreContext, chatKey: number, messageId: Id) => PollVote[];
+/**
+ * The totals of the people's reactions the store holds for a message, or `undefined` when it holds none: then the
+ * messenger's own totals stand. A taken-back reaction still counts as held, so all of them taken back is zero.
+ */
+export declare const derivedReactions: ({ database }: StoreContext, chatKey: number, messageId: Id) => Reactions | undefined;
+/** A reaction older than the one held for that person is dropped, and so is any reaction to a deleted message. */
+export declare const saveReaction: (context: StoreContext, accountKey: number, provider: Provider, chatKey: number, messageId: Id, { person, own, reaction, reactedAt }: PersonReaction) => void;
+export declare const writeDerivedReactions: (context: StoreContext, chatKey: number, messageId: Id) => void;