@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.3

package/dist/channels/outbound.js

@@ -1,33 +1,35 @@
-import { createHash, randomUUID } from "node:crypto";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { randomUUID } from "node:crypto";
 import { isChannelSendError, } from "@capybara-hq/plugin-sdk";
-import { DelayedError, Queue, UnrecoverableError, Worker } from "bullmq";
+import { Inject, Injectable } from "@nestjs/common";
+import { DelayedError, UnrecoverableError } from "bullmq";
 import { sql } from "kysely";
-import { conversationTopic, } from "../conversations/event-log.js";
+import { conversationTopic, EventLog, } from "../conversations/event-log.js";
 import { ApiError } from "../errors.js";
-import { withJobContext } from "../log-context.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
+import { KERNEL_BUS, KERNEL_LOGGER } from "../infra/tokens.js";
 import { readOrgSettings } from "../orgs/settings.service.js";
-import { ConversationLock } from "../runtime/conversation-lock.js";
-import { bullConnection } from "../runtime/run-queue.js";
+import { ConversationLock, } from "../runtime/conversation-lock.js";
+import { ApprovalsService } from "../tools/approvals.service.js";
+import { QuestionsService } from "../tools/questions.service.js";
 import { approvalCard, cardMessage, connectUrl, conversationUrl, questionCard, webBase, } from "./cards.js";
+import { ChannelConnections } from "./connections.service.js";
+import { ChannelInbound } from "./inbound.js";
+import { ChannelJobs, INBOUND_JOB, idempotencyKey, } from "./jobs.js";
 import { phrase } from "./phrases.js";
-/** 渠道队列（出站投递与入站任务，不含 `:`），只在 worker 角色上消费。 */
-export const CHANNEL_QUEUE_NAME = "cap-kernel-channels";
-/** 投递任务名。 */
-export const DELIVER_JOB = "deliver";
-/** 投递任务 id（不含 `:`）：同一会话、同一日志位置只排一个任务。 */
-export const deliverJobId = (conversationId, seq) => `deliver-${conversationId}-${seq}`;
-/**
- * 结束后复核排的任务 id：每次唯一（带随机后缀，不含 `:`）。不能复用 `deliver-<会话>-<seq>`——同 id 的任务
- * 可能正因锁被占而即将直接结束，BullMQ 会把新任务去重进它，于是没人投递。
- */
-export const followUpJobId = (conversationId, seq) => `deliver-${conversationId}-${seq}-f${randomUUID().slice(0, 8)}`;
-/**
- * 发给插件的幂等键（Ruling A15）：把逻辑键（如 `<会话>-<seq>`）做 sha256，取 base64url 的前 32 个字符——
- * 稳定、只含 `[A-Za-z0-9_-]`，满足常见平台的长度限制。
- */
-export function idempotencyKey(raw) {
-    return createHash("sha256").update(raw).digest("base64url").slice(0, 32);
-}
+// The queue, job names, ids and priorities live with the producer (jobs.ts)
+export { CHANNEL_QUEUE_NAME, DELIVER_ATTEMPTS, DELIVER_JOB, DELIVER_PRIORITY, deliverJobId, followUpJobId, INBOUND_ATTEMPTS, INBOUND_JOB, INBOUND_PRIORITY, idempotencyKey, inboundJobId, } from "./jobs.js";
 /**
  * 投递锁被占时怎么办：读不到持有者（刚被释放）→ 再取一次；是自己上一次（已崩溃、被 stalled 重新投递）的尝试 →
  * 推迟重试等它过期；别的任务 → 直接结束（它会读到新事件，结束时还会复核）。
@@ -59,8 +61,6 @@ const LOCK_BUSY_DELAY_MS = 1000;
 const PLUGIN_PENDING_DELAY_MS = 5000;
 /** 插件一直没有在任何副本上加载：任务排进队列这么久之后放弃（之后的新事件会再排任务）。 */
 const PLUGIN_PENDING_MAX_MS = 3_600_000;
-/** 可重试失败（限流、5xx、网络、超时）的总尝试次数。 */
-export const DELIVER_ATTEMPTS = 8;
 /** 同一事件不可重试地失败这么多次后跳过它（Ruling A14）。 */
 export const POISON_FAILURES = 3;
 /** 退避：未给出建议等待时长时 `min(上限, 基数 · 2^(n-1))`。 */
@@ -70,22 +70,6 @@ const BACKOFF_MAX_MS = 60_000;
 const PAGE = 200;
 /** `last_error` 的最大长度（同渠道选主）。 */
 const MAX_ERROR_CHARS = 1000;
-/** 入站任务名。 */
-export const INBOUND_JOB = "inbound";
-/**
- * BullMQ 优先级（数字越小越先）：入站任务先于出站投递任务——投递任务可能占着并发槽等输出，
- * 用户发来的消息不能排在它们后面。
- */
-export const INBOUND_PRIORITY = 1;
-export const DELIVER_PRIORITY = 10;
-/** 入站任务的总尝试次数（处理失败由 BullMQ 指数退避重试：1s、2s、4s、8s）。 */
-export const INBOUND_ATTEMPTS = 5;
-const INBOUND_BACKOFF_MS = 1000;
-/**
- * 入站消息的任务 id（不含 `:`）：`inbound-<连接>-<sha256(消息 id) 的 base64url 前 22 位>`。同一条消息只排一个任务
- * （已完成的任务保留一段时间，期间重复入队被 BullMQ 忽略）。
- */
-export const inboundJobId = (connectionId, messageId) => `inbound-${connectionId}-${createHash("sha256").update(messageId).digest("base64url").slice(0, 22)}`;
 /** 可重试的投递失败：带已打码的说明与平台建议的等待时长，供退避策略与最后一次失败时记录。 */
 class RetryableDeliveryError extends Error {
     connectionId;
@@ -121,9 +105,8 @@ export function deliverBackoff(attemptsMade, err) {
 }
 /**
  * 渠道出站投递：把会话日志里 `channel_deliveries.last_seq` 之后的内容按序投到 IM。
- * - 生产方（任意角色）：`enqueue(conversationId)` 投递 `deliver-<会话>-<当前 seq>` 任务（会话没有投递目标时什么都不做）。
- *   内核在会话每次追加事件后都调用它（事件日志的 notify 钩子），运行开始时也调用。
- * - Worker（只在 worker 角色）：每个任务先取按会话互斥的投递锁，订阅 `conv.<id>` 后补读日志；运行进入 waiting /
+ * - 生产方（任意角色）：{@link ChannelJobs}（`deliver-<会话>-<当前 seq>` 任务；会话没有投递目标时什么都不做）。
+ * - Worker（只在 worker 角色，经 `@Processor`）：每个任务先取按会话互斥的投递锁，订阅 `conv.<id>` 后补读日志；运行进入 waiting /
  *   终态且日志读完，或追上后 `channels.deliveryIdleMs` 内没有新的总线消息，任务就结束（不长期占并发槽）。
  *   锁被别的任务持有 → 本任务直接结束：持有者会读到新事件，且它结束时（释放锁之后）复核日志是否有新内容，有就再排一个任务；
  *   锁被自己上一次（已崩溃的）尝试占着 → 推迟重试，等锁过期。
@@ -131,127 +114,82 @@ export function deliverBackoff(attemptsMade, err) {
  *   并记下 IM 消息 id（草稿 id、卡片消息 id），已投递的不会重发。
  *   审批 / 提问卡片在发送之前先记一行 `pending`（T5a），卡片一出现就被点击也能通过 Ruling A13 的核对；
  *   推进 `last_seq` 的事务再补上消息 id、改为 `sent`。崩溃后续投的副本用同一个幂等键重发。
- * 同一队列还承载入站任务（`inbound`，Ruling A21）：由 `enqueueInbound` 排入，worker 调用 `deps.inbound` 处理，
- * 失败按 BullMQ 指数退避重试。
+ * 同一队列还承载入站任务（`inbound`，Ruling A21）：由 {@link ChannelJobs.enqueueInbound} 排入，worker 调用
+ * {@link ChannelInbound.handle} 处理，失败按 BullMQ 指数退避重试。
  * 状态全部在 PG / Redis；进程内只有本任务自己的订阅、草稿节流时刻与等待定时器（本进程持有的资源）。
  */
-export class ChannelOutbound {
-    d;
-    queue;
-    queueConn;
+let ChannelOutbound = class ChannelOutbound {
+    kdb;
+    inbound;
+    jobs;
+    config;
+    log;
+    txHost;
     worker;
-    workerConn;
     closed = false;
     /** 停机：进行中的任务在下一个检查点交还队列（由其他副本续投）。 */
     stopping = new AbortController();
     lock;
-    constructor(d) {
-        this.d = d;
-        this.lock = new ConversationLock(d.redis, d.log, DELIVER_LOCK_PREFIX);
-    }
-    /** 会话有 IM 投递目标时投递一个出站任务（同一日志位置重复调用只排一个）；已关闭时什么都不做。 */
-    async enqueue(conversationId, opts = {}) {
-        if (this.closed)
-            return;
-        const row = await this.d.db
-            .selectFrom("channel_deliveries")
-            .innerJoin("conversations", "conversations.id", "channel_deliveries.conversation_id")
-            .select("conversations.last_seq")
-            .where("channel_deliveries.conversation_id", "=", conversationId)
-            .executeTakeFirst();
-        if (!row || this.closed)
-            return;
-        await this.getQueue().add(DELIVER_JOB, { conversationId }, {
-            jobId: opts.followUp
-                ? followUpJobId(conversationId, Number(row.last_seq))
-                : deliverJobId(conversationId, Number(row.last_seq)),
-            attempts: DELIVER_ATTEMPTS,
-            backoff: { type: "deliver" },
-            priority: DELIVER_PRIORITY,
-            removeOnComplete: true,
-            removeOnFail: true,
-        });
+    d;
+    constructor(kdb, bus, eventLog, 
+    /** The conversation lock provider; delivery takes it under its own key prefix. */
+    lock, connections, approvals, questions, 
+    /** 入站任务的处理（worker 上执行 `ChannelInbound.handle`）；失败抛错由 BullMQ 重试。 */
+    inbound, jobs, config, log, txHost) {
+        this.kdb = kdb;
+        this.inbound = inbound;
+        this.jobs = jobs;
+        this.config = config;
+        this.log = log;
+        this.txHost = txHost;
+        this.lock = lock.scoped(DELIVER_LOCK_PREFIX);
+        this.d = {
+            get db() {
+                return kdb.db;
+            },
+            bus,
+            eventLog,
+            connections,
+            approvals,
+            questions,
+            config,
+            log,
+            writes: this,
+        };
     }
     /**
-     * 排一个入站任务（Ruling A21，同一队列 `cap-kernel-channels`）：处理失败按 {@link INBOUND_ATTEMPTS} 次指数退避重试。
-     * 已关闭时抛错（调用方据此让插件不确认、由平台重投）。
+     * Starts consuming (worker role only): `worker` is the `@Processor` worker of the channel queue
+     * (its job lock and stalled detection follow the run queue's config).
      */
-    async enqueueInbound(connectionId, event, jobId) {
-        await this.getQueue().add(INBOUND_JOB, { connectionId, event }, {
-            jobId,
-            attempts: INBOUND_ATTEMPTS,
-            priority: INBOUND_PRIORITY,
-            backoff: { type: "exponential", delay: INBOUND_BACKOFF_MS },
-            removeOnComplete: { age: 3600, count: 1000 },
-            removeOnFail: { age: 86_400 },
-        });
+    startWorker(worker) {
+        if (this.worker || this.closed)
+            return;
+        this.worker = worker;
+        void worker.run().catch((err) => this.onError(err));
     }
-    /**
-     * 连接重新可投递（轮换了凭据 / 重新启用）：给该连接投递进度落后于会话日志的会话各排一个出站任务，
-     * 补投停用或凭据失效期间落下的内容（不必等下一条消息）。
-     */
-    async resumeConnection(connectionId) {
-        const rows = await this.d.db
-            .selectFrom("channel_deliveries")
-            .innerJoin("conversations", "conversations.id", "channel_deliveries.conversation_id")
-            .select("channel_deliveries.conversation_id")
-            .where("channel_deliveries.connection_id", "=", connectionId)
-            .whereRef("channel_deliveries.last_seq", "<", "conversations.last_seq")
-            .execute();
-        for (const r of rows)
-            await this.enqueue(r.conversation_id, { followUp: true });
+    /** The worker's `error` event. */
+    onError(err) {
+        this.log.error("channel outbound worker error", { err });
     }
-    /** 启动 Worker（只在含 `worker` 角色的进程）。任务锁与 stalled 检测沿用运行队列的配置。 */
-    startWorker() {
-        if (this.worker || this.closed)
+    /** The worker's `failed` event (a requeue for later is not a failure). */
+    onFailed(job, err) {
+        if (err instanceof DelayedError || err.name === "DelayedError")
             return;
-        const { jobLockMs, stalledIntervalMs } = this.d.config().runtime;
-        this.workerConn = bullConnection(this.d.redisUrl, this.d.log);
-        this.worker = new Worker(CHANNEL_QUEUE_NAME, (job, token) => withJobContext(CHANNEL_QUEUE_NAME, job, () => this.process(job, token)), {
-            connection: this.workerConn,
-            concurrency: this.d.config().channels.deliveryConcurrency,
-            lockDuration: jobLockMs,
-            stalledInterval: stalledIntervalMs,
-            maxStalledCount: 3,
-            settings: { backoffStrategy: (n, _type, err) => deliverBackoff(n, err) },
-        });
-        this.worker.on("error", (err) => this.d.log.error("channel outbound worker error", { err }));
-        this.worker.on("failed", (job, err) => {
-            if (err instanceof DelayedError || err.name === "DelayedError")
-                return;
-            this.d.log.warn("channel delivery attempt failed", { jobId: job?.id, error: err.message });
-        });
+        this.log.warn("channel delivery attempt failed", { jobId: job?.id, error: err.message });
     }
+    /** Stops: the jobs in flight are handed back at their next checkpoint, the worker closes. */
     async close() {
         this.closed = true;
         this.stopping.abort();
         const w = this.worker;
-        const q = this.queue;
         this.worker = undefined;
-        this.queue = undefined;
         await w?.close().catch(() => { });
-        await q?.close().catch(() => { });
-        for (const c of [this.workerConn, this.queueConn]) {
-            if (c)
-                await c.quit().catch(() => c.disconnect());
-        }
-        this.workerConn = undefined;
-        this.queueConn = undefined;
-    }
-    getQueue() {
-        if (this.closed)
-            throw new Error("channel outbound queue is closed");
-        if (!this.queue) {
-            this.queueConn = bullConnection(this.d.redisUrl, this.d.log);
-            this.queue = new Queue(CHANNEL_QUEUE_NAME, { connection: this.queueConn });
-            this.queue.on("error", (err) => this.d.log.error("channel outbound queue error", { err }));
-        }
-        return this.queue;
     }
     async requeue(job, token, delayMs) {
         await job.moveToDelayed(Date.now() + delayMs, token);
         throw new DelayedError();
     }
+    /** One job of the channel queue (the `@Processor` calls it): a delivery or an inbound event. */
     async process(job, token) {
         if (this.stopping.signal.aborted)
             return this.requeue(job, token, 0);
@@ -262,7 +200,7 @@ export class ChannelOutbound {
     /** 本副本没有加载连接的插件：推迟重试（不消耗重试次数），排队超过上限才放弃。 */
     async pluginPending(job, token, what) {
         if (Date.now() - job.timestamp > PLUGIN_PENDING_MAX_MS) {
-            this.d.log.warn(`channel ${what} dropped: extension not loaded on any replica in time`, {
+            this.log.warn(`channel ${what} dropped: extension not loaded on any replica in time`, {
                 jobId: job.id,
             });
             return;
@@ -275,10 +213,8 @@ export class ChannelOutbound {
      */
     async processInbound(job, token) {
         const { connectionId, event } = job.data;
-        if (!this.d.inbound)
-            throw new Error("channel inbound handler is not configured");
         try {
-            await this.d.inbound(connectionId, event);
+            await this.inbound.handle(connectionId, event);
         }
         catch (err) {
             if (err instanceof ApiError && err.code === "extension.not_found") {
@@ -287,7 +223,7 @@ export class ChannelOutbound {
             if (isChannelSendError(err) &&
                 !err.retryable &&
                 (err.reason === "auth" || err.reason === "target_gone")) {
-                this.d.log.warn("channel inbound reply failed permanently", {
+                this.log.warn("channel inbound reply failed permanently", {
                     connectionId,
                     type: event.type,
                     reason: err.reason,
@@ -295,7 +231,7 @@ export class ChannelOutbound {
                 throw new UnrecoverableError(`inbound reply failed: ${err.reason}`);
             }
             if (job.attemptsMade + 1 >= (job.opts.attempts ?? 1)) {
-                this.d.log.error("channel inbound event dropped after retries", {
+                this.log.error("channel inbound event dropped after retries", {
                     connectionId,
                     type: event.type,
                     err,
@@ -307,7 +243,7 @@ export class ChannelOutbound {
     async deliver(job, token) {
         const { conversationId } = job.data;
         const owner = `${job.id ?? "job"}.`;
-        const acquire = () => this.lock.acquire(conversationId, `${owner}${randomUUID()}`, this.d.config().runtime.jobLockMs);
+        const acquire = () => this.lock.acquire(conversationId, `${owner}${randomUUID()}`, this.config.get().runtime.jobLockMs);
         let lease = await acquire();
         if (!lease) {
             const action = busyLockAction(await this.lock.holder(conversationId), owner);
@@ -337,7 +273,7 @@ export class ChannelOutbound {
         finally {
             await lease
                 .release()
-                .catch((err) => this.d.log.warn("cannot release channel delivery lock", { conversationId, err }));
+                .catch((err) => this.log.warn("cannot release channel delivery lock", { conversationId, err }));
         }
         if (outcome.error)
             await this.recordError(outcome.error.connectionId, outcome.error.message);
@@ -360,7 +296,7 @@ export class ChannelOutbound {
                 return;
             case "changed":
                 // 连接改过（轮换凭据等）：释放锁之后排新任务，用新的出站会话从 last_seq 接着投
-                await this.enqueue(conversationId, { followUp: true });
+                await this.jobs.enqueue(conversationId, { followUp: true });
                 return;
             case "pending":
                 return this.pluginPending(job, token, "delivery");
@@ -368,7 +304,7 @@ export class ChannelOutbound {
     }
     /** 会话日志当前的最后位置（会话不存在时 undefined）。 */
     async lastSeq(conversationId) {
-        const conv = await this.d.db
+        const conv = await this.kdb
             .selectFrom("conversations")
             .select("last_seq")
             .where("id", "=", conversationId)
@@ -379,20 +315,81 @@ export class ChannelOutbound {
     async followUp(conversationId, seen) {
         const last = await this.lastSeq(conversationId);
         if (last !== undefined && last > seen)
-            await this.enqueue(conversationId, { followUp: true });
+            await this.jobs.enqueue(conversationId, { followUp: true });
     }
     /** 不可重试（或重试用尽）的发送失败：记连接 `last_error`（已打码）。 */
     async recordError(connectionId, message) {
         const text = `delivery failed: ${message}`.slice(0, MAX_ERROR_CHARS);
-        this.d.log.warn("channel delivery failed", { connectionId, error: text });
-        await this.d.db
+        this.log.warn("channel delivery failed", { connectionId, error: text });
+        await this.kdb
             .updateTable("channel_connections")
             .set({ last_error: text })
             .where("id", "=", connectionId)
             .execute()
-            .catch((err) => this.d.log.warn("cannot record channel delivery error", { err }));
+            .catch((err) => this.log.warn("cannot record channel delivery error", { err }));
     }
-}
+    /**
+     * 推进 `last_seq`（同一事务记下草稿 / 卡片消息 id，清零失败计数）。以「仍是 `persisted`」为条件：
+     * 被别人推进过（投递锁丢失后另一实例接手）返回 false，什么都不写。
+     */
+    async advanceIn(a) {
+        const r = await this.kdb
+            .updateTable("channel_deliveries")
+            .set({
+            last_seq: String(a.seq),
+            fail_seq: null,
+            fail_count: 0,
+            ...(a.draft !== undefined && { draft_message_id: a.draft }),
+            updated_at: new Date(),
+        })
+            .where("conversation_id", "=", a.conversationId)
+            .where("last_seq", "=", String(a.persisted))
+            .executeTakeFirst();
+        if (r.numUpdatedRows === 0n)
+            return false;
+        if (a.card) {
+            // The row was recorded as `pending` before the send (recordCard); fill in the message id
+            const { messageId, target } = a.card;
+            await this.kdb
+                .insertInto("channel_card_messages")
+                .values({
+                conversation_id: a.conversationId,
+                connection_id: a.card.connectionId,
+                card_kind: a.card.kind,
+                card_id: a.card.id,
+                message_id: messageId,
+                status: "sent",
+                target: JSON.stringify(target),
+            })
+                .onConflict((oc) => oc.columns(["conversation_id", "connection_id", "card_kind", "card_id"]).doUpdateSet({
+                message_id: messageId,
+                status: "sent",
+                target: JSON.stringify(target),
+            }))
+                .execute();
+        }
+        return true;
+    }
+};
+__decorate([
+    Transactional()
+], ChannelOutbound.prototype, "advanceIn", null);
+ChannelOutbound = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(KERNEL_BUS)),
+    __param(2, Inject(EventLog)),
+    __param(3, Inject(ConversationLock)),
+    __param(4, Inject(ChannelConnections)),
+    __param(5, Inject(ApprovalsService)),
+    __param(6, Inject(QuestionsService)),
+    __param(7, Inject(ChannelInbound)),
+    __param(8, Inject(ChannelJobs)),
+    __param(9, Inject(KernelConfigService)),
+    __param(10, Inject(KERNEL_LOGGER)),
+    __param(11, Inject(TransactionHost))
+], ChannelOutbound);
+export { ChannelOutbound };
 /** 一次投递任务（本进程持有）：订阅、补读、草稿节流。 */
 class Delivery {
     d;
@@ -482,7 +479,7 @@ class Delivery {
             this.persisted = this.seen;
             this.draftId = row.draft_message_id;
             this.locale = (await readOrgSettings(this.d.db, this.s.row.orgId)).locale;
-            this.base = webBase(this.d.config().http.publicUrl);
+            this.base = webBase(this.d.config.get().http.publicUrl);
             return await this.loop();
         }
         catch (err) {
@@ -586,7 +583,7 @@ class Delivery {
         return undefined;
     }
     async loop() {
-        const idleMs = this.d.config().channels.deliveryIdleMs;
+        const idleMs = this.d.config.get().channels.deliveryIdleMs;
         let lastMessageAt = Date.now();
         let needCatchUp = true;
         this.checkedAt = Date.now();
@@ -690,43 +687,17 @@ class Delivery {
      * 被别人推进过（投递锁丢失后另一实例接手）就停止，不再重复发送。
      */
     async advance(seq, opts = {}) {
-        await this.d.db.transaction().execute(async (t) => {
-            const r = await t
-                .updateTable("channel_deliveries")
-                .set({
-                last_seq: String(seq),
-                fail_seq: null,
-                fail_count: 0,
-                ...(opts.draft !== undefined && { draft_message_id: opts.draft }),
-                updated_at: new Date(),
-            })
-                .where("conversation_id", "=", this.conversationId)
-                .where("last_seq", "=", String(this.persisted))
-                .executeTakeFirst();
-            if (r.numUpdatedRows === 0n)
-                throw new DeliveryLostError();
-            if (opts.card) {
-                // The row was recorded as `pending` before the send (recordCard); fill in the message id
-                const messageId = opts.card.messageId;
-                await t
-                    .insertInto("channel_card_messages")
-                    .values({
-                    conversation_id: this.conversationId,
-                    connection_id: this.s.row.id,
-                    card_kind: opts.card.kind,
-                    card_id: opts.card.id,
-                    message_id: messageId,
-                    status: "sent",
-                    target: JSON.stringify(this.target),
-                })
-                    .onConflict((oc) => oc.columns(["conversation_id", "connection_id", "card_kind", "card_id"]).doUpdateSet({
-                    message_id: messageId,
-                    status: "sent",
-                    target: JSON.stringify(this.target),
-                }))
-                    .execute();
-            }
+        const advanced = await this.d.writes.advanceIn({
+            conversationId: this.conversationId,
+            persisted: this.persisted,
+            seq,
+            ...(opts.draft !== undefined && { draft: opts.draft }),
+            ...(opts.card && {
+                card: { ...opts.card, connectionId: this.s.row.id, target: this.target },
+            }),
         });
+        if (!advanced)
+            throw new DeliveryLostError();
         this.persisted = seq;
         if (opts.draft !== undefined) {
             this.draftId = opts.draft;