@rei-standard/amsg-server 2.6.0-next.20 → 2.6.0-next.21

package/dist/lib/message-processor.d.ts

@@ -3,6 +3,9 @@
  * @property {Object}  webpush           - The web-push module instance (already VAPID-configured).
  * @property {Object}  vapid             - { email, publicKey, privateKey }
  * @property {import('../adapters/interface.js').DbAdapter} db
+ * @property {{ maxChunkBytes?: number, maxChunks?: number, maxTotalBytes?: number, ttlMs?: number }} [multipart]
+ *   分片传输的限额，宿主传给 `installReiSW` 的那一份原样传过来即可（见
+ *   resolveMultipartOptions）。不传 = 两边都用默认值。
  */
 /**
  * Process a single database task row: decrypt → generate content → push.
@@ -34,12 +37,16 @@ export function processSingleMessage(task: import("../adapters/interface.js").Ta
  * @param {number} [maxRetries=2]
  * @param {string} [userId]
  * @param {string} [providedMasterKey]
- * @returns {Promise<{ success: boolean, messagesSent?: number, retriesUsed?: number, error?: Object }>}
+ * @returns {Promise<{ success: boolean, messagesSent?: number, retriesUsed?: number, reasoningError?: string, error?: Object }>}
+ *   `reasoningError` 只在正文都发出去了、思考过程那一条没发成时出现（思考过程是
+ *   附赠内容，它发不出去不算这条消息失败）。调用方拿它提示用户这次没有思考过程，
+ *   不带这个字段就是整轮都送到了。
  */
 export function processMessagesByUuid(uuid: string, ctx: ProcessorContext, maxRetries?: number, userId?: string, providedMasterKey?: string): Promise<{
     success: boolean;
     messagesSent?: number;
     retriesUsed?: number;
+    reasoningError?: string;
     error?: any;
 }>;
 export { normalizeAiApiUrl } from "./llm.js";
@@ -53,4 +60,14 @@ export type ProcessorContext = {
      */
     vapid: any;
     db: import("../adapters/interface.js").DbAdapter;
+    /**
+     * 分片传输的限额，宿主传给 `installReiSW` 的那一份原样传过来即可（见
+     * resolveMultipartOptions）。不传 = 两边都用默认值。
+     */
+    multipart?: {
+        maxChunkBytes?: number;
+        maxChunks?: number;
+        maxTotalBytes?: number;
+        ttlMs?: number;
+    };
 };

package/dist/lib/outbox-store.d.ts

@@ -18,6 +18,18 @@ export function appendPushesToOutbox({ db, userId, userKey, pushes }: {
     userKey: CryptoKey | string;
     pushes: any[];
 }): Promise<boolean>;
+/**
+ * 把 push 对象转成 message_outbox 的行（payload 加密）。
+ *
+ * 抽出来是给 `ctx.emitResult()` 用的：它落的行要跟推送链路落的完全同构——
+ * 列一样、加密方式一样、身份字段的取法一样，客户端补收时才不用区分是谁写的。
+ *
+ * @param {Object[]} pushes - 定稿后的 push 对象
+ * @param {CryptoKey|string} userKey
+ * @param {number} createdAt - epoch 毫秒
+ * @returns {Promise<Object[]>}
+ */
+export function toOutboxRows(pushes: any[], userKey: CryptoKey | string, createdAt: number): Promise<any[]>;
 /**
  * 把发出去的那部分标成 delivered（发送半途失败时只标已发出的段）。
  *
@@ -31,3 +43,53 @@ export function markPushesDelivered({ db, userId, messageIds }: {
     userId: string;
     messageIds: string[];
 }): Promise<void>;
+/**
+ * 把这一批 push 里「没发出去的那些」从 outbox 撤掉。
+ *
+ * 取消撞上投递时用：整批 push 在开发之前就落进了 outbox，取消只拦住了 Web
+ * Push 这一路，剩下的行不撤掉，客户端下一次 GET /outbox 会照样把它们拉回去
+ * ——用户看到的就是「取消接口回了成功，消息还是来了」。
+ *
+ * 「哪些算没发出去」这条判据收在这里：投递侧只要把整批 push 和已发出的
+ * messageId 交过来就行。
+ *
+ * @param {Object} args
+ * @param {Object} args.db
+ * @param {string} args.userId
+ * @param {Array<{ messageId: string }>} args.pushes - 落进 outbox 的整批 push
+ * @param {string[]} args.sentIds - 已经发出去的 messageId
+ */
+export function discardUndeliveredPushes({ db, userId, pushes, sentIds }: {
+    db: any;
+    userId: string;
+    pushes: Array<{
+        messageId: string;
+    }>;
+    sentIds: string[];
+}): Promise<void>;
+/**
+ * 把某条任务名下「还没发出去的」行从 outbox 撤掉。
+ *
+ * 用在取消 / 顶替只碰了任务行的那两条路上（`DELETE /message` 与
+ * `supersedesUuid`）：任务此前投递到一半失败过的话，没发出去的那几段还躺在
+ * outbox 里等重试，任务行删掉它们也不会跟着走。不撤的话客户端下一次
+ * `GET /outbox` 照样把它们补收回去——用户看到的就是「取消接口回了成功，消息还
+ * 是来了」。
+ *
+ * 判据与 discardUndeliveredPushes 一致：只撤 delivered_at 为 null 的行。已经推
+ * 给设备的那几条撤不回来，行留着让客户端照常 ack——取消的意思是「别再发后面
+ * 的」，不是「把已经收到的从收件箱里抹掉」。
+ *
+ * 同样是 best-effort：适配器缺读/删任一侧就静默跳过，出错只记日志。取消 / 顶
+ * 替本身已经生效了，不该因为账本没清干净被翻成失败。
+ *
+ * @param {Object} args
+ * @param {Object} args.db
+ * @param {string} args.userId
+ * @param {string} args.taskUuid - 被取消 / 被顶替的任务 uuid
+ */
+export function discardUndeliveredPushesForTask({ db, userId, taskUuid }: {
+    db: any;
+    userId: string;
+    taskUuid: string;
+}): Promise<void>;

package/dist/lib/push-subscription-store.d.ts

@@ -28,9 +28,32 @@ export function savePushSubscription({ db, userId, userKey, subscription, update
 }): Promise<{
     updatedAt: number;
 }>;
+/**
+ * 把一行 push_subscriptions 解成明文订阅。行不在、或订阅列是空的 → null；
+ * 密文解不开（换过 masterKey 之类）、解出来不是 JSON → 抛。
+ *
+ * 单独拎出来是为了让调用方分得开两类失败：`db.getPushSubscription()` 抛出来
+ * 的是基础设施问题（表没建、读超时），换个时候重试有救；这里抛出来的是这一
+ * 行的密文废了，重试多少次都一样。两者压在同一个 try 里就只能一起处理，读不
+ * 到库会被当成「这个用户没登记过」。
+ *
+ * @param {{ subscription?: unknown, updated_at?: unknown }|null|undefined} row - `getPushSubscription()` 读回的行
+ * @param {string} userKey
+ * @returns {Promise<{ subscription: Object, updatedAt: number|null }|null>}
+ */
+export function decodePushSubscriptionRow(row: {
+    subscription?: unknown;
+    updated_at?: unknown;
+} | null | undefined, userKey: string): Promise<{
+    subscription: any;
+    updatedAt: number | null;
+} | null>;
 /**
  * 读回这个用户的订阅（解密后的明文对象）。没有登记过 → null。
  *
+ * 读库失败和解密失败都原样抛出去：投递链路上这两种都得让任务失败，分不分得
+ * 开无所谓；要分开处理的调用方（GET /push-subscription）自己走上面两步。
+ *
  * @param {Object} args
  * @param {import('../adapters/interface.js').DbAdapter} args.db
  * @param {string} args.userId

package/dist/lib/request.d.ts

@@ -1,3 +1,42 @@
+/**
+ * 把请求正文读成字符串，`Content-Encoding: gzip` 的在这一步还原。
+ *
+ * 客户端把大 body（一次 fire_pack、一整批 client_state）压了再传能省下几倍
+ * 传输量，代价只有服务端这一次解压。所有带 body 的端点走同一个入口，谁都不用
+ * 各自判一遍这个头。
+ *
+ * 说是 gzip、字节却不是 gzip 开头时按明文处理：有些边缘网关会替你把请求体解
+ * 开却留着原来的 `Content-Encoding` 头，再解一次只会解出乱码。魔数判断两种情
+ * 况都接得住。
+ *
+ * 只认 gzip。deflate / br 回 415 而不是猜着解——猜错解出来的是一段乱码，会变
+ * 成一句让人找不着北的「请求体不是有效的 JSON」。
+ *
+ * @param {{ headers?: { get?: (name: string) => string|null }, text: () => Promise<string>, arrayBuffer: () => Promise<ArrayBuffer> }} request
+ *   Fetch API 的 Request（或形状相同的对象）。
+ * @param {{ maxBytes?: number }} [options] - `maxBytes`：解压后的字节上限，
+ *   默认 {@link DEFAULT_MAX_REQUEST_BODY_BYTES}。
+ * @returns {Promise<{ ok: true, body: string } | { ok: false, error: { status: number, body: Object } }>}
+ *   `error` 就是可以直接回给调用方的那个信封（与 handler 的返回同构）。
+ */
+export function readRequestBody(request: {
+    headers?: {
+        get?: (name: string) => string | null;
+    };
+    text: () => Promise<string>;
+    arrayBuffer: () => Promise<ArrayBuffer>;
+}, options?: {
+    maxBytes?: number;
+}): Promise<{
+    ok: true;
+    body: string;
+} | {
+    ok: false;
+    error: {
+        status: number;
+        body: any;
+    };
+}>;
 /**
  * @typedef {{ code: string, message: string }} ValidationError
  */
@@ -118,6 +157,14 @@ export namespace REQUEST_ERRORS {
         export { message_2 as message };
     }
 }
+/**
+ * 解压后请求体的字节上限（默认 32MB）。
+ *
+ * 只管 gzip 那条路：压缩数据能用很小的体积展开成极大的正文（几百 KB 换几个
+ * GB），不设上限等于把内存交给调用方决定。不压缩的请求体不受这个数约束，行为
+ * 与以前一致——那条路的体积本来就摆在传输量上，平台自己的请求大小限制盖得住。
+ */
+export const DEFAULT_MAX_REQUEST_BODY_BYTES: number;
 export type ValidationError = {
     code: string;
     message: string;

package/dist/lib/result-emitter.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @typedef {Object} ResultEmitter
+ * @property {(payload: Object) => Promise<{ messageId: string, pushed: boolean }>} emitResult
+ *   把一条结果落进收件箱并推送出去。`payload` 是宿主自己的形状，只有两个约束：
+ *   必须是普通对象，且带一个非空的 `resultKind`（这类结果的名字，客户端按它
+ *   分流）。返回 `messageId`（补收和去重的键）与 `pushed`（这次推送有没有真
+ *   的发出去；`false` 只表示没能当场送达，行还在收件箱里等补收）。
+ */
+/**
+ * 造一份作用于某条任务的结果出口。
+ *
+ * 身份字段（`taskId` / `taskUuid` / `recurrenceType` / `occurrenceMs` /
+ * `messageKind`）由库覆盖写：它们描述的是这条任务行的事实，不是内容。
+ * `messageId` / `sessionId` / `timestamp` 宿主没给才补——`messageId` 的缺省
+ * 值掺了任务 id 与本次名义触发时刻，同一次触发重试时组出同一个 id，收件箱靠
+ * `(user_id, message_id)` 唯一约束天然去重，不会补出第二条。
+ *
+ * @param {Object} args
+ * @param {import('../adapters/interface.js').DbAdapter} args.db
+ * @param {Object} args.task - 数据库任务行
+ * @param {string} args.userKey - per-user 存储密钥
+ * @param {Object} args.decryptedPayload - 解密后的任务 payload（取 messageType / recurrenceType / 老任务里的订阅）
+ * @param {string} args.messageIdBase - messageId 的前缀（与推送链路同一份）
+ * @param {string} args.sessionId
+ * @param {number|null} args.occurrenceMs
+ * @param {{ sendNotification: Function }|null} args.webpush
+ * @param {() => number} [args.now] - 取当前时刻（测试可注入假时钟）
+ * @returns {ResultEmitter}
+ */
+export function createResultEmitter({ db, task, userKey, decryptedPayload, messageIdBase, sessionId, occurrenceMs, webpush, now, }: {
+    db: import("../adapters/interface.js").DbAdapter;
+    task: any;
+    userKey: string;
+    decryptedPayload: any;
+    messageIdBase: string;
+    sessionId: string;
+    occurrenceMs: number | null;
+    webpush: {
+        sendNotification: Function;
+    } | null;
+    now?: () => number;
+}): ResultEmitter;
+export type ResultEmitter = {
+    /**
+     *   把一条结果落进收件箱并推送出去。`payload` 是宿主自己的形状，只有两个约束：
+     *   必须是普通对象，且带一个非空的 `resultKind`（这类结果的名字，客户端按它
+     *   分流）。返回 `messageId`（补收和去重的键）与 `pushed`（这次推送有没有真
+     *   的发出去；`false` 只表示没能当场送达，行还在收件箱里等补收）。
+     */
+    emitResult: (payload: any) => Promise<{
+        messageId: string;
+        pushed: boolean;
+    }>;
+};

package/dist/lib/run-tick.d.ts

@@ -24,6 +24,8 @@ export function runScheduledTick(ctx: any): Promise<{
         deletedOnceOffTasks: number;
         updatedRecurringTasks: number;
         staleTasks: any[];
+        cancelledTasks: any[];
+        reasoningSkippedTasks: any[];
         failedTasks: any[];
     };
 }>;
@@ -102,5 +104,12 @@ export type StaleSkipInfo = {
     nextSendAt: string | null;
     readState: (namespace: string) => Promise<any[]>;
     writeState: (namespace: string, entries: any[]) => Promise<any>;
+    /**
+     *   往客户端补一条自定义结果（落收件箱 + 推送，见 lib/result-emitter.js）。
+     */
+    emitResult: (payload: any) => Promise<{
+        messageId: string;
+        pushed: boolean;
+    }>;
 };
 import { sanitizeErrorSummary } from './errors.js';

package/dist/lib/task-projection.d.ts

@@ -26,8 +26,10 @@
  * @property {string|null}  clientTaskId  - 取自 metadata.amsgClientTaskId
  * @property {Object|null}  credRefs      - 凭据引用（{ <purpose>: <cred_id> }）；引用不是机密，客户端对账要看。没带 → null
  * @property {Object|null}  [metadata]    - 只有 includeMetadata 时才有，见下
- * @property {{ at: string, occurrence: string, reason: string, pushStatus?: number }|null} lastError
- *   `pushStatus` 只在投递失败于推送这一步时出现，值是推送服务回的 HTTP 状态码。
+ * @property {{ at: string, occurrence: string, reason: string, errorCode?: string, pushStatus?: number }|null} lastError
+ *   `errorCode` 是底层错误的稳定 code（如 `PUSH_PAYLOAD_TOO_LARGE`），拿得到就
+ *   带上；`pushStatus` 只在投递失败于推送这一步时出现，值是推送服务回的 HTTP
+ *   状态码。判断该怎么处置读这两个字段，别去正则匹配 `reason`。
  */
 /**
  * @param {Object} row - 数据库任务行
@@ -76,12 +78,15 @@ export type TaskProjection = {
      */
     metadata?: any | null;
     /**
-     *   `pushStatus` 只在投递失败于推送这一步时出现，值是推送服务回的 HTTP 状态码。
+     *   `errorCode` 是底层错误的稳定 code（如 `PUSH_PAYLOAD_TOO_LARGE`），拿得到就
+     *   带上；`pushStatus` 只在投递失败于推送这一步时出现，值是推送服务回的 HTTP
+     *   状态码。判断该怎么处置读这两个字段，别去正则匹配 `reason`。
      */
     lastError: {
         at: string;
         occurrence: string;
         reason: string;
+        errorCode?: string;
         pushStatus?: number;
     } | null;
 };

package/dist/lib/validation.d.ts

@@ -46,6 +46,36 @@ export function validateSplitPattern(value: unknown): string | null;
  * @returns {string | null}   Error message, or null if valid.
  */
 export function validateLlmMessagesArray(messages: unknown): string | null;
+/**
+ * 落库前量一次任务正文。合法返回 null，超限返回可以直接放进 400 响应体的
+ * error 对象——`POST /schedule-message` 与 `PUT /update-message` 共用同一个错
+ * 误码和同一套 details，下游判断读 `details.bytes` / `details.maxBytes`，不用
+ * 去解析那句人话。
+ *
+ * 按 UTF-8 字节算而不是字符数：D1 限的是字节，加密前也是先转 UTF-8，一段全中
+ * 文的正文字符数只有字节数的三分之一，用 `.length` 量等于把上限放大三倍。
+ *
+ * @param {string} serializedPayload - 将要交给 encryptForStorage 的那个字符串。
+ * @returns {{ code: string, message: string, details: { bytes: number, maxBytes: number } } | null}
+ */
+export function validateTaskPayloadSize(serializedPayload: string): {
+    code: string;
+    message: string;
+    details: {
+        bytes: number;
+        maxBytes: number;
+    };
+} | null;
+/**
+ * 任务正文的 UTF-8 字节数（与 {@link validateTaskPayloadSize} 同一把尺子）。
+ *
+ * `PUT /update-message` 拿它跟改动前的正文比大小：上限是后加的，比它更早建出来
+ * 的大任务不该因此连排期都改不了，只要这次改动没把它变得更大就放行。
+ *
+ * @param {string} serializedPayload
+ * @returns {number}
+ */
+export function taskPayloadByteLength(serializedPayload: string): number;
 /**
  * Validate the schedule-message request payload.
  *
@@ -58,5 +88,10 @@ export function validateScheduleMessagePayload(payload: any): {
     errorMessage?: string;
     details?: any;
 };
+/**
+ * 一条任务正文（`JSON.stringify` 的结果）的明文上限，UTF-8 字节数。
+ * 客户端想在提交前自己预算就读这个数（从 `@rei-standard/amsg-server` 导出）。
+ */
+export const MAX_TASK_PAYLOAD_BYTES: number;
 import { isValidTimeZoneId } from './recurrence.js';
 export { isValidTimeZoneId, isValidUrl, validateAvatarUrl };

package/dist/{neon-U6TQFKMJ.cjs → neon-KP2CPA57.cjs}

@@ -19,7 +19,9 @@ var _chunkE7OWP3VLcjs = require('./chunk-E7OWP3VL.cjs');
 
 
 
-var _chunkV6NZQ22Scjs = require('./chunk-V6NZQ22S.cjs');
+
+
+var _chunk7NMQFTDJcjs = require('./chunk-7NMQFTDJ.cjs');
 
 // src/server/adapters/neon.js
 var _serverless = require('@neondatabase/serverless');
@@ -29,7 +31,13 @@ var NeonAdapter = class {
     this._connectionString = connectionString;
     this._sql = null;
   }
-  /** @private */
+  /**
+   * neon() 的 HTTP 驱动：一次查询一个 fetch，两次查询之间不留连接。所以它没有
+   * pg 那种「空闲连接被服务端掐断」的问题——连接层面的错误只会让当次调用的
+   * Promise 失败，落在调用方的 try/catch 里，不会变成进程级未捕获异常。
+   *
+   * @private
+   */
   _getSql() {
     if (!this._sql) {
       this._sql = _serverless.neon.call(void 0, this._connectionString);
@@ -38,14 +46,14 @@ var NeonAdapter = class {
   }
   async initSchema() {
     const sql = this._getSql();
-    await sql.query(_chunkV6NZQ22Scjs.TABLE_SQL);
-    await sql.query(_chunkV6NZQ22Scjs.PUSH_SUBSCRIPTION_TABLE_SQL);
-    await sql.query(_chunkV6NZQ22Scjs.LLM_CREDENTIALS_TABLE_SQL);
-    for (const migration of _chunkV6NZQ22Scjs.MIGRATIONS) {
+    await sql.query(_chunk7NMQFTDJcjs.TABLE_SQL);
+    await sql.query(_chunk7NMQFTDJcjs.PUSH_SUBSCRIPTION_TABLE_SQL);
+    await sql.query(_chunk7NMQFTDJcjs.LLM_CREDENTIALS_TABLE_SQL);
+    for (const migration of _chunk7NMQFTDJcjs.MIGRATIONS) {
       await sql.query(migration.sql);
     }
     const indexResults = [];
-    for (const index of _chunkV6NZQ22Scjs.INDEXES) {
+    for (const index of _chunk7NMQFTDJcjs.INDEXES) {
       try {
         await sql.query(index.sql);
         indexResults.push({
@@ -71,11 +79,11 @@ var NeonAdapter = class {
         `Critical index creation failed (${failedNames}). Please remove duplicate UUID rows and run initSchema again.`
       );
     }
-    const tableCheck = await sql.query(_chunkV6NZQ22Scjs.VERIFY_TABLE_SQL);
+    const tableCheck = await sql.query(_chunk7NMQFTDJcjs.VERIFY_TABLE_SQL);
     if (tableCheck.length === 0) {
       throw new Error("Table creation verification failed");
     }
-    const columns = await sql.query(_chunkV6NZQ22Scjs.COLUMNS_SQL);
+    const columns = await sql.query(_chunk7NMQFTDJcjs.COLUMNS_SQL);
     return {
       columnsCreated: columns.length,
       indexesCreated: indexResults.filter((r) => r.status === "success").length,
@@ -106,7 +114,7 @@ var NeonAdapter = class {
   async getTaskByUuid(uuid, userId) {
     const sql = this._getSql();
     const rows = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, last_error, created_at, updated_at
+      `SELECT ${_chunk7NMQFTDJcjs.TASK_DETAIL_COLUMNS}
        FROM scheduled_messages
        WHERE uuid = $1 AND user_id = $2 AND status = 'pending'
        LIMIT 1`,
@@ -117,7 +125,7 @@ var NeonAdapter = class {
   async getTaskByUuidOnly(uuid) {
     const sql = this._getSql();
     const rows = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT ${_chunk7NMQFTDJcjs.TASK_DELIVERY_COLUMNS}
        FROM scheduled_messages
        WHERE uuid = $1 AND status = 'pending'
        LIMIT 1`,
@@ -146,7 +154,7 @@ var NeonAdapter = class {
     const values = [];
     let idx = 1;
     for (const [key, value] of Object.entries(updates)) {
-      if (!_chunkV6NZQ22Scjs.UPDATABLE_COLUMNS.has(key)) {
+      if (!_chunk7NMQFTDJcjs.UPDATABLE_COLUMNS.has(key)) {
         throw new Error(`[amsg-server neon] rejected unknown update column: ${key}`);
       }
       sets.push(`${key} = $${idx}`);
@@ -168,7 +176,7 @@ var NeonAdapter = class {
     let idx = 2;
     if (extraFields) {
       for (const [key, value] of Object.entries(extraFields)) {
-        if (!_chunkV6NZQ22Scjs.UPDATABLE_COLUMNS.has(key)) {
+        if (!_chunk7NMQFTDJcjs.UPDATABLE_COLUMNS.has(key)) {
           throw new Error(`[amsg-server neon] rejected unknown update column: ${key}`);
         }
         sets.push(`${key} = $${idx}`);
@@ -201,7 +209,7 @@ var NeonAdapter = class {
   async getPendingTasks(limit = 50) {
     const sql = this._getSql();
     return sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, retry_after, status, retry_count
+      `SELECT ${_chunk7NMQFTDJcjs.TASK_DELIVERY_COLUMNS}
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
          AND (lease_until IS NULL OR lease_until <= NOW())
@@ -241,7 +249,7 @@ var NeonAdapter = class {
     const total = parseInt(countRows[0].count, 10);
     const taskParams = [...params, limit, offset];
     const tasks = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, last_error, created_at, updated_at
+      `SELECT ${_chunk7NMQFTDJcjs.TASK_DETAIL_COLUMNS}
        FROM scheduled_messages
        WHERE ${where}
        ORDER BY next_send_at ASC

package/dist/{neon-Y4KEZO5C.mjs → neon-ZIMHALYI.mjs}

@@ -17,9 +17,11 @@ import {
   MIGRATIONS,
   PUSH_SUBSCRIPTION_TABLE_SQL,
   TABLE_SQL,
+  TASK_DELIVERY_COLUMNS,
+  TASK_DETAIL_COLUMNS,
   UPDATABLE_COLUMNS,
   VERIFY_TABLE_SQL
-} from "./chunk-5FXVSC5O.mjs";
+} from "./chunk-GN44PST5.mjs";
 
 // src/server/adapters/neon.js
 import { neon } from "@neondatabase/serverless";
@@ -29,7 +31,13 @@ var NeonAdapter = class {
     this._connectionString = connectionString;
     this._sql = null;
   }
-  /** @private */
+  /**
+   * neon() 的 HTTP 驱动：一次查询一个 fetch，两次查询之间不留连接。所以它没有
+   * pg 那种「空闲连接被服务端掐断」的问题——连接层面的错误只会让当次调用的
+   * Promise 失败，落在调用方的 try/catch 里，不会变成进程级未捕获异常。
+   *
+   * @private
+   */
   _getSql() {
     if (!this._sql) {
       this._sql = neon(this._connectionString);
@@ -106,7 +114,7 @@ var NeonAdapter = class {
   async getTaskByUuid(uuid, userId) {
     const sql = this._getSql();
     const rows = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, last_error, created_at, updated_at
+      `SELECT ${TASK_DETAIL_COLUMNS}
        FROM scheduled_messages
        WHERE uuid = $1 AND user_id = $2 AND status = 'pending'
        LIMIT 1`,
@@ -117,7 +125,7 @@ var NeonAdapter = class {
   async getTaskByUuidOnly(uuid) {
     const sql = this._getSql();
     const rows = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT ${TASK_DELIVERY_COLUMNS}
        FROM scheduled_messages
        WHERE uuid = $1 AND status = 'pending'
        LIMIT 1`,
@@ -201,7 +209,7 @@ var NeonAdapter = class {
   async getPendingTasks(limit = 50) {
     const sql = this._getSql();
     return sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, retry_after, status, retry_count
+      `SELECT ${TASK_DELIVERY_COLUMNS}
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
          AND (lease_until IS NULL OR lease_until <= NOW())
@@ -241,7 +249,7 @@ var NeonAdapter = class {
     const total = parseInt(countRows[0].count, 10);
     const taskParams = [...params, limit, offset];
     const tasks = await sql.query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, last_error, created_at, updated_at
+      `SELECT ${TASK_DETAIL_COLUMNS}
        FROM scheduled_messages
        WHERE ${where}
        ORDER BY next_send_at ASC

package/dist/{pg-GWJZBWAM.mjs → pg-QGC2XHUT.mjs}

@@ -17,9 +17,11 @@ import {
   MIGRATIONS,
   PUSH_SUBSCRIPTION_TABLE_SQL,
   TABLE_SQL,
+  TASK_DELIVERY_COLUMNS,
+  TASK_DETAIL_COLUMNS,
   UPDATABLE_COLUMNS,
   VERIFY_TABLE_SQL
-} from "./chunk-5FXVSC5O.mjs";
+} from "./chunk-GN44PST5.mjs";
 
 // src/server/adapters/pg.js
 import { Pool } from "pg";
@@ -33,6 +35,12 @@ var PgAdapter = class {
   _getPool() {
     if (!this._pool) {
       this._pool = new Pool({ connectionString: this._connectionString });
+      this._pool.on("error", (error) => {
+        console.error(
+          "[amsg-server pg] \u8FDE\u63A5\u6C60\u91CC\u7684\u7A7A\u95F2\u8FDE\u63A5\u51FA\u9519\uFF08\u8BE5\u8FDE\u63A5\u5DF2\u88AB\u6458\u9664\uFF0C\u4E0B\u6B21\u67E5\u8BE2\u4F1A\u91CD\u8FDE\uFF09:",
+          error && error.message
+        );
+      });
     }
     return this._pool;
   }
@@ -108,7 +116,7 @@ var PgAdapter = class {
   }
   async getTaskByUuid(uuid, userId) {
     const rows = await this._query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, last_error, created_at, updated_at
+      `SELECT ${TASK_DETAIL_COLUMNS}
        FROM scheduled_messages
        WHERE uuid = $1 AND user_id = $2 AND status = 'pending'
        LIMIT 1`,
@@ -118,7 +126,7 @@ var PgAdapter = class {
   }
   async getTaskByUuidOnly(uuid) {
     const rows = await this._query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count
+      `SELECT ${TASK_DELIVERY_COLUMNS}
        FROM scheduled_messages
        WHERE uuid = $1 AND status = 'pending'
        LIMIT 1`,
@@ -196,7 +204,7 @@ var PgAdapter = class {
   }
   async getPendingTasks(limit = 50) {
     return this._query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, retry_after, status, retry_count
+      `SELECT ${TASK_DELIVERY_COLUMNS}
        FROM scheduled_messages
        WHERE status = 'pending' AND next_send_at <= NOW()
          AND (lease_until IS NULL OR lease_until <= NOW())
@@ -233,7 +241,7 @@ var PgAdapter = class {
     const total = parseInt(countRows[0].count, 10);
     const taskParams = [...params, limit, offset];
     const tasks = await this._query(
-      `SELECT id, user_id, uuid, encrypted_payload, message_type, next_send_at, status, retry_count, last_error, created_at, updated_at
+      `SELECT ${TASK_DETAIL_COLUMNS}
        FROM scheduled_messages
        WHERE ${where}
        ORDER BY next_send_at ASC