toolroll 0.9.52 → 0.9.54

package/dist/chat-delivery-state.js

@@ -1,210 +1,180 @@
-/** Durable private-chat receipts. Each transport has its own tables and lease. */
-import { createHash, randomBytes } from "node:crypto";
+/** Durable chat receipts on the shared chat core: what each app's chats sent us and what we plan to send them. */
+import { randomBytes } from "node:crypto";
 import { MATE_ASK_TTL_MS } from "./store.js";
-import { chatSchema, chatTables } from "./contracts/chat-tables.js";
+import { ChatCore, chatHash } from "./chat-core.js";
+import { ChatMessages } from "./chat-messages.js";
 import { readChatPart, savedChatEventBody, savedChatPart } from "./contracts/chat-content.js";
-export { savedChatPart };
-export { chatSchema, chatTables };
-export const chatHash = (text) => createHash("sha256").update(text).digest("hex");
-export class ChatState {
-    store;
-    channel;
-    constructor(store, channel) {
-        this.store = store;
-        this.channel = channel;
-    }
-    prepare(sql) {
-        return this.db.prepare(sql.replace(/\bchat_(binding|pair|event|part|action|progress|runtime|room|meta|flow_action|flow_prompt|flow_choice|flow_note|question_action|question_prompt|ask_action)\b/g, `${this.channel}_$1`));
-    }
-    /** Small transport facts a channel must remember per chat (a Teams service URL). Never credentials. */
-    meta(installation, key) {
-        const row = this.prepare("SELECT value FROM chat_meta WHERE installation=? AND key=?").get(installation, key);
-        return row === undefined ? null : String(row.value);
-    }
-    setMeta(installation, key, value, now) {
-        this.prepare("INSERT INTO chat_meta(installation,key,value,updated) VALUES(?,?,?,?) ON CONFLICT(installation,key) DO UPDATE SET value=excluded.value,updated=excluded.updated").run(installation, key, value, now.toISOString());
-    }
-    // ---- rooms (v73) -----------------------------------------------------------
-    readRoom(row) {
-        return { id: Number(row.id), installation: String(row.installation), chat: String(row.chat), kind: row.kind === "group" ? "group" : "private",
-            conversation: String(row.conversation), boundBy: String(row.bound_by), binding: Number(row.binding), cursor: Number(row.cursor) };
-    }
-    room(installation, chat) {
-        const row = this.prepare("SELECT * FROM chat_room WHERE installation=? AND chat=? AND revoked IS NULL").get(installation, chat);
-        return row === undefined ? null : this.readRoom(row);
-    }
-    rooms(installation) {
-        return this.prepare("SELECT * FROM chat_room WHERE installation=? AND revoked IS NULL ORDER BY id").all(installation).map(row => this.readRoom(row));
-    }
-    /** Point a chat at a conversation; an earlier choice for the same chat is revoked and delivery starts from now. */
-    bindRoom(args, now) {
-        return this.store.transact(() => {
-            const stamp = now.toISOString();
-            // Check the expected collision before revoking the current selection.
-            if (args.kind === "group") {
-                const group = this.prepare("SELECT installation, chat FROM chat_room WHERE conversation=? AND kind='group' AND revoked IS NULL").get(args.conversation);
-                if (group !== undefined && (group.installation !== args.installation || group.chat !== args.chat))
-                    return { ok: false, reason: "group-taken" };
-            }
-            this.prepare("UPDATE chat_room SET revoked=?,revoked_by=? WHERE installation=? AND chat=? AND revoked IS NULL").run(stamp, args.by, args.installation, args.chat);
-            const thread = this.db.prepare("SELECT thread FROM team_conversation WHERE id=?").get(args.conversation);
-            if (thread === undefined)
-                throw new Error("no such team conversation");
-            const cursor = Number(this.db.prepare("SELECT COALESCE(MAX(id),0) AS n FROM mate_message WHERE thread=?").get(Number(thread["thread"]))?.["n"] ?? 0);
-            this.prepare("INSERT INTO chat_room(installation,chat,kind,conversation,binding,bound_by,bound,cursor) VALUES(?,?,?,?,?,?,?,?)").run(args.installation, args.chat, args.kind, args.conversation, args.binding, args.by, stamp, cursor);
-            return { ok: true };
-        });
-    }
-    unbindRoom(installation, chat, by, now) {
-        return Number(this.prepare("UPDATE chat_room SET revoked=?,revoked_by=? WHERE installation=? AND chat=? AND revoked IS NULL").run(now.toISOString(), by, installation, chat).changes) > 0;
-    }
-    /** The shared rooms core's view of this installation's room records. */
-    roomBackend(installation, now) {
-        const roomOf = (room) => room === null ? null : { id: room.id, chatId: room.chat, kind: room.kind, conversation: room.conversation, boundBy: room.boundBy, binding: room.binding, cursor: room.cursor };
-        return {
-            room: chat => roomOf(this.room(installation, chat)),
-            bind: args => this.bindRoom({ installation, chat: args.chatId, kind: args.kind, conversation: args.conversation, by: args.by, binding: args.binding }, now),
-            unbind: (chat, by) => this.unbindRoom(installation, chat, by, now),
-            grant: id => { const binding = this.bindingById(id); return binding === null || !this.live(binding) ? null : { approver: binding.approver, generation: binding.generation, chatId: binding.channel }; },
-        };
-    }
-    advanceRoomCursor(id, messageId) {
-        return Number(this.prepare("UPDATE chat_room SET cursor=? WHERE id=? AND cursor<? AND revoked IS NULL").run(messageId, id, messageId).changes) > 0;
-    }
-    get db() {
-        return this.store.handle;
-    }
-    /** Every unrevoked binding for an installation, oldest first: one per
-     * paired person (v73). Liveness is checked per binding with `live`. */
-    bindings(installation) {
-        return this.prepare("SELECT * FROM chat_binding WHERE installation=? AND revoked IS NULL ORDER BY id").all(installation);
-    }
-    /** The unrevoked binding one channel member holds, if any. */
-    bindingFor(installation, member) {
-        return (this.prepare("SELECT * FROM chat_binding WHERE installation=? AND member=? AND revoked IS NULL").get(installation, member) ?? null);
-    }
-    bindingById(id) {
-        return (this.prepare("SELECT * FROM chat_binding WHERE id=? AND revoked IS NULL").get(id) ?? null);
-    }
-    /** The oldest unrevoked binding — the single-person reading kept for
-     * status lines and fixtures; inbound, delivery and notices read
-     * `bindingFor` / `bindingById` / `bindings`. */
-    binding(installation) {
-        return this.bindings(installation)[0] ?? null;
-    }
-    live(binding) {
-        const current = this.bindingById(binding.id);
-        const account = this.store.accountOf(binding.approver);
-        return (current !== null &&
-            account?.role === "approver" &&
-            account.revokedAt === null &&
-            account.generation === binding.generation);
-    }
-    /** End one person's pairing and everything their chat could still do; teammates' bindings stay. */
-    revokeBinding(binding, now = new Date()) {
-        this.store.transact(() => {
-            this.prepare("UPDATE chat_binding SET revoked=? WHERE id=? AND revoked IS NULL").run(now.toISOString(), binding.id);
-            this.prepare("UPDATE chat_event SET state='dropped',payload='{}',problem='Chat disconnected' WHERE binding=? AND state='queued'").run(binding.id);
-            this.prepare("UPDATE chat_part SET state='dropped',problem='Chat disconnected' WHERE state='pending' AND event IN (SELECT id FROM chat_event WHERE binding=?)").run(binding.id);
-        });
-    }
-    revoke(installation, now = new Date()) {
-        this.store.transact(() => {
-            this.prepare("UPDATE chat_binding SET revoked=? WHERE installation=? AND revoked IS NULL").run(now.toISOString(), installation);
-            this.prepare("UPDATE chat_pair SET consumed=? WHERE installation=? AND consumed IS NULL").run(now.toISOString(), installation);
-            this.prepare("UPDATE chat_event SET state='dropped',payload='{}',problem='Chat disconnected' WHERE installation=? AND state='queued'").run(installation);
-            this.prepare("UPDATE chat_part SET state='dropped',problem='Chat disconnected' WHERE state='pending' AND event IN (SELECT id FROM chat_event WHERE installation=?)").run(installation);
-        });
-    }
+export { savedChatPart, chatHash };
+const DAY_MS = 86_400_000;
+/** One app's chats on the shared core (the same object Telegram's run on): its events, planned parts and their buttons. */
+export class ChatState extends ChatMessages {
+    constructor(store, provider) {
+        super(store, provider);
+    }
+    /** Pair-time half kept for the settings pages: mint a code for this installation and return it (only its hash is kept). */
     pairing(installation, approver, generation, now = new Date()) {
         const code = randomBytes(16).toString("hex");
-        this.store.transact(() => {
-            // A fresh code replaces this person's outstanding ones; a teammate's pending code is theirs.
-            this.prepare("UPDATE chat_pair SET consumed=? WHERE installation=? AND approver=? AND consumed IS NULL").run(now.toISOString(), installation, approver);
-            this.prepare("INSERT INTO chat_pair VALUES(?,?,?,?,?,NULL)").run(chatHash(code), installation, approver, generation, new Date(now.getTime() + 600_000).toISOString());
-        });
+        this.savePairing({ hash: chatHash(code), installation, approver, generation, by: approver }, now);
         return code;
     }
-    pair(identity, hash, member, channel, now) {
+    /**
+     * Consume a code sent in a chat (the shared rules, chat-core.ts). The installation's notice cursor starts from now
+     * on its FIRST pairing; a later person joins the running cursor (their own history is fenced by their binding's
+     * creation time).
+     */
+    pair(identity, hash, member, channel, now, event = null) {
         return this.store.transact(() => {
-            const pair = this.prepare("SELECT approver,generation FROM chat_pair WHERE hash=? AND installation=? AND consumed IS NULL AND expires>?").get(hash, identity.installation, now.toISOString());
-            if (!pair)
+            const paired = this.consumePairing({ hash, installation: identity.installation, team: identity.team ?? identity.app, app: identity.app, member, channel, event }, now);
+            if (!paired.ok)
                 return null;
-            // One binding per channel member, and one channel identity per person.
-            if (this.bindingFor(identity.installation, member))
-                return null;
-            if (this.bindings(identity.installation).some(one => one.approver === String(pair.approver) && this.live(one)))
-                return null;
-            const account = this.store.accountOf(String(pair.approver));
-            if (account?.role !== "approver" ||
-                account.revokedAt !== null ||
-                account.generation !== Number(pair.generation))
-                return null;
-            this.prepare("UPDATE chat_pair SET consumed=? WHERE hash=?").run(now.toISOString(), hash);
-            this.prepare("INSERT INTO chat_binding(installation,team,app,member,channel,approver,generation,created) VALUES(?,?,?,?,?,?,?,?)").run(identity.installation, identity.team ?? identity.app, identity.app, member, channel, String(pair.approver), Number(pair.generation), now.toISOString());
-            // The installation's notice cursor starts from now on its FIRST pairing;
-            // a later person joins the running cursor (their own history is fenced
-            // by their binding's creation time).
-            this.prepare("INSERT OR IGNORE INTO chat_runtime(installation, notification) VALUES(?, (SELECT COALESCE(MAX(id),0) FROM notification))").run(identity.installation);
-            return this.bindingFor(identity.installation, member);
+            this.prepare("INSERT OR IGNORE INTO chat_runtime (provider, installation, notification) VALUES (:provider, ?, (SELECT COALESCE(MAX(id), 0) FROM notification))")
+                .run(identity.installation);
+            return paired.binding;
         });
     }
-    /** Save a received event with its body (contracts/chat-content.ts), versioned. */
+    /** The 60-second lease the Slack, Discord and Teams workers renew. */
+    lease(installation, owner, now) {
+        return this.acquire(installation, owner, 60_000, now).ok;
+    }
+    /** Save a received event with its body (contracts/chat-content.ts), versioned. False: it was already here. */
     enqueue(event) {
-        return (Number(this.prepare("INSERT OR IGNORE INTO chat_event(id,installation,binding,kind,channel,member,ts,thread,payload,created) VALUES(?,?,?,?,?,?,?,?,?,?)").run(event.id, event.installation, event.binding, event.kind, event.channel, event.member, event.ts, event.thread, savedChatEventBody(event.payload), event.created).changes) === 1);
+        return Number(this.prepare(`INSERT OR IGNORE INTO chat_event (provider, id, installation, binding, kind, channel, member, ts, thread, payload, created)
+      VALUES (:provider, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(event.id, event.installation, event.binding, event.kind, event.channel, event.member, event.ts, event.thread, savedChatEventBody(event.payload), event.created).changes) === 1;
     }
     event(id) {
-        return (this.prepare("SELECT * FROM chat_event WHERE id=?").get(id) ?? null);
+        return this.prepare("SELECT * FROM chat_event WHERE provider = :provider AND id = ?").get(id) ?? null;
     }
     next(installation, now) {
-        return (this.prepare("SELECT * FROM chat_event WHERE installation=? AND state='queued' AND (next_at IS NULL OR next_at<=?) ORDER BY created,id LIMIT 1").get(installation, now.toISOString()) ?? null);
+        return this.prepare(`SELECT * FROM chat_event WHERE provider = :provider AND installation = ? AND kind <> 'update' AND state = 'queued'
+      AND (next_at IS NULL OR next_at <= ?) ORDER BY created, id LIMIT 1`).get(installation, now.toISOString()) ?? null;
     }
     defer(event, problem, until) {
-        this.prepare("UPDATE chat_event SET next_at=?,problem=? WHERE id=? AND state='queued'").run(until.toISOString(), problem, event);
+        this.prepare("UPDATE chat_event SET next_at = ?, problem = ? WHERE provider = :provider AND id = ? AND state = 'queued'").run(until.toISOString(), problem, event);
     }
     finish(event, dropped = false) {
-        this.prepare("UPDATE chat_event SET state=?,payload='{}' WHERE id=?").run(dropped ? "dropped" : "done", event);
+        this.prepare("UPDATE chat_event SET state = ?, payload = '{}' WHERE provider = :provider AND id = ?").run(dropped ? "dropped" : "done", event);
+    }
+    /** Point an event at the binding its pairing made. */
+    setEventBinding(event, binding) {
+        this.prepare("UPDATE chat_event SET binding = ? WHERE provider = :provider AND id = ?").run(binding, event);
     }
     part(id) {
-        return (this.prepare("SELECT * FROM chat_part WHERE id=?").get(id) ?? null);
+        return this.prepare("SELECT * FROM chat_part WHERE provider = :provider AND id = ?").get(id) ?? null;
     }
+    /** The reply to an event, part by part, with each part's buttons minted with it; the event is then handled. Planned once. */
     plan(event, parts, now) {
         this.store.transact(() => {
             for (const [ordinal, part] of parts.entries()) {
-                const inserted = this.prepare("INSERT OR IGNORE INTO chat_part(event,ordinal,payload,created) VALUES(?,?,?,?)").run(event, ordinal, savedChatPart(part), now.toISOString());
-                if (Number(inserted.changes) && part.proposal)
-                    this.tokens(Number(inserted.lastInsertRowid), part.proposal, ["confirm", "dismiss"], now);
-                if (Number(inserted.changes) && part.question)
+                if (this.prepare("SELECT 1 AS hit FROM chat_part WHERE provider = :provider AND event = ? AND ordinal = ?").get(event, ordinal) !== undefined)
+                    continue;
+                const id = this.nextId("chat_part");
+                this.prepare("INSERT INTO chat_part (provider, id, event, ordinal, payload, created) VALUES (:provider, ?, ?, ?, ?, ?)").run(id, event, ordinal, savedChatPart(part), now.toISOString());
+                const token = () => randomBytes(16).toString("hex");
+                if (part.proposal)
+                    this.tokens(id, part.proposal, ["confirm", "dismiss"], now);
+                if (part.question)
                     for (const one of part.question.choices)
-                        this.prepare("INSERT INTO chat_question_action(token,part,question,choice,expires) VALUES(?,?,?,?,?)").run(randomBytes(16).toString("hex"), Number(inserted.lastInsertRowid), part.question.id, one.choice, new Date(now.getTime() + 7 * 86_400_000).toISOString());
-                if (Number(inserted.changes) && part.ask)
+                        this.prepare("INSERT INTO chat_question_action (provider, token, part, question, choice, created, expires) VALUES (:provider, ?, ?, ?, ?, ?, ?)")
+                            .run(token(), id, part.question.id, one.choice, now.toISOString(), new Date(now.getTime() + 7 * DAY_MS).toISOString());
+                if (part.ask)
                     for (const choice of [...part.ask.options.map((_, index) => index), null])
-                        this.prepare("INSERT INTO chat_ask_action(token,part,turn,choice,expires) VALUES(?,?,?,?,?)").run(randomBytes(16).toString("hex"), Number(inserted.lastInsertRowid), part.ask.turn, choice, new Date(now.getTime() + MATE_ASK_TTL_MS).toISOString());
-                if (Number(inserted.changes) && part.choose)
+                        this.prepare("INSERT INTO chat_ask_action (provider, token, part, turn, choice, expires) VALUES (:provider, ?, ?, ?, ?, ?)")
+                            .run(token(), id, part.ask.turn, choice, new Date(now.getTime() + MATE_ASK_TTL_MS).toISOString());
+                if (part.choose)
                     for (const one of part.choose.options)
-                        this.prepare("INSERT INTO chat_flow_choice(token,part,card,entry,choice,label,expires) VALUES(?,?,?,?,?,?,?)").run(randomBytes(16).toString("hex"), Number(inserted.lastInsertRowid), part.choose.card, part.choose.entry, one.choice, one.label, new Date(now.getTime() + 7 * 86_400_000).toISOString());
-                if (Number(inserted.changes) && part.note)
+                        this.prepare("INSERT INTO chat_flow_choice (provider, token, part, card, entry, choice, label, created, expires) VALUES (:provider, ?, ?, ?, ?, ?, ?, ?, ?)")
+                            .run(token(), id, part.choose.card, part.choose.entry, one.choice, one.label, now.toISOString(), new Date(now.getTime() + 7 * DAY_MS).toISOString());
+                if (part.note)
                     for (const answer of ["yes", "no"])
-                        this.prepare("INSERT INTO chat_flow_note(token,part,card,entry,held,answer,expires) VALUES(?,?,?,?,?,?,?)").run(randomBytes(16).toString("hex"), Number(inserted.lastInsertRowid), part.note.card, part.note.entry, part.note.held, answer, new Date(now.getTime() + 86_400_000).toISOString());
-                if (Number(inserted.changes) && part.flow)
+                        this.prepare("INSERT INTO chat_flow_note (provider, token, part, card, entry, held, answer, expires) VALUES (:provider, ?, ?, ?, ?, ?, ?, ?)")
+                            .run(token(), id, part.note.card, part.note.entry, part.note.held, answer, new Date(now.getTime() + DAY_MS).toISOString());
+                if (part.flow)
                     for (const action of part.flow.actions)
-                        this.prepare("INSERT INTO chat_flow_action(token,part,card,entry,action,expires) VALUES(?,?,?,?,?,?)").run(randomBytes(16).toString("hex"), Number(inserted.lastInsertRowid), part.flow.card, part.flow.entry, action, new Date(now.getTime() + 7 * 86_400_000).toISOString());
+                        this.prepare("INSERT INTO chat_flow_action (provider, token, part, card, entry, action, created, expires) VALUES (:provider, ?, ?, ?, ?, ?, ?, ?)")
+                            .run(token(), id, part.flow.card, part.flow.entry, action, now.toISOString(), new Date(now.getTime() + 7 * DAY_MS).toISOString());
             }
             this.finish(event);
         });
     }
+    /** A proposal card's buttons on its part: earlier ones on that part are spent. Yes and Cancel last ten minutes. */
     tokens(part, proposal, phases, now) {
-        this.prepare("UPDATE chat_action SET consumed=? WHERE part=? AND consumed IS NULL").run(now.toISOString(), part);
+        this.prepare("UPDATE chat_action SET consumed = ? WHERE provider = :provider AND part = ? AND consumed IS NULL").run(now.toISOString(), part);
         for (const phase of phases)
-            this.prepare("INSERT INTO chat_action VALUES(?,?,?,?,?,NULL)").run(randomBytes(16).toString("hex"), part, proposal, phase, new Date(now.getTime() +
-                (phase === "yes" || phase === "cancel" ? 600_000 : 86_400_000)).toISOString());
-    }
-    lease(installation, owner, now) {
-        this.prepare("INSERT OR IGNORE INTO chat_runtime(installation) VALUES(?)").run(installation);
-        return (Number(this.prepare("UPDATE chat_runtime SET owner=?,lease_until=? WHERE installation=? AND (owner=? OR lease_until IS NULL OR lease_until<=?)").run(owner, new Date(now.getTime() + 60_000).toISOString(), installation, owner, now.toISOString()).changes) === 1);
+            this.prepare("INSERT INTO chat_action (provider, token, part, proposal, phase, created, expires) VALUES (:provider, ?, ?, ?, ?, ?, ?)").run(randomBytes(16).toString("hex"), part, proposal, phase, now.toISOString(), new Date(now.getTime() + (phase === "yes" || phase === "cancel" ? 600_000 : DAY_MS)).toISOString());
+    }
+    /** A proposal card's live buttons on one part, in the order they were minted. */
+    partTokens(part, now) {
+        return this.prepare("SELECT token, phase FROM chat_action WHERE provider = :provider AND part = ? AND consumed IS NULL AND expires > ? ORDER BY rowid")
+            .all(part, now.toISOString()).map(row => ({ token: String(row["token"]), phase: String(row["phase"]) }));
+    }
+    // ---- sending, the same for every app's worker ----------------------------------------------------------------------
+    /** The next part to send for an installation: notices only while notifications may go out. */
+    nextPart(installation, notices, now, order = "id") {
+        return this.prepare(`SELECT p.* FROM chat_part p JOIN chat_event e ON e.provider = p.provider AND e.id = p.event
+      WHERE p.provider = :provider AND e.installation = ? AND p.state = 'pending' AND (e.kind <> 'notice' OR ? = 1)
+        AND (p.next_at IS NULL OR p.next_at <= ?) ORDER BY ${order === "created" ? "p.created, " : ""}p.id LIMIT 1`)
+            .get(installation, notices ? 1 : 0, now.toISOString()) ?? null;
+    }
+    /** A part that will not go: why, in words the saved chat shows. */
+    dropPart(id, problem) {
+        this.prepare("UPDATE chat_part SET state = 'dropped', next_at = NULL, problem = ? WHERE provider = :provider AND id = ?").run(problem, id);
+    }
+    /** Try again no earlier than then (a screenshot waiting for its result's message). */
+    holdPart(id, until) {
+        this.prepare("UPDATE chat_part SET next_at = ? WHERE provider = :provider AND id = ?").run(until, id);
+    }
+    /** The app's upload identity for a part's file, and whether its bytes are up. */
+    setPartFile(id, file, uploaded, message) {
+        if (message !== undefined)
+            this.prepare("UPDATE chat_part SET message = ? WHERE provider = :provider AND id = ?").run(message, id);
+        if (file !== null)
+            this.prepare("UPDATE chat_part SET file = ? WHERE provider = :provider AND id = ?").run(file, id);
+        if (uploaded !== undefined)
+            this.prepare("UPDATE chat_part SET uploaded = ? WHERE provider = :provider AND id = ?").run(uploaded ? 1 : 0, id);
+    }
+    /**
+     * Sent: on the app's own message id when it gave one (an uploaded file may not). A card's decide buttons
+     * (chat-decide.ts) now ride that message, and any older ones on it stop working; a "What should change?" names it.
+     */
+    partSent(id, message, now, attempt = true) {
+        this.store.transact(() => {
+            this.prepare(`UPDATE chat_part SET state = 'sent', message = COALESCE(?, message), attempts = attempts + ?, problem = NULL, next_at = NULL, sent = ?
+        WHERE provider = :provider AND id = ?`).run(message, attempt ? 1 : 0, now.toISOString(), id);
+            const row = this.prepare(`SELECT p.payload, p.message, b.channel AS own FROM chat_part p JOIN chat_event e ON e.provider = p.provider AND e.id = p.event
+        LEFT JOIN chat_binding b ON b.provider = e.provider AND b.id = e.binding WHERE p.provider = :provider AND p.id = ?`).get(id);
+            const read = row === undefined ? null : readChatPart(String(row["payload"]));
+            const placed = row?.["message"] == null ? null : String(row["message"]);
+            if (read?.ok !== true || placed === null)
+                return;
+            const content = read.value, chat = content.channel ?? (row?.["own"] == null ? null : String(row["own"]));
+            if (chat !== null) {
+                // What the message shows now is all that acts on it: buttons it no longer shows stop working.
+                const tokens = JSON.stringify((content.decide?.rows ?? []).flat().flatMap(one => "token" in one ? [one.token] : []));
+                this.prepare(`UPDATE chat_decide_action SET consumed_at = ? WHERE channel = :provider AND chat = ? AND message = ? AND consumed_at IS NULL
+          AND token NOT IN (SELECT value FROM json_each(?))`).run(now.toISOString(), chat, placed, tokens);
+                if (content.decide !== undefined)
+                    this.prepare("UPDATE chat_decide_action SET message = ? WHERE channel = :provider AND message IS NULL AND token IN (SELECT value FROM json_each(?))").run(placed, tokens);
+            }
+            if (content.prompt !== undefined)
+                this.prepare("UPDATE chat_decide_prompt SET message = ? WHERE channel = :provider AND id = ? AND message IS NULL").run(placed, content.prompt);
+        });
     }
-    owns(installation, owner, now = new Date()) {
-        return !!this.prepare("SELECT 1 FROM chat_runtime WHERE installation=? AND owner=? AND lease_until>?").get(installation, owner, now.toISOString());
+    /** Not sent this time: counted, named, and (when the answer was lost rather than refused) counted as uncertain. */
+    partFailed(id, failure, giveUpAfter) {
+        this.prepare(`UPDATE chat_part SET attempts = attempts + 1, uncertain = uncertain + ?, next_at = ?, problem = ?,
+      state = CASE WHEN ? IS NOT NULL AND attempts >= ? THEN 'dropped' ELSE state END WHERE provider = :provider AND id = ?`)
+            .run(failure.uncertain ? 1 : 0, failure.until, failure.problem, giveUpAfter ?? null, giveUpAfter ?? 0, id);
+    }
+    /** One person's replies still waiting to send, and those that could not be delivered (settings show both). */
+    partCounts(binding) {
+        const row = this.prepare(`SELECT SUM(p.state = 'pending') AS pending, SUM(p.state = 'dropped') AS dropped FROM chat_part p
+      JOIN chat_event e ON e.provider = p.provider AND e.id = p.event WHERE p.provider = :provider AND e.binding = ?`).get(binding);
+        return { pending: Number(row?.["pending"] ?? 0), dropped: Number(row?.["dropped"] ?? 0) };
+    }
+    /** Replace a part's content and send it again (a repaint after a tap). */
+    repaint(id, content) {
+        this.prepare("UPDATE chat_part SET payload = ?, state = 'pending', next_at = NULL WHERE provider = :provider AND id = ?").run(savedChatPart(content), id);
     }
 }
 /** A saved part's content. One that can't be read is a delivery problem that names the field, never a guess. */

package/dist/chat-delivery.d.ts

@@ -1,8 +1,8 @@
 import { type WarmHooks } from "./chat-warmth.js";
-import { type DoorOptions } from "./mate-doors.js";
-import { ChatState, type ChatBinding, type ChatEvent, type ChatIdentity } from "./chat-delivery-state.js";
+import { ChatState, type ChatBinding, type ChatContent, type ChatEvent, type ChatIdentity } from "./chat-delivery-state.js";
 import { type Store } from "./store.js";
 import type { SubscriptionMateRunner } from "./subscription-chat.js";
+import { type ChatMerge } from "./chat-decide.js";
 export declare const chatObject: (v: unknown) => Record<string, unknown>;
 export type ChatDeliveryOptions = {
     store: Store;
@@ -16,19 +16,35 @@ export type ChatDeliveryOptions = {
     current: () => boolean;
     origin: () => string | null;
     subscriptionRunner?: SubscriptionMateRunner;
-    held?: DoorOptions["held"];
     canNotify?: () => boolean;
     clock?: () => Date;
     partSize?: number;
     maxProposal?: number;
     /** The app's warm touches for one owner message (a 👍, typing), where the app and the bot's permissions allow them. */
     warm?: (event: ChatEvent, binding: ChatBinding) => WarmHooks;
+    /** Merges a pull request approved in chat (tests script it); otherwise the project's own merge. */
+    merge?: (input: {
+        runId: number;
+        by: string;
+    }) => Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        message: string;
+    }>;
 };
 export declare const splitChatText: (text: string, size?: number) => string[];
 export declare function channelAccess(options: ChatDeliveryOptions, binding: ChatBinding, ceiling?: string): Promise<string[]>;
+/** A merge approved in chat, waiting on GitHub, and the card that says how it went. */
+type PendingMerge = {
+    merge: ChatMerge;
+    part: number;
+    shown: string;
+    content: ChatContent;
+};
 export declare function processChatEvent(options: ChatDeliveryOptions): Promise<boolean>;
 /** Bound to the paired member, exact channel/message, pending proposal and current ceiling. */
-export declare function applyChatAction(options: ChatDeliveryOptions, event: ChatEvent, binding: ChatBinding, repos: readonly string[]): void;
+export declare function applyChatAction(options: ChatDeliveryOptions, event: ChatEvent, binding: ChatBinding, repos: readonly string[]): PendingMerge | null;
 /**
  * Carry new conversation messages to every room that follows one: the
  * lead's replies, teammates' messages (never the room's own), and each
@@ -39,3 +55,4 @@ export declare function applyChatAction(options: ChatDeliveryOptions, event: Cha
 export declare function planRoomMessages(options: ChatDeliveryOptions): Promise<void>;
 /** One progress card per exact result; separate urgent facts retain their own review link. */
 export declare function planChatNotifications(options: ChatDeliveryOptions): Promise<void>;
+export {};