@wirecat/cli-core 0.381.0 → 0.382.0

package/dist/meetings/index.d.ts

@@ -8,7 +8,7 @@ export { type FindingEvidence, type FindingOutcome, findingHash, MEETING_FINDING
 export { type Finding, type FindingsInput, type FindingsReceipt, type FindingsRules, findingFingerprint, validateFindings, } from "./findings-rules.js";
 export { MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
 export { type ImportFile, importFiles } from "./import.js";
-export { MEETING_QUERY, type MeetingItem, type MeetingOwner, meeting, meetingItem } from "./item.js";
+export { MEETING_ISSUES, MEETING_QUERY, type MeetingIssue, type MeetingItem, type MeetingOwner, meeting, meetingIssuesOf, meetingItem, } from "./item.js";
 export { createMeetingContext, MEETING_FACT_TYPES, type MeetingContextAction, type MeetingContextChange, type MeetingContextOperation, type MeetingContextPorts, type MeetingContextReceipt, validateMeetingContextChange, } from "./meeting-context.js";
 export { createMeetingManagement, dispatchMeetingMutation, type ManagedMeeting, type ManagedMeetingChange, type MeetingManagement, type MeetingManagementPorts, type MeetingMutationOptions, type MeetingMutationProposal, type MeetingMutationReceipt, type MeetingOperationOptions, type MeetingProviderContext, validateMeetingChange, } from "./meeting-management.js";
 export type { Attachment, ChatLine, Event, EventSeries, JsonValue, Meeting, MeetingSeries, Metadata, Occurrence, Participant, RecordTimes, SourceChatLine, SourceMeeting, Summary, SummaryContent, Transcript, TranscriptLine, TranscriptRow, } from "./model.js";

package/dist/meetings/index.js

@@ -6,7 +6,7 @@ export { findingHash, MEETING_FINDINGS_KIND, meetingFindingFingerprint, validate
 export { findingFingerprint, validateFindings, } from "./findings-rules.js";
 export { MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
 export { importFiles } from "./import.js";
-export { MEETING_QUERY, meeting, meetingItem } from "./item.js";
+export { MEETING_ISSUES, MEETING_QUERY, meeting, meetingIssuesOf, meetingItem, } from "./item.js";
 export { createMeetingContext, MEETING_FACT_TYPES, validateMeetingContextChange, } from "./meeting-context.js";
 export { createMeetingManagement, dispatchMeetingMutation, validateMeetingChange, } from "./meeting-management.js";
 export { normalizeMeetingParticipantQuery, validateMeetingParticipantSearch, } from "./participant-search.js";

package/dist/meetings/item.d.ts

@@ -1,5 +1,13 @@
 import * as v from "valibot";
 import type { Meeting } from "./model.js";
+/**
+ * Why a stored meeting's facts may be off, kept so the data stays but a reader knows to doubt it.
+ * `time_without_zone`: the provider sent a time with no zone, and it was read in the computer's zone.
+ */
+export declare const MEETING_ISSUES: readonly ["time_without_zone"];
+export type MeetingIssue = (typeof MEETING_ISSUES)[number];
+/** The issues a provider adapter put in `metadata.issues`, the known ones only, in their listed order. */
+export declare const meetingIssuesOf: (metadata: Meeting["metadata"]) => MeetingIssue[];
 /** A stored meeting as every command and tool answers it; `src/entities/` registers it as `meeting`. */
 export declare const meeting: v.StrictObjectSchema<{
     readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
@@ -16,6 +24,8 @@ export declare const meeting: v.StrictObjectSchema<{
     readonly duration_ms: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
     readonly timezone: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
     readonly participants_count: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+    /** Present only when something about this meeting is doubtful. */
+    readonly issues: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["time_without_zone"], undefined>, undefined>, undefined>;
     readonly created_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
     readonly updated_at: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
 }, undefined>;

package/dist/meetings/item.js

@@ -4,6 +4,16 @@ import * as v from "valibot";
 import { formatMeetingReference } from "./reference.js";
 const text = v.string();
 const count = v.pipe(v.number(), v.integer(), v.minValue(0));
+/**
+ * Why a stored meeting's facts may be off, kept so the data stays but a reader knows to doubt it.
+ * `time_without_zone`: the provider sent a time with no zone, and it was read in the computer's zone.
+ */
+export const MEETING_ISSUES = ["time_without_zone"];
+/** The issues a provider adapter put in `metadata.issues`, the known ones only, in their listed order. */
+export const meetingIssuesOf = (metadata) => {
+    const listed = metadata?.issues;
+    return Array.isArray(listed) ? MEETING_ISSUES.filter((issue) => listed.includes(issue)) : [];
+};
 /** A stored meeting as every command and tool answers it; `src/entities/` registers it as `meeting`. */
 export const meeting = v.strictObject({
     ref: reference,
@@ -20,33 +30,39 @@ export const meeting = v.strictObject({
     duration_ms: v.nullable(count),
     timezone: v.optional(v.nullable(text)),
     participants_count: v.nullable(count),
+    /** Present only when something about this meeting is doubtful. */
+    issues: v.optional(v.array(v.picklist(MEETING_ISSUES))),
     created_at: isoTime,
     updated_at: isoTime,
 });
 const iso = (ms) => (ms === null ? null : new Date(ms).toISOString());
-export const meetingItem = (row, owner) => ({
-    ref: formatMeetingReference({ type: "meeting", accountId: row.accountId, meetingId: row.id }),
-    id: String(row.id),
-    provider: owner.provider,
-    account: owner.account,
-    title: row.title,
-    description: row.description,
-    location: row.location,
-    url: row.joinUrl,
-    started_at: iso(row.startedAt),
-    ended_at: iso(row.endedAt),
-    duration_ms: row.durationMs,
-    timezone: row.timezone,
-    participants_count: row.participantsCount,
-    created_at: new Date(row.createdAt).toISOString(),
-    updated_at: new Date(row.updatedAt).toISOString(),
-});
+export const meetingItem = (row, owner) => {
+    const issues = meetingIssuesOf(row.metadata);
+    return {
+        ref: formatMeetingReference({ type: "meeting", accountId: row.accountId, meetingId: row.id }),
+        id: String(row.id),
+        provider: owner.provider,
+        account: owner.account,
+        title: row.title,
+        description: row.description,
+        location: row.location,
+        url: row.joinUrl,
+        started_at: iso(row.startedAt),
+        ended_at: iso(row.endedAt),
+        duration_ms: row.durationMs,
+        timezone: row.timezone,
+        participants_count: row.participantsCount,
+        ...(issues.length ? { issues } : {}),
+        created_at: new Date(row.createdAt).toISOString(),
+        updated_at: new Date(row.updatedAt).toISOString(),
+    };
+};
 /** `meetings list` fields: what the meetings table holds of the meeting itself. */
 export const MEETING_QUERY = {
     entity: "meeting",
     backend: "sql",
     fields: queryFieldsOf(meeting, {
-        exclude: ["ref", "provider", "account", "description", "location", "url", "timezone"],
+        exclude: ["ref", "provider", "account", "description", "location", "url", "timezone", "issues"],
         examples: {
             id: "id:12",
             title: "title:*standup*",

package/dist/ports/traits.d.ts

@@ -72,6 +72,12 @@ export interface MessengerTraits {
      * adapter's `history` — `messages sync <chat>`. `--all` stays refused: there is no chat list to walk. No when unset.
      */
     historyOnDemand?: boolean;
+    /**
+     * Who keeps a chat's unread count. `messenger` when unset: the store holds what the messenger last said. `store`: the
+     * messenger says it only now and then (a history push, a read on the phone), so each message from someone else that
+     * `watch` or `listen` saves for the first time, sent after the last count, adds one.
+     */
+    unreadCounts?: "messenger" | "store";
     /**
      * Whether `search messages --backend` is offered: the adapter has `searchMessages`. `chat` when its server
      * searches one chat at a time, so only a query that names one chat asks it. No when unset.

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/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>;

package/dist/store/sqlite/chats.js

@@ -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 {};
@@ -286,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)
@@ -300,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));
 /**
@@ -324,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)
@@ -333,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
         ? []
@@ -346,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,
@@ -361,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

@@ -32,6 +32,8 @@ export const MANIFEST = [
     { 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/messages.d.ts

@@ -1,7 +1,12 @@
-import type { Id, Message, PersonReaction, 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.
@@ -11,6 +16,8 @@ export declare const tombstone: (context: StoreContext, pk: number) => number;
 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;