@rei-standard/amsg-server 2.6.0-next.13 → 2.6.0-next.15

package/dist/adapters/d1.d.ts

@@ -38,6 +38,19 @@ export class D1Adapter {
     }>;
     dropSchema(): Promise<void>;
     createTask(params: any): Promise<any>;
+    /**
+     * 建新任务的同时取消旧的那条（`POST /schedule-message` 的 supersedesUuid）。
+     *
+     * 两条语句走一次 batch（D1 的隐式事务 + 单次网络往返）：不会出现「旧的删了、
+     * 新的没建成」的中间态——INSERT 撞 uuid 唯一索引时整个 batch 回滚，旧行原样
+     * 留着，调用方按既有的 409 冲突路径处理。
+     *
+     * @param {import('./interface.js').InsertTaskParams} params
+     * @param {string} supersedesUuid - 要取消的旧任务 uuid（同一 user_id 下）
+     * @returns {Promise<Object>} createTask 的返回行 + `superseded`（旧行是否
+     *   真的被删掉；false = 旧行本就不存在）
+     */
+    createTaskSuperseding(params: import("./interface.js").InsertTaskParams, supersedesUuid: string): Promise<any>;
     getTaskByUuid(uuid: any, userId: any): Promise<any>;
     getTaskByUuidOnly(uuid: any): Promise<any>;
     updateTaskById(taskId: any, updates: any): Promise<any>;
@@ -83,12 +96,34 @@ export class D1Adapter {
      *   有任务正在跑、排期被改过、或行已不是 pending
      */
     claimTask(taskId: number, expectedNextSendAt: string, leaseUntil: string | Date, serializeGroup?: string | null): Promise<boolean>;
+    /**
+     * 投递期间的租约续期（run-tick 的心跳用）。只在行仍是 pending 且确实持有
+     * 租约（lease_until 非空）时生效——收尾把租约放掉之后，迟到的心跳不会把
+     * 租约复活。
+     *
+     * @param {number} taskId
+     * @param {string|Date} leaseUntil - 新的租期末尾
+     * @returns {Promise<boolean>} true = 续上了
+     */
+    renewTaskLease(taskId: number, leaseUntil: string | Date): Promise<boolean>;
     listTasks(userId: any, opts?: {}): Promise<{
         tasks: any;
         total: number;
     }>;
     cleanupOldTasks(days?: number): Promise<any>;
     getTaskStatus(uuid: any, userId: any): Promise<any>;
+    /**
+     * 状态 + 失败摘要（GET /message 用它把「为什么失败」透给已失败的行——那些
+     * 行 getTaskByUuid 读不到，payload 里的 lastError 也就够不着了）。
+     *
+     * @param {string} uuid
+     * @param {string} userId
+     * @returns {Promise<{ status: string, last_error: string|null }|null>}
+     */
+    getTaskStatusInfo(uuid: string, userId: string): Promise<{
+        status: string;
+        last_error: string | null;
+    } | null>;
     /**
      * Batch upsert. Last-write-wins per (namespace, key): an entry older
      * than the stored row (updatedAt strictly lower) is skipped; equal or
@@ -178,4 +213,75 @@ export class D1Adapter {
      * @returns {Promise<boolean>} true = 确实删掉了一行
      */
     deletePushSubscription(userId: string): Promise<boolean>;
+    /**
+     * 发送前把这一批 push 落进 outbox（一次 batch）。(user_id, message_id)
+     * 唯一：重试同一 occurrence 带着同一批 messageId 再来时更新 payload、不加
+     * 第二行；客户端已经 ack 过的行不动（ack 是终态，重试不该把它拉回未读）。
+     *
+     * @param {string} userId
+     * @param {Array<{ message_id: string, task_uuid?: string|null, session_id?: string|null,
+     *   message_index?: number|null, total_messages?: number|null, payload: string, created_at: number }>} rows
+     *   `payload` 是整条 push JSON 的 encryptForStorage 密文。
+     * @returns {Promise<number>} 实际写入/更新的行数
+     */
+    appendOutboxMessages(userId: string, rows: Array<{
+        message_id: string;
+        task_uuid?: string | null;
+        session_id?: string | null;
+        message_index?: number | null;
+        total_messages?: number | null;
+        payload: string;
+        created_at: number;
+    }>): Promise<number>;
+    /**
+     * 把这一批标记为「Web Push 已发出」。发送失败的段不标——delivered_at 为
+     * null 的行正是客户端最需要拉的那部分。
+     *
+     * @param {string} userId
+     * @param {string[]} messageIds
+     * @param {number} deliveredAt - epoch 毫秒
+     * @returns {Promise<number>}
+     */
+    markOutboxDelivered(userId: string, messageIds: string[], deliveredAt: number): Promise<number>;
+    /**
+     * 未 ack 的行（id 升序，游标翻页）。payload 仍是密文，解密在 handler。
+     *
+     * @param {string} userId
+     * @param {number} sinceId - 上一页游标（0 = 从头）
+     * @param {number} limit
+     * @returns {Promise<Array<{ id: number, message_id: string, task_uuid: string|null,
+     *   session_id: string|null, message_index: number|null, total_messages: number|null,
+     *   payload: string, created_at: number, delivered_at: number|null }>>}
+     */
+    listUnackedOutbox(userId: string, sinceId?: number, limit?: number): Promise<Array<{
+        id: number;
+        message_id: string;
+        task_uuid: string | null;
+        session_id: string | null;
+        message_index: number | null;
+        total_messages: number | null;
+        payload: string;
+        created_at: number;
+        delivered_at: number | null;
+    }>>;
+    /**
+     * 客户端确认收到这一批（幂等：已 ack 的行再 ack 不动）。
+     *
+     * @param {string} userId
+     * @param {string[]} messageIds
+     * @param {number} ackedAt - epoch 毫秒
+     * @returns {Promise<number>} 本次真正被 ack 的行数
+     */
+    ackOutboxMessages(userId: string, messageIds: string[], ackedAt: number): Promise<number>;
+    /**
+     * outbox 的例行清理（run-tick 每跳顺手调）：已 ack 的行留短一些，未 ack 的
+     * 也不无限留（Web Push TTL 上限四周，比它更老的推送谁也收不到了）。
+     *
+     * @param {{ ackedBeforeMs?: number, allBeforeMs?: number }} opts - epoch 毫秒阈值
+     * @returns {Promise<number>} 删掉的行数
+     */
+    cleanupOutbox({ ackedBeforeMs, allBeforeMs }?: {
+        ackedBeforeMs?: number;
+        allBeforeMs?: number;
+    }): Promise<number>;
 }

package/dist/adapters/interface.d.ts

@@ -162,4 +162,54 @@ export type DbAdapter = {
      * （建了也永远发不出去）。内置的 D1 / pg / neon 适配器都实现了。
      */
     deletePushSubscription?: (userId: string) => Promise<boolean>;
+    /**
+     * （可选）投递期间的租约续期（runScheduledTick 的心跳）。只在行仍是
+     * pending 且 lease_until 非空时生效——收尾放掉租约之后，迟到的心跳不会把
+     * 它复活。不实现 → 心跳自动关闭，退回一次性长租约（claimLeaseMs）。
+     */
+    renewTaskLease?: (taskId: number, leaseUntil: string | Date) => Promise<boolean>;
+    /**
+     * （可选）状态 + last_error 列（脱敏失败摘要的 JSON 串）。GET /message 用
+     * 它把「为什么失败」透给已失败的行；不实现时退回 getTaskStatus（409 里就
+     * 没有 lastError）。
+     */
+    getTaskStatusInfo?: (uuid: string, userId: string) => Promise<{
+        status: string;
+        last_error: string | null;
+    } | null>;
+    /**
+     * （可选）建新任务的同一事务里取消旧的那条（POST /schedule-message 的
+     * supersedesUuid）。不实现时 handler 退回「先删再建」两步（失去原子性）。
+     */
+    createTaskSuperseding?: (params: InsertTaskParams, supersedesUuid: string) => Promise<TaskRow & {
+        superseded: boolean;
+    }>;
+    /**
+     * （可选；单用户/D1）push 发送前把整批落进 message_outbox（密文 payload），
+     * (user_id, message_id) 冲突时更新未 ack 的行、不动已 ack 的。
+     */
+    appendOutboxMessages?: (userId: string, rows: Array<any>) => Promise<number>;
+    /**
+     * （可选；单用户/D1）把发出去的段标 delivered_at。
+     */
+    markOutboxDelivered?: (userId: string, messageIds: string[], deliveredAt: number) => Promise<number>;
+    /**
+     * （可选；单用户/D1）未 ack 的行，id 升序游标翻页（GET /outbox）。
+     */
+    listUnackedOutbox?: (userId: string, sinceId: number, limit: number) => Promise<Array<any>>;
+    /**
+     * （可选；单用户/D1）客户端确认收到（POST /outbox/ack，幂等）。
+     */
+    ackOutboxMessages?: (userId: string, messageIds: string[], ackedAt: number) => Promise<number>;
+    /**
+     * （可选；单用户/D1）outbox 例行清理（runScheduledTick 每跳顺手调）。
+     *
+     * outbox 五个方法要么都实现、要么都不实现：缺写入侧的（append / mark），
+     * 发送链路静默跳过落行；缺读取侧的（list / ack），`GET /outbox` 与
+     * `POST /outbox/ack` 返回 501。内置只有 D1 实现（与 client_state 同待遇）。
+     */
+    cleanupOutbox?: (opts: {
+        ackedBeforeMs?: number;
+        allBeforeMs?: number;
+    }) => Promise<number>;
 };

package/dist/adapters/neon.d.ts

@@ -40,70 +40,22 @@ export class NeonAdapter {
     deleteTaskById(taskId: any): Promise<boolean>;
     deleteTaskByUuid(uuid: any, userId: any): Promise<boolean>;
     getPendingTasks(limit?: number): Promise<Record<string, any>[]>;
-    /**
-     * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
-     * 本次投递期间别的 tick 领不走它。
-     *
-     * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
-     * 任务列表要读它、循环任务推进下一次也要拿它当基准。
-     *
-     * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
-     * 过。WHERE 里的两个条件各管一件事：
-     *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
-     *     也不会把行焊死，租约到期后自然可以被接手。
-     *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
-     *     这一跳就不该再按旧时刻发。
-     *
-     * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
-     * 要改表。
-     *
-     * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
-     * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
-     *
-     * 带 serializeGroup 时多一道分组门：同一分组里已经有别的行拿着未到期的租
-     * 约，这条就领不走（同一分组同时只跑一条）。判定和写租约在同一条 UPDATE
-     * 里完成，「先查再占」的空档天然不存在。分组门只看租约，不看
-     * `retry_after`：等着重试的任务其实闲着，不该把同分组的其他任务一起堵住。
-     *
-     * @param {number} taskId
-     * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
-     * @param {string|Date} leaseUntil - 租期末尾
-     * @param {string|null} [serializeGroup] - 串行分组标识；空表示不参与分组串行
-     * @returns {Promise<boolean>} true = 领到了；false = 别人正拿着租约、同分组
-     *   有任务正在跑、排期被改过、或行已不是 pending
-     */
-    claimTask(taskId: number, expectedNextSendAt: string | Date, leaseUntil: string | Date, serializeGroup?: string | null): Promise<boolean>;
+    claimTask(taskId: any, expectedNextSendAt: any, leaseUntil: any, serializeGroup?: any): Promise<boolean>;
+    renewTaskLease(taskId: any, leaseUntil: any): Promise<boolean>;
     listTasks(userId: any, opts?: {}): Promise<{
         tasks: Record<string, any>[];
         total: number;
     }>;
     cleanupOldTasks(days?: number): Promise<number>;
     getTaskStatus(uuid: any, userId: any): Promise<any>;
-    /**
-     * 这个用户当前登记的推送订阅（密文原样返回，解密在上层）。
-     *
-     * @param {string} userId
-     * @returns {Promise<{ subscription: string, updated_at: number }|null>}
-     */
-    getPushSubscription(userId: string): Promise<{
+    getTaskStatusInfo(uuid: any, userId: any): Promise<{
+        status: string;
+        last_error: string | null;
+    }>;
+    getPushSubscription(userId: any): Promise<{
         subscription: string;
         updated_at: number;
-    } | null>;
-    /**
-     * 覆盖写这个用户的订阅。一个用户一行，没有 last-write-wins 之类的比较——
-     * 客户端拿到的新订阅永远比旧的有效，旧的那份只会 410。
-     *
-     * @param {string} userId
-     * @param {string} encryptedSubscription
-     * @param {number} updatedAt - epoch 毫秒
-     * @returns {Promise<boolean>}
-     */
-    upsertPushSubscription(userId: string, encryptedSubscription: string, updatedAt: number): Promise<boolean>;
-    /**
-     * 删掉这个用户的订阅（设置页「停止接收推送」）。
-     *
-     * @param {string} userId
-     * @returns {Promise<boolean>} true = 确实删掉了一行
-     */
-    deletePushSubscription(userId: string): Promise<boolean>;
+    }>;
+    upsertPushSubscription(userId: any, encryptedSubscription: any, updatedAt: any): Promise<boolean>;
+    deletePushSubscription(userId: any): Promise<boolean>;
 }

package/dist/adapters/pg-shared.d.ts

@@ -0,0 +1,114 @@
+/**
+ * pg / neon 共用的 Postgres 查询实现。
+ *
+ * 两个适配器只在「怎么把 SQL 发出去」上不同（pg 的连接池 vs neon 的 HTTP
+ * 驱动），SQL 与并发语义必须逐字一致——各自复制一份的话，修一边漏一边就会让
+ * 两种 Postgres 部署的串行化行为静默分歧，而各自的测试还都是绿的。所以这里
+ * 按执行器参数化：适配器只递一个 `query(text, params) → rows`。
+ *
+ * D1（SQLite 方言、单写者、ISO TEXT 时间戳）不走这份实现。
+ *
+ * @typedef {(text: string, params?: any[]) => Promise<any[]>} PgQuery
+ */
+/**
+ * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
+ * 本次投递期间别的 tick 领不走它。
+ *
+ * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
+ * 任务列表要读它、循环任务推进下一次也要拿它当基准。
+ *
+ * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
+ * 过。WHERE 里的两个条件各管一件事：
+ *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
+ *     也不会把行焊死，租约到期后自然可以被接手。
+ *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
+ *     这一跳就不该再按旧时刻发。
+ *
+ * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
+ * 要改表。
+ *
+ * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
+ * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
+ *
+ * 带 serializeGroup 时多一道分组门：同一分组里已经有别的行拿着未到期的租
+ * 约，这条就领不走（同一分组同时只跑一条）。判定和写租约在同一条 UPDATE
+ * 里完成——但那只对「抢同一行」成立；READ COMMITTED 下两个并发 tick 各领
+ * 同组的**不同**行时，各自的 NOT EXISTS 子查询都看不到对方尚未提交的租约，
+ * 也没有行锁冲突逼它重查（写偏斜）。所以占位成功后再回头查一次：真撞上了
+ * 就把自己刚写的租约放掉、这一跳不跑——两边都让也没事，行保持 pending，
+ * 下一跳重试。分组门只看租约，不看 `retry_after`：等着重试的任务其实闲着，
+ * 不该把同分组的其他任务一起堵住。
+ *
+ * @param {PgQuery} query
+ * @param {number} taskId
+ * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
+ * @param {string|Date} leaseUntil - 租期末尾
+ * @param {string|null} [serializeGroup] - 串行分组标识；空表示不参与分组串行
+ * @returns {Promise<boolean>} true = 领到了；false = 已被别人领走、同分组有
+ *   任务正在跑、排期被改过、或行已不是 pending
+ */
+export function claimTask(query: PgQuery, taskId: number, expectedNextSendAt: string | Date, leaseUntil: string | Date, serializeGroup?: string | null): Promise<boolean>;
+/**
+ * 投递期间的租约续期（run-tick 的心跳用）。只在行仍是 pending 且确实持有
+ * 租约（lease_until 非空）时生效——收尾把租约放掉之后，迟到的心跳不会把
+ * 租约复活。
+ *
+ * @param {PgQuery} query
+ * @param {number} taskId
+ * @param {string|Date} leaseUntil - 新的租期末尾
+ * @returns {Promise<boolean>} true = 续上了
+ */
+export function renewTaskLease(query: PgQuery, taskId: number, leaseUntil: string | Date): Promise<boolean>;
+/**
+ * 状态 + 失败摘要（GET /message 用它把「为什么失败」透给已失败的行）。
+ *
+ * @param {PgQuery} query
+ * @param {string} uuid
+ * @param {string} userId
+ * @returns {Promise<{ status: string, last_error: string|null }|null>}
+ */
+export function getTaskStatusInfo(query: PgQuery, uuid: string, userId: string): Promise<{
+    status: string;
+    last_error: string | null;
+} | null>;
+/**
+ * 这个用户当前登记的推送订阅（密文原样返回，解密在上层）。
+ *
+ * @param {PgQuery} query
+ * @param {string} userId
+ * @returns {Promise<{ subscription: string, updated_at: number }|null>}
+ */
+export function getPushSubscription(query: PgQuery, userId: string): Promise<{
+    subscription: string;
+    updated_at: number;
+} | null>;
+/**
+ * 覆盖写这个用户的订阅。一个用户一行，没有 last-write-wins 之类的比较——
+ * 客户端拿到的新订阅永远比旧的有效，旧的那份只会 410。
+ *
+ * @param {PgQuery} query
+ * @param {string} userId
+ * @param {string} encryptedSubscription
+ * @param {number} updatedAt - epoch 毫秒
+ * @returns {Promise<boolean>}
+ */
+export function upsertPushSubscription(query: PgQuery, userId: string, encryptedSubscription: string, updatedAt: number): Promise<boolean>;
+/**
+ * 删掉这个用户的订阅（设置页「停止接收推送」）。
+ *
+ * @param {PgQuery} query
+ * @param {string} userId
+ * @returns {Promise<boolean>} true = 确实删掉了一行
+ */
+export function deletePushSubscription(query: PgQuery, userId: string): Promise<boolean>;
+/**
+ * pg / neon 共用的 Postgres 查询实现。
+ *
+ * 两个适配器只在「怎么把 SQL 发出去」上不同（pg 的连接池 vs neon 的 HTTP
+ * 驱动），SQL 与并发语义必须逐字一致——各自复制一份的话，修一边漏一边就会让
+ * 两种 Postgres 部署的串行化行为静默分歧，而各自的测试还都是绿的。所以这里
+ * 按执行器参数化：适配器只递一个 `query(text, params) → rows`。
+ *
+ * D1（SQLite 方言、单写者、ISO TEXT 时间戳）不走这份实现。
+ */
+export type PgQuery = (text: string, params?: any[]) => Promise<any[]>;

package/dist/adapters/pg.d.ts

@@ -42,70 +42,22 @@ export class PgAdapter {
     deleteTaskById(taskId: any): Promise<boolean>;
     deleteTaskByUuid(uuid: any, userId: any): Promise<boolean>;
     getPendingTasks(limit?: number): Promise<any[][]>;
-    /**
-     * 领取一条到点的任务：在 lease_until 上写下「这条归我管到什么时候」，
-     * 本次投递期间别的 tick 领不走它。
-     *
-     * 租约写在自己的列上，next_send_at 全程不动——那一列是用户设的触发时刻，
-     * 任务列表要读它、循环任务推进下一次也要拿它当基准。
-     *
-     * 两个 tick 抢同一行时只有一个改得动，另一个拿不到 RETURNING 行，据此跳
-     * 过。WHERE 里的两个条件各管一件事：
-     *   - lease_until 为空或已过期：没人正在跑这条。领了任务的 tick 中途没了
-     *     也不会把行焊死，租约到期后自然可以被接手。
-     *   - next_send_at 等于读这行时看到的值：读出来之后用户又改了排期的话，
-     *     这一跳就不该再按旧时刻发。
-     *
-     * 不加一个 'sending' 状态来表达「正在跑」：status 上有 CHECK 约束，加值
-     * 要改表。
-     *
-     * 比 next_send_at 时两边都截到毫秒：列是 timestamptz（微秒精度），驱动读
-     * 出来是 JS Date（毫秒精度），原值送回去可能因为亚毫秒差对不上。
-     *
-     * 带 serializeGroup 时多一道分组门：同一分组里已经有别的行拿着未到期的租
-     * 约，这条就领不走（同一分组同时只跑一条）。判定和写租约在同一条 UPDATE
-     * 里完成，「先查再占」的空档天然不存在。分组门只看租约，不看
-     * `retry_after`：等着重试的任务其实闲着，不该把同分组的其他任务一起堵住。
-     *
-     * @param {number} taskId
-     * @param {string|Date} expectedNextSendAt - 读这行时拿到的 next_send_at 原值
-     * @param {string|Date} leaseUntil - 租期末尾
-     * @param {string|null} [serializeGroup] - 串行分组标识；空表示不参与分组串行
-     * @returns {Promise<boolean>} true = 领到了；false = 已被别人领走、同分组有
-     *   任务正在跑、或行已不是 pending
-     */
-    claimTask(taskId: number, expectedNextSendAt: string | Date, leaseUntil: string | Date, serializeGroup?: string | null): Promise<boolean>;
+    claimTask(taskId: any, expectedNextSendAt: any, leaseUntil: any, serializeGroup?: any): Promise<boolean>;
+    renewTaskLease(taskId: any, leaseUntil: any): Promise<boolean>;
     listTasks(userId: any, opts?: {}): Promise<{
         tasks: any[][];
         total: number;
     }>;
     cleanupOldTasks(days?: number): Promise<number>;
     getTaskStatus(uuid: any, userId: any): Promise<any>;
-    /**
-     * 这个用户当前登记的推送订阅（密文原样返回，解密在上层）。
-     *
-     * @param {string} userId
-     * @returns {Promise<{ subscription: string, updated_at: number }|null>}
-     */
-    getPushSubscription(userId: string): Promise<{
+    getTaskStatusInfo(uuid: any, userId: any): Promise<{
+        status: string;
+        last_error: string | null;
+    }>;
+    getPushSubscription(userId: any): Promise<{
         subscription: string;
         updated_at: number;
-    } | null>;
-    /**
-     * 覆盖写这个用户的订阅。一个用户一行，没有 last-write-wins 之类的比较——
-     * 客户端拿到的新订阅永远比旧的有效，旧的那份只会 410。
-     *
-     * @param {string} userId
-     * @param {string} encryptedSubscription
-     * @param {number} updatedAt - epoch 毫秒
-     * @returns {Promise<boolean>}
-     */
-    upsertPushSubscription(userId: string, encryptedSubscription: string, updatedAt: number): Promise<boolean>;
-    /**
-     * 删掉这个用户的订阅（设置页「停止接收推送」）。
-     *
-     * @param {string} userId
-     * @returns {Promise<boolean>} true = 确实删掉了一行
-     */
-    deletePushSubscription(userId: string): Promise<boolean>;
+    }>;
+    upsertPushSubscription(userId: any, encryptedSubscription: any, updatedAt: any): Promise<boolean>;
+    deletePushSubscription(userId: any): Promise<boolean>;
 }

package/dist/adapters/schema.d.ts

@@ -12,7 +12,7 @@
  *     派生值而不是宿主给的原始 key —— 原始 key 往往是角色 id 之类的宿主数据，
  *     任务内容都是密文落库的，这一列不该成为它的明文出口。
  */
-export const TABLE_SQL: "\n  CREATE TABLE IF NOT EXISTS scheduled_messages (\n    id SERIAL PRIMARY KEY,\n    user_id VARCHAR(255) NOT NULL,\n    uuid VARCHAR(36),\n    encrypted_payload TEXT NOT NULL,\n    message_type VARCHAR(50) NOT NULL CHECK (message_type IN ('fixed', 'prompted', 'auto', 'instant')),\n    next_send_at TIMESTAMP WITH TIME ZONE NOT NULL,\n    lease_until TIMESTAMP WITH TIME ZONE,\n    retry_after TIMESTAMP WITH TIME ZONE,\n    serialize_group VARCHAR(64),\n    status VARCHAR(50) NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),\n    retry_count INTEGER DEFAULT 0,\n    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),\n    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()\n  )\n";
+export const TABLE_SQL: "\n  CREATE TABLE IF NOT EXISTS scheduled_messages (\n    id SERIAL PRIMARY KEY,\n    user_id VARCHAR(255) NOT NULL,\n    uuid VARCHAR(36),\n    encrypted_payload TEXT NOT NULL,\n    message_type VARCHAR(50) NOT NULL CHECK (message_type IN ('fixed', 'prompted', 'auto', 'instant')),\n    next_send_at TIMESTAMP WITH TIME ZONE NOT NULL,\n    lease_until TIMESTAMP WITH TIME ZONE,\n    retry_after TIMESTAMP WITH TIME ZONE,\n    serialize_group VARCHAR(64),\n    status VARCHAR(50) NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),\n    retry_count INTEGER DEFAULT 0,\n    last_error TEXT,\n    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),\n    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()\n  )\n";
 /**
  * 建表语句用的是 CREATE TABLE IF NOT EXISTS，已经存在的表不会被改动，所以
  * 后加的列要单独补。initSchema 每次都会跑一遍，Postgres 的 IF NOT EXISTS

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

@@ -14,7 +14,7 @@
  * Index entries mirror the Postgres INDEXES shape ({ name, sql, description,
  * critical }) so both adapters' initSchema() return the same index metadata.
  */
-export const SQLITE_TABLE_SQL: "\n  CREATE TABLE IF NOT EXISTS scheduled_messages (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    user_id TEXT NOT NULL,\n    uuid TEXT,\n    encrypted_payload TEXT NOT NULL,\n    message_type TEXT NOT NULL CHECK (message_type IN ('fixed', 'prompted', 'auto', 'instant')),\n    next_send_at TEXT NOT NULL,\n    lease_until TEXT,\n    retry_after TEXT,\n    serialize_group TEXT,\n    status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),\n    retry_count INTEGER NOT NULL DEFAULT 0,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n  )\n";
+export const SQLITE_TABLE_SQL: "\n  CREATE TABLE IF NOT EXISTS scheduled_messages (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    user_id TEXT NOT NULL,\n    uuid TEXT,\n    encrypted_payload TEXT NOT NULL,\n    message_type TEXT NOT NULL CHECK (message_type IN ('fixed', 'prompted', 'auto', 'instant')),\n    next_send_at TEXT NOT NULL,\n    lease_until TEXT,\n    retry_after TEXT,\n    serialize_group TEXT,\n    status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),\n    retry_count INTEGER NOT NULL DEFAULT 0,\n    last_error TEXT,\n    created_at TEXT NOT NULL,\n    updated_at TEXT NOT NULL\n  )\n";
 /**
  * 建表语句用的是 CREATE TABLE IF NOT EXISTS，已经存在的表不会被改动，所以
  * 后加的列要单独补。initSchema 每次都会跑一遍，列已经在了就跳过。
@@ -32,3 +32,5 @@ export const SQLITE_INDEXES: {
 }[];
 export const CLIENT_STATE_TABLE_SQL: "\n  CREATE TABLE IF NOT EXISTS client_state (\n    user_id TEXT NOT NULL,\n    namespace TEXT NOT NULL,\n    key TEXT NOT NULL,\n    value TEXT NOT NULL,\n    updated_at INTEGER NOT NULL,\n    PRIMARY KEY (user_id, namespace, key)\n  )\n";
 export const PUSH_SUBSCRIPTION_TABLE_SQL: "\n  CREATE TABLE IF NOT EXISTS push_subscriptions (\n    user_id TEXT PRIMARY KEY,\n    subscription TEXT NOT NULL,\n    updated_at INTEGER NOT NULL\n  )\n";
+export const MESSAGE_OUTBOX_TABLE_SQL: "\n  CREATE TABLE IF NOT EXISTS message_outbox (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    user_id TEXT NOT NULL,\n    message_id TEXT NOT NULL,\n    task_uuid TEXT,\n    session_id TEXT,\n    message_index INTEGER,\n    total_messages INTEGER,\n    payload TEXT NOT NULL,\n    created_at INTEGER NOT NULL,\n    delivered_at INTEGER,\n    acked_at INTEGER,\n    UNIQUE (user_id, message_id)\n  )\n";
+export const MESSAGE_OUTBOX_INDEX_SQL: "\n  CREATE INDEX IF NOT EXISTS idx_outbox_unacked\n    ON message_outbox (user_id, id)\n    WHERE acked_at IS NULL\n";

package/dist/{chunk-B2FDV7YK.mjs → chunk-34I2YSWE.mjs}

@@ -12,6 +12,7 @@ var TABLE_SQL = `
     serialize_group VARCHAR(64),
     status VARCHAR(50) NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'sent', 'failed')),
     retry_count INTEGER DEFAULT 0,
+    last_error TEXT,
     created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
     updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
   )
@@ -31,6 +32,14 @@ var MIGRATIONS = [
     name: "add_serialize_group",
     sql: "ALTER TABLE scheduled_messages ADD COLUMN IF NOT EXISTS serialize_group VARCHAR(64)",
     description: "Serialization group for runScheduledTick serializeBy (2.6.0)"
+  },
+  {
+    name: "add_last_error",
+    // 上一次投递失败的脱敏摘要（JSON：{ at, occurrence, reason }）。payload 里
+    // 的 lastError 是密文里的完整记录，这一列是它的明文出口——payload 本身
+    // 解密失败时也写得进去，GET /message 对已失败的行也读得出来。
+    sql: "ALTER TABLE scheduled_messages ADD COLUMN IF NOT EXISTS last_error TEXT",
+    description: "Sanitized last delivery-failure summary (2.6.0)"
   }
 ];
 var INDEXES = [
@@ -108,6 +117,7 @@ var UPDATABLE_COLUMNS = /* @__PURE__ */ new Set([
   "serialize_group",
   "status",
   "retry_count",
+  "last_error",
   "created_at",
   "updated_at"
 ]);