@wirecat/cli-core 0.380.0 → 0.382.0

package/dist/store/sqlite/messages.js

@@ -7,7 +7,7 @@ import { folded } from "./folded.js";
 import { identityPk } from "./identities.js";
 import { attachments, chats, messageRevisions, messages, messageTranscripts } from "./schema.js";
 import { intoVoiceAttachment } from "./transcripts.js";
-import { json, parsed, toMs } from "./values.js";
+import { DELIVERY, json, parsed, toMs } from "./values.js";
 import { purgeVectorsOf } from "./vectors.js";
 const FIELDS = [
     "threadExternalId",
@@ -120,7 +120,7 @@ export const upsertMessage = (context, key, accountKey, chatKey, message, via, s
     const revived = found?.deletedAt != null && seenAt !== undefined && found.deletedAt < seenAt;
     // A deleted message leaves no text behind, and a sync that still carries it does not bring it back.
     if (found?.deletedAt != null && !revived)
-        return;
+        return false;
     let pk;
     if (!found) {
         pk = Number(statements.insert.get({
@@ -174,6 +174,13 @@ export const upsertMessage = (context, key, accountKey, chatKey, message, via, s
         if (revived)
             orm.update(messages).set({ deletedAt: null, text: message.text }).where(eq(messages.id, pk)).run();
     }
+    const derived = derivedReactions(context, chatKey, message.id);
+    if (derived)
+        orm
+            .update(messages)
+            .set({ reactions: JSON.stringify(derived) })
+            .where(eq(messages.id, pk))
+            .run();
     if (message.counterObservations)
         applyCounterObservations(context, pk, message.counterObservations);
     if (message.starred !== undefined)
@@ -182,6 +189,12 @@ export const upsertMessage = (context, key, accountKey, chatKey, message, via, s
             .set({ starred: message.starred ? 1 : 0 })
             .where(eq(messages.id, pk))
             .run();
+    if (message.delivery !== undefined)
+        orm
+            .update(messages)
+            .set({ delivery: raised(message.delivery) })
+            .where(and(eq(messages.id, pk), eq(messages.outgoing, 1)))
+            .run();
     const root = message.threadRootId ?? message.threadId;
     if (root !== undefined) {
         context.database
@@ -215,6 +228,19 @@ export const upsertMessage = (context, key, accountKey, chatKey, message, via, s
     });
     if (Number(heardFirst) > 0)
         intoVoiceAttachment(context, pk);
+    return !found;
+};
+/**
+ * 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 const countUnread = ({ database }, chatKey, message) => {
+    if (message.outgoing || message.editedAt !== null)
+        return;
+    database
+        .prepare(`UPDATE chats SET unread_count = unread_count + 1
+         WHERE id = ? AND unread_count IS NOT NULL AND unread_counted_at IS NOT NULL AND unread_counted_at < ?`)
+        .run(chatKey, Date.parse(message.timestamp));
 };
 /**
  * The owner's ruling (NEED-393 A): a deleted message keeps its row, so a later sync cannot bring it
@@ -237,6 +263,9 @@ export const tombstone = (context, pk) => {
     context.database
         .prepare("DELETE FROM poll_votes WHERE chat_id=? AND message_external_id=?")
         .run(row.chatId, row.externalId);
+    context.database
+        .prepare("DELETE FROM message_reactions WHERE chat_id=? AND message_external_id=?")
+        .run(row.chatId, row.externalId);
     purgeVectorsOf(context, pk);
     orm
         .delete(messageTranscripts)
@@ -244,10 +273,10 @@ export const tombstone = (context, pk) => {
         .run();
     return 1;
 };
-/** Whether the message is held at all. */
-export const saveReactions = ({ orm }, chatKey, messageId, reactions) => orm
+/** Whether the message is held at all. Where people's own reactions are held, the totals come from them instead. */
+export const saveReactions = (context, chatKey, messageId, reactions) => context.orm
     .update(messages)
-    .set({ reactions: JSON.stringify(reactions) })
+    .set({ reactions: JSON.stringify(derivedReactions(context, chatKey, messageId) ?? reactions) })
     .where(and(eq(messages.chatId, chatKey), eq(messages.externalId, messageId), isNull(messages.deletedAt)))
     .returning({ pk: messages.id })
     .all().length > 0;
@@ -258,6 +287,14 @@ export const saveStar = ({ orm }, chatKey, messageId, starred) => orm
     .where(and(eq(messages.chatId, chatKey), eq(messages.externalId, messageId), isNull(messages.deletedAt)))
     .returning({ pk: messages.id })
     .all().length > 0;
+const raised = (delivery) => sql `max(coalesce(delivery, 0), ${DELIVERY[delivery]})`;
+/** Answers whether the owner's own message is held. A receipt is for a message the owner sent, so another's keeps none. */
+export const saveDelivery = ({ orm }, chatKey, messageId, delivery) => orm
+    .update(messages)
+    .set({ delivery: raised(delivery) })
+    .where(and(eq(messages.chatId, chatKey), eq(messages.externalId, messageId), eq(messages.outgoing, 1), isNull(messages.deletedAt)))
+    .returning({ pk: messages.id })
+    .all().length > 0;
 export const markDeleted = (context, accountKey, messageIds, chatId, among) => {
     const { orm } = context;
     const chatKey = chatId === undefined ? undefined : findChatPk(context, accountKey, chatId);
@@ -326,3 +363,64 @@ export const pollVotes = ({ database }, chatKey, messageId) => database
     answers: JSON.parse(answers),
     votedAt: new Date(votedAt).toISOString(),
 }));
+const reactionStatements = new WeakMap();
+const reactionStatementsOf = (database) => {
+    const held = reactionStatements.get(database);
+    if (held)
+        return held;
+    const statements = {
+        gone: database.prepare("SELECT 1 FROM messages WHERE chat_id=? AND external_id=? AND deleted_at IS NOT NULL"),
+        upsert: database.prepare(`INSERT INTO message_reactions
+         (chat_id, message_external_id, identity_id, own, reaction, reacted_at, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT (chat_id, message_external_id, identity_id) DO UPDATE SET
+         own = excluded.own, reaction = excluded.reaction, reacted_at = excluded.reacted_at,
+         updated_at = excluded.updated_at
+       WHERE excluded.reacted_at >= message_reactions.reacted_at`),
+        held: database.prepare("SELECT reaction, own, reacted_at AS reactedAt FROM message_reactions WHERE chat_id=? AND message_external_id=?"),
+        total: database.prepare("UPDATE messages SET reactions=? WHERE chat_id=? AND external_id=? AND deleted_at IS NULL"),
+    };
+    reactionStatements.set(database, statements);
+    return statements;
+};
+/**
+ * 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 const derivedReactions = ({ database }, chatKey, messageId) => {
+    const rows = reactionStatementsOf(database).held.all(chatKey, messageId);
+    if (rows.length === 0)
+        return undefined;
+    const counts = new Map();
+    let mine = null;
+    for (const { reaction, own, reactedAt } of rows) {
+        if (reaction === null)
+            continue;
+        const held = counts.get(reaction);
+        counts.set(reaction, { count: (held?.count ?? 0) + 1, first: Math.min(held?.first ?? reactedAt, reactedAt) });
+        if (own === 1 && (mine === null || reactedAt > mine.at))
+            mine = { reaction, at: reactedAt };
+    }
+    const sorted = [...counts].sort(([, a], [, b]) => b.count - a.count || a.first - b.first);
+    return {
+        counts: sorted.map(([reaction, { count }]) => ({ reaction, count })),
+        mine: mine?.reaction ?? null,
+        total: sorted.reduce((sum, [, { count }]) => sum + count, 0),
+    };
+};
+/** A reaction older than the one held for that person is dropped, and so is any reaction to a deleted message. */
+export const saveReaction = (context, accountKey, provider, chatKey, messageId, { person, own, reaction, reactedAt }) => {
+    const { database, now } = context;
+    const statements = reactionStatementsOf(database);
+    if (statements.gone.get(chatKey, messageId))
+        return;
+    const reactor = identityPk(context, accountKey, provider, person.id, person.name, person.username ? { username: person.username } : {});
+    const at = toMs(reactedAt) ?? now();
+    statements.upsert.run(chatKey, messageId, reactor, own ? 1 : 0, reaction, at, now(), now());
+    writeDerivedReactions(context, chatKey, messageId);
+};
+export const writeDerivedReactions = (context, chatKey, messageId) => {
+    const derived = derivedReactions(context, chatKey, messageId);
+    if (derived)
+        reactionStatementsOf(context.database).total.run(JSON.stringify(derived), chatKey, messageId);
+};

package/dist/store/sqlite/migrations.generated.js

@@ -554,5 +554,28 @@ export const GENERATED = [
             "CREATE TRIGGER chat_revisions_au AFTER UPDATE OF external_id, title, membership_state, scope, searchable, parent_chat_id ON chats BEGIN\n  INSERT INTO chat_revisions (chat_id, account_id, field, old_value, new_value, source, created_at)\n  SELECT new.id, new.account_id, f.field, f.old_value, f.new_value, s.source,\n    coalesce(s.at, CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER))\n  FROM (\n    SELECT 'external_id' AS field, old.external_id AS old_value, new.external_id AS new_value\n    UNION ALL SELECT 'title', old.title, new.title\n    UNION ALL SELECT 'membership_state', old.membership_state, new.membership_state\n    UNION ALL SELECT 'scope', old.scope, new.scope\n    UNION ALL SELECT 'searchable', old.searchable, new.searchable\n    UNION ALL SELECT 'parent_chat_id', old.parent_chat_id, new.parent_chat_id\n  ) f\n  LEFT JOIN chat_revision_source s ON s.id = 1\n  WHERE f.old_value IS NOT f.new_value;\nEND;",
             "CREATE TRIGGER chat_revisions_ad AFTER DELETE ON chats BEGIN\n  DELETE FROM chat_revisions WHERE chat_id = old.id;\nEND;"
         ]
+    },
+    {
+        "name": "20261021214318_version-26-message-reactions",
+        "statements": [
+            "CREATE TABLE `message_reactions` (\n\t`id` integer PRIMARY KEY,\n\t`chat_id` integer NOT NULL,\n\t`message_external_id` text NOT NULL,\n\t`identity_id` integer NOT NULL,\n\t`own` integer NOT NULL,\n\t`reaction` text,\n\t`reacted_at` integer NOT NULL,\n\t`created_at` integer NOT NULL,\n\t`updated_at` integer NOT NULL,\n\tCONSTRAINT `fk_message_reactions_chat_id_chats_id_fk` FOREIGN KEY (`chat_id`) REFERENCES `chats`(`id`),\n\tCONSTRAINT `fk_message_reactions_identity_id_identities_id_fk` FOREIGN KEY (`identity_id`) REFERENCES `identities`(`id`),\n\tCONSTRAINT `message_reactions_chat_id_message_external_id_identity_id_unique` UNIQUE(`chat_id`,`message_external_id`,`identity_id`)\n);",
+            "CREATE INDEX `message_reactions_by_identity_id` ON `message_reactions` (`identity_id`);"
+        ]
+    },
+    {
+        "name": "20261021221808_version-27-message-delivery",
+        "statements": [
+            "ALTER TABLE `messages` ADD `delivery` integer;"
+        ]
+    },
+    {
+        "name": "20261021224625_version-28-chat-state",
+        "statements": [
+            "ALTER TABLE `chats` ADD `muted` integer;",
+            "ALTER TABLE `chats` ADD `muted_until` integer;",
+            "ALTER TABLE `chats` ADD `archived` integer;",
+            "ALTER TABLE `chats` ADD `marked_unread` integer;",
+            "ALTER TABLE `chats` ADD `unread_counted_at` integer;"
+        ]
     }
 ];

package/dist/store/sqlite/open-store.js

@@ -13,6 +13,20 @@ import { assertReadCompatible } from "./read-compatibility.js";
 import { stemsState } from "./stems.js";
 import { fillStems, followDefaultStemmers } from "./stems-fill.js";
 export const BACKFILL_ON_OPEN = 5_000;
+const NOT_WRITABLE = new Set(["EACCES", "EPERM", "EROFS"]);
+const createWritable = (file) => {
+    try {
+        mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+        // SQLite gives its sidecar files the database's permissions.
+        writeFileSync(file, "", { flag: "a", mode: 0o600 });
+    }
+    catch (error) {
+        if (!NOT_WRITABLE.has(error.code ?? ""))
+            throw error;
+        // The errno's own sentence names the path, which holds the owner's home folder.
+        throw new CliError("permission_error", "the message store cannot be written from here; run where it is writable, or set MESSAGING_STORE", { reason: "store.not-writable" });
+    }
+};
 export const openStoreContext = async ({ path, env, now = Date.now, command, readOnly = false, } = {}) => {
     if (typeof readOnly !== "boolean")
         throw new CliError("validation_error", "readOnly must be a boolean");
@@ -22,11 +36,8 @@ export const openStoreContext = async ({ path, env, now = Date.now, command, rea
         if (!statSync(file, { throwIfNoEntry: false })?.isFile())
             throw new CliError("not_found", "The store does not exist as a file; read-only opening does not create it");
     }
-    else {
-        mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
-        // SQLite gives its sidecar files the database's permissions.
-        writeFileSync(file, "", { flag: "a", mode: 0o600 });
-    }
+    else
+        createWritable(file);
     const opened = await openSqlite(file, { readOnly });
     const database = opened.database;
     try {

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

@@ -266,6 +266,22 @@ export declare const MESSAGE_FIELDS: {
         identity: undefined;
         generated: undefined;
     }, {}>;
+    delivery: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: string;
+        tableName: "messages";
+        dataType: "number int53";
+        data: number;
+        driverParam: number;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}>;
 };
 export interface MessageRow {
     pk: number;
@@ -286,6 +302,7 @@ export interface MessageRow {
     providerMetadata: string | null;
     mentions: string | null;
     starred: number | null;
+    delivery: number | null;
 }
 export declare const selectMessages: ({ orm }: StoreContext) => Omit<import("drizzle-orm/sqlite-core").SQLiteAsyncSelectBase<"messages", "sync", unknown, {
     pk: import("drizzle-orm/sqlite-core").SQLiteColumn<{
@@ -546,6 +563,22 @@ export declare const selectMessages: ({ orm }: StoreContext) => Omit<import("dri
         identity: undefined;
         generated: undefined;
     }, {}>;
+    delivery: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: string;
+        tableName: "messages";
+        dataType: "number int53";
+        data: number;
+        driverParam: number;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}>;
 }, "partial", Record<"messages", "not-null"> & {
     chats: "not-null";
 } & {
@@ -569,6 +602,7 @@ export declare const selectMessages: ({ orm }: StoreContext) => Omit<import("dri
     providerMetadata: string | null;
     mentions: string | null;
     starred: number | null;
+    delivery: number | null;
 }[], {
     pk: import("drizzle-orm/sqlite-core").SQLiteColumn<{
         name: string;
@@ -828,6 +862,22 @@ export declare const selectMessages: ({ orm }: StoreContext) => Omit<import("dri
         identity: undefined;
         generated: undefined;
     }, {}>;
+    delivery: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: string;
+        tableName: "messages";
+        dataType: "number int53";
+        data: number;
+        driverParam: number;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}>;
 }>, never>;
 export declare const newestFirst: SQL<unknown>[];
 export declare const before: (sentAt: number, pk: number) => SQL<unknown>;

package/dist/store/sqlite/reads.js

@@ -1,7 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { and, asc, desc, eq, gt, gte, inArray, isNull, lte, or, sql } from "./drizzle/core.js";
 import { attachments, chats, identities, messageRevisions, messages } from "./schema.js";
-import { parsed, present, toIso, toMs } from "./values.js";
+import { deliveryOf, parsed, present, toIso, toMs } from "./values.js";
 /**
  * One flat row for every read, aliased where tables share a column name, so the same mapper serves
  * a plain select and a subquery (`find` per chat).
@@ -25,6 +25,7 @@ export const MESSAGE_FIELDS = {
     providerMetadata: messages.metadata,
     mentions: messages.mentions,
     starred: messages.starred,
+    delivery: messages.delivery,
 };
 export const selectMessages = ({ orm }) => orm
     .select(MESSAGE_FIELDS)
@@ -236,6 +237,7 @@ const toMessage = (row, attachments) => {
         reactions: parsed(row.reactions) ?? null,
         ...present({ providerMetadata: parsed(row.providerMetadata), mentions: parsed(row.mentions) }),
         ...(row.starred === 1 ? { starred: true } : {}),
+        ...present({ delivery: deliveryOf(row.delivery) }),
     };
 };
 /**

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

@@ -2596,6 +2596,86 @@ export declare const chats: import("drizzle-orm/sqlite-core").SQLiteTableWithCol
             identity: undefined;
             generated: undefined;
         }, {}>;
+        muted: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chats";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        mutedUntil: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chats";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        archived: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chats";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        markedUnread: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chats";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        unreadCountedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "chats";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
     };
     dialect: 'sqlite';
 }>;
@@ -3365,6 +3445,22 @@ export declare const messages: import("drizzle-orm/sqlite-core").SQLiteTableWith
             identity: undefined;
             generated: undefined;
         }, {}>;
+        delivery: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "messages";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
     };
     dialect: 'sqlite';
 }>;
@@ -4478,6 +4574,161 @@ export declare const chatEventPeople: import("drizzle-orm/sqlite-core").SQLiteTa
     };
     dialect: 'sqlite';
 }>;
+/**
+ * Each person's newest reaction to a message, for a messenger that sends one person's change at a time; the store
+ * derives `messages.reactions` from them. Keyed by chat and external id: a reaction can arrive before its message.
+ */
+export declare const messageReactions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "message_reactions";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        chatId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        messageExternalId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        identityId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        own: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        reaction: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        reactedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "message_reactions";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: 'sqlite';
+}>;
 /** One read of a chat's member list. Retention reads presence at a checkpoint from these, not from stays. */
 export declare const memberObservations: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: "member_observations";

package/dist/store/sqlite/schema.js

@@ -261,6 +261,11 @@ export const chats = sqliteTable("chats", {
     createdAt: integer("created_at").notNull(),
     parentChatId: integer("parent_chat_id").references(() => chats.id),
     scope: text("scope"),
+    muted: integer("muted"),
+    mutedUntil: integer("muted_until"),
+    archived: integer("archived"),
+    markedUnread: integer("marked_unread"),
+    unreadCountedAt: integer("unread_counted_at"),
 }, (table) => [
     unique().on(table.accountId, table.externalId),
     index("chats_by_recency").on(table.accountId, desc(table.lastMessageAt)),
@@ -348,6 +353,7 @@ export const messages = sqliteTable("messages", {
     updatedAt: integer("updated_at").notNull(),
     threadRootId: integer("thread_root_id").references(() => messages.id),
     starred: integer("starred"),
+    delivery: integer("delivery"),
 }, (table) => [
     unique().on(table.chatId, table.externalId),
     index("messages_by_time").on(table.chatId, desc(table.sentAt)),
@@ -511,6 +517,28 @@ export const chatEventPeople = sqliteTable("chat_event_people", {
     primaryKey({ columns: [table.chatEventId, table.identityId] }),
     index("chat_event_people_by_identity_id").on(table.identityId),
 ]);
+/**
+ * Each person's newest reaction to a message, for a messenger that sends one person's change at a time; the store
+ * derives `messages.reactions` from them. Keyed by chat and external id: a reaction can arrive before its message.
+ */
+export const messageReactions = sqliteTable("message_reactions", {
+    id: integer("id").primaryKey(),
+    chatId: integer("chat_id")
+        .notNull()
+        .references(() => chats.id),
+    messageExternalId: text("message_external_id").notNull(),
+    identityId: integer("identity_id")
+        .notNull()
+        .references(() => identities.id),
+    own: integer("own").notNull(),
+    reaction: text("reaction"),
+    reactedAt: integer("reacted_at").notNull(),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+}, (table) => [
+    unique().on(table.chatId, table.messageExternalId, table.identityId),
+    index("message_reactions_by_identity_id").on(table.identityId),
+]);
 /** One read of a chat's member list. Retention reads presence at a checkpoint from these, not from stays. */
 export const memberObservations = sqliteTable("member_observations", {
     id: integer("id").primaryKey(),