dsh-mobile-plugin 0.1.99 → 0.2.0

package/lib/mobile/extensions.js

@@ -0,0 +1,279 @@
+'use strict';
+
+/**
+ * 扩展卡的宿主侧：卡状态账本、扩展动作登记表，以及给模型用的 `extension_present` 工具。
+ *
+ * 为什么卡状态要落在宿主家里：一张卡「现在长什么样」不能只靠声明它的那一次工具调用。
+ * 扩展页回写标题与说明之后，手机上重进会话、刷新列表都会从历史重新拼卡 —— 没有这份账本，
+ * 卡会一直停在声明那一刻的样子（卡的状态得由宿主认账）。账本与会话
+ * 日志无关，清理会话不连带它，与统计账本同口径。
+ *
+ * 为什么动作名是一张硬编码白名单：扩展是网页，它能让宿主做的事必须由宿主预先枚举，而不是
+ * 由扩展在消息里现拼一个动作名交给宿主执行。这条边界和移动 API 的能力面是同一条 —— 移动
+ * API 不暴露 shell、系统设置、任意文件读写，这里也一个都不开。**登记表现在是空的**：宿主动作
+ * 这一档还没有对任何扩展放开，所以任何动作名都必须被拒。
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { sendJson, readJsonBody } = require('../shared/http-util');
+const { dshHome } = require('../shared/paths');
+
+/** 账本文件名。跟会话日志分开，清理会话时不动它。 */
+const CARDS_FILE = 'mobile-extension-cards.json';
+/** 一条卡状态的标题 / 说明上限：App 那张卡只画一行，长正文只会把它撑坏。 */
+const MAX_TEXT = 200;
+/** 整张表的上限：会话越积越多，不封顶的话这份 JSON 会一直长下去。 */
+const MAX_CARDS = 500;
+
+function cardsFile() {
+  return path.join(dshHome(), CARDS_FILE);
+}
+
+/**
+ * 读整张表。文件不在、读坏、形状不对都当空表 —— 账本是锦上添花，读不出来不该让请求失败
+ * （卡按声明的样子画，下一次回写会把它补回来）。
+ */
+function readLedger() {
+  let text;
+  try { text = fs.readFileSync(cardsFile(), 'utf8'); } catch { return {}; }
+  let parsed;
+  try { parsed = JSON.parse(text); } catch { return {}; }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
+  return parsed;
+}
+
+/**
+ * 整份覆写。**写失败不抛**：回写卡状态是扩展页的一次旁路动作，写不进去最多是下次进会话
+ * 看到旧状态，不该把这次请求变成失败。仍然是先写临时文件再改名，宿主随时可能被杀。
+ */
+function writeLedger(table) {
+  const file = cardsFile();
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(table, null, 2)}\n`);
+    fs.renameSync(temp, file);
+  } catch { /* 旁路：写不进去就算了 */ }
+}
+
+function cardKey(sessionId, cardId) {
+  return `${sessionId}:${cardId}`;
+}
+
+function textOf(value) {
+  return typeof value === 'string' ? value.slice(0, MAX_TEXT) : '';
+}
+
+/** 一条记录至少要有身份：会话、卡、扩展三者缺一就没有可认的卡。 */
+function validCard(input) {
+  if (!input || typeof input !== 'object') return null;
+  const sessionId = typeof input.sessionId === 'string' ? input.sessionId.trim() : '';
+  const cardId = typeof input.cardId === 'string' ? input.cardId.trim() : '';
+  const extension = typeof input.extension === 'string' ? input.extension.trim() : '';
+  const title = textOf(input.title);
+  const detail = textOf(input.detail);
+  // title 与 detail 都空等于「这张卡什么都没变」，收下来只会把声明时那句话擦掉。
+  if (!sessionId || !cardId || !extension) return null;
+  if (!title && !detail) return null;
+  return { sessionId, cardId, extension, title, detail };
+}
+
+/** 丢掉最旧的那几条，直到表回到上限以内。 */
+function trimLedger(table) {
+  const entries = Object.entries(table);
+  if (entries.length <= MAX_CARDS) return;
+  entries.sort((left, right) => (Number(left[1].updatedAt) || 0) - (Number(right[1].updatedAt) || 0));
+  for (const [key] of entries.slice(0, entries.length - MAX_CARDS)) delete table[key];
+}
+
+/**
+ * 写一条卡状态。参数不合法回 null（调用方据此回 400），合法则回完整记录。
+ *
+ * 同一张卡重复回写是覆盖，不追加：`sessionId:cardId` 就是这张卡的身份，与 App 侧
+ * 卡上的 id（那次工具调用的 id）是同一个东西。
+ */
+function writeCard(input) {
+  const card = validCard(input);
+  if (!card) return null;
+  const table = readLedger();
+  const record = { ...card, updatedAt: Date.now() };
+  table[cardKey(card.sessionId, card.cardId)] = record;
+  trimLedger(table);
+  writeLedger(table);
+  return record;
+}
+
+/** 这条会话里被回写过的卡状态。坏行丢掉，别的会话的一律不带上。 */
+function readCards(sessionId) {
+  if (typeof sessionId !== 'string' || !sessionId) return [];
+  const table = readLedger();
+  const cards = [];
+  for (const value of Object.values(table)) {
+    if (!value || typeof value !== 'object') continue;
+    if (value.sessionId !== sessionId) continue;
+    if (typeof value.cardId !== 'string' || !value.cardId) continue;
+    if (typeof value.extension !== 'string' || !value.extension) continue;
+    cards.push({
+      cardId: value.cardId,
+      extension: value.extension,
+      title: typeof value.title === 'string' ? value.title : '',
+      detail: typeof value.detail === 'string' ? value.detail : '',
+      updatedAt: typeof value.updatedAt === 'number' ? value.updatedAt : 0,
+    });
+  }
+  return cards;
+}
+
+/**
+ * 已登记的宿主动作：扩展 slug → { 动作名: 处理函数 }。
+ *
+ * **现在是空的**：宿主动作这一档还没有对任何扩展放开，所以 `actionsFor` 恒回空数组、
+ * `runAction` 恒回 `extension-action-unknown`。要放开第三方来源时，在这里逐个扩展、
+ * 逐个动作名登记 —— 只认这张表里的字面名字，不接受通配，也不接受调用方现拼的动作名。
+ * 处理函数拿到的是扩展带来的 params，返回值放进 `result` 原样交回。
+ */
+const HOST_ACTIONS = Object.freeze({
+  // '某个扩展的 slug': {
+  //   '某个动作名': async (params) => ({ /* 交回给扩展的结果 */ }),
+  // },
+});
+
+/** 这个扩展被宿主预先枚举过的动作名；没登记过就是空数组。 */
+function actionsFor(extensionSlug) {
+  if (typeof extensionSlug !== 'string' || !extensionSlug) return [];
+  const table = HOST_ACTIONS[extensionSlug];
+  return table ? Object.keys(table) : [];
+}
+
+/**
+ * 让宿主替扩展办一件事。
+ *
+ * 动作名不在 `actionsFor` 里一律拒 —— 包括 `*` 这类看起来像通配的写法。有登记时按登记表
+ * 里的处理函数执行；登记表现在是空的，所以这条分支只剩形状（放开时在下面接处理函数）。
+ *
+ * **不抛异常**：被拒是预期结果，不是故障，调用方要拿它回 403 而不是 500。
+ */
+async function runAction(input) {
+  const extension = input && typeof input.extension === 'string' ? input.extension : '';
+  const action = input && typeof input.action === 'string' ? input.action : '';
+  if (!extension || !action || !actionsFor(extension).includes(action)) {
+    return { ok: false, code: 'extension-action-unknown', message: '该扩展没有登记这个动作' };
+  }
+  const handler = HOST_ACTIONS[extension][action];
+  return { ok: true, result: await handler(input.params) };
+}
+
+/**
+ * 模型声明一张扩展卡的工具。
+ *
+ * 卡本身不是这里存的：工具只把「哪个扩展、哪张卡、写了什么」说清楚，App 从历史里那次调用
+ * 的参数画出卡，之后的状态回写落在上面那张账本里。所以这里不写账本 —— 声明与回写是两件事
+ * （卡可以声明之后再也没人动过）。
+ */
+function registerExtensionTool(ctx) {
+  const { defineTool } = require('@deepseek-ai/dsh-tools');
+  ctx.tools.register(defineTool({
+    name: 'extension_present',
+    description: 'Declare a card that an installed extension takes over (for example a draft or a form flow). The card is drawn from this call; the extension page can later write back its title and detail.',
+    parameters: {
+      extension: { type: 'string', required: true, description: 'Slug of the installed extension that takes over this content.' },
+      title: { type: 'string', required: true, description: 'One-line title shown on the card.' },
+      detail: { type: 'string', description: 'Optional secondary line; keep it short, the card shows one line.' },
+    },
+    output: {
+      schema: { type: 'object', additionalProperties: false, properties: {
+        extension: { type: 'string' }, title: { type: 'string' }, detail: { type: 'string' },
+      } },
+      render: (_args, value) => [{ type: 'text', text: `已为扩展 ${value.extension} 声明卡片：${value.title}` }],
+    },
+    execute: (args) => ({
+      extension: args.extension,
+      title: args.title,
+      detail: typeof args.detail === 'string' ? args.detail : '',
+    }),
+  }));
+}
+
+/**
+ * 装配层的入口：挂 `extension_present` 工具。
+ *
+ * 账本与三条路由不依赖这个工具，所以没有 tools 注入的 profile 照样能回写卡状态；缺注入
+ * 时只静默跳过（cordis 抛的是 "cannot get property … without inject"，与 session-cleanup
+ * 同一口径）。其余错误照抛 —— 不能把真的注册失败也当成「这个 profile 没注入」。
+ */
+function installExtensions(ctx) {
+  try {
+    registerExtensionTool(ctx);
+  } catch (error) {
+    const message = error && error.message ? error.message : String(error);
+    if (!message.includes('without inject')) throw error;
+  }
+}
+
+/**
+ * GET /api/mobile/v1/extension/cards?sessionId=…（token）
+ *
+ * 这条会话里被回写过的卡状态；没有会话 id 就回 400，不拿空数组冒充「没有卡」。
+ */
+async function handleExtensionCards(_ctx, req, res) {
+  const url = new URL(req.url || '/', 'http://x');
+  const sessionId = (url.searchParams.get('sessionId') || '').trim();
+  if (!sessionId) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 sessionId' } });
+  }
+  sendJson(res, 200, { ok: true, cards: readCards(sessionId) });
+}
+
+/**
+ * POST /api/mobile/v1/extension/card-state（token）
+ * body: { sessionId, cardId, extension, title?, detail? }
+ *
+ * `sessionId` / `cardId` / `extension` 由 App 按卡本身填，不由扩展页提供 —— 页面能指定
+ * 别人的卡就等于能回写别人的卡。写失败不回错误，理由在 writeLedger 上。
+ */
+async function handleExtensionCardState(_ctx, req, res) {
+  const body = await readJsonBody(req, 64 * 1024);
+  const card = body ? writeCard(body) : null;
+  if (!card) {
+    return sendJson(res, 400, {
+      ok: false,
+      error: { code: 'bad-request', message: '需要 { sessionId, cardId, extension }，且 title 与 detail 不能都为空' },
+    });
+  }
+  sendJson(res, 200, { ok: true, card });
+}
+
+/**
+ * POST /api/mobile/v1/extension/action（token）
+ * body: { extension, action, params? }
+ *
+ * 没登记的动作回 **403**：这不是请求坏了，是预期内的拒绝，App 侧据此让扩展页自己解释
+ * 「这个动作宿主没开放」，而不是当成请求失败。`code` / `message` 放在顶层，与 App 那边
+ * 读 `body.code` 的口径一致（见 `app/src/api/domains/extensions.ts`）。
+ */
+async function handleExtensionAction(_ctx, req, res) {
+  const body = await readJsonBody(req, 64 * 1024);
+  if (!body || typeof body.extension !== 'string' || !body.extension
+    || typeof body.action !== 'string' || !body.action) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { extension, action }' } });
+  }
+  const outcome = await runAction({ extension: body.extension, action: body.action, params: body.params });
+  if (!outcome.ok) return sendJson(res, 403, { ok: false, code: outcome.code, message: outcome.message });
+  sendJson(res, 200, { ok: true, result: outcome.result });
+}
+
+module.exports = {
+  actionsFor,
+  runAction,
+  readCards,
+  writeCard,
+  registerExtensionTool,
+  installExtensions,
+  handleExtensionCards,
+  handleExtensionCardState,
+  handleExtensionAction,
+  MAX_TEXT,
+  MAX_CARDS,
+};

package/lib/mobile/history-derive.js

@@ -162,6 +162,38 @@ function buildToolResultMap(events) {
   return map;
 }
 
+/**
+ * 把整窗工具结果折成客户端补丁（`/session/messages` 顶层的 `toolResults`）。
+ *
+ * 补丁本身必须取自整个窗口：调用方游标可能已经越过结果 seq，而工具卡还停在 running，
+ * 客户端按 callId 幂等打补丁。但**已经随消息块下发的**那份结果不再重复带正文 ——
+ * `items` 里的 tool-call 块本来就是同一张表构出来的，输出/图片/diff 再传一遍等于同一份
+ * 工具输出在一条响应里走两趟。客户端打补丁时状态照写、正文只在给了的时候才覆盖，所以
+ * 那几格省掉是安全的；消息块不在这份窗口里时才带全。
+ */
+function toolResultPatchesFor(events, items) {
+  const delivered = new Set();
+  for (const item of items || []) {
+    if (!item || !Array.isArray(item.blocks)) continue;
+    for (const block of item.blocks) {
+      if (block && block.type === 'tool-call' && typeof block.callId === 'string' && block.callId) {
+        delivered.add(block.callId);
+      }
+    }
+  }
+  return [...buildToolResultMap(events).entries()].map(([callId, result]) => {
+    const state = result.isError ? (result.code === 'interrupted' ? 'stopped' : 'error') : 'ok';
+    if (delivered.has(callId)) return { callId, state };
+    return {
+      callId,
+      state,
+      ...(result.output ? { output: result.output } : {}),
+      ...(result.images && result.images.length ? { images: result.images } : {}),
+      ...(result.diffs && result.diffs.length ? { diffs: result.diffs } : {}),
+    };
+  });
+}
+
 /** 把 assistant message.content 解析为一个结构块数组（text/reasoning/tool-call/image）。 */
 function parseBlocks(blocks, toolResults) {
   if (!Array.isArray(blocks)) return [];
@@ -729,6 +761,131 @@ function deriveMessages(events) {
   return out;
 }
 
+/**
+ * 入口窗口的「内容化」裁剪（`GET /session/messages?thin=1`，只对不带 beforeSeq / afterSeq 的
+ * 一次性入口窗口生效；往上翻页与增量补拉保持完整）。
+ *
+ * 为什么：入口原来按「消息条数」截尾巴，而宿主每跑一个 agent 步就落一条 assistant 消息
+ * （推理块 + 工具调用块）。一次长回合几十上百步，最后 40 条可能全是这些过程消息 ——
+ * 用户自己那句话被挤出窗口，进对话只剩半轮，看起来像「我说的话凭空消失」。
+ *
+ * 现在入口按「轮」分组、只留用户看得见的内容：
+ *  - 用户消息 / 定时任务唤醒行（原样）；
+ *  - 助手正文（中途汇报与最终答复都算）与带图的消息；
+ *  - 结构化行（压缩、重试、本轮失败等，体量小，且带着这一轮的状态）。
+ * 过程明细（推理块、工具调用块、只有过程没有文字的消息）不下发，开启某一轮时再逐轮补取。
+ * 每轮被裁掉多少项、范围到哪，挂在**这一轮开头那条用户消息**的 `turnProcess` 上：App 用它
+ * 渲染「还有 N 项处理过程」，点开时按 startSeq / endSeq 回头要那一轮的事件。
+ *
+ * 窗口最老那一组没有起点（宿主按 maxMessages 截断时正好切在一轮中间）时整组丢掉：
+ * 半轮的消息没有用户消息打头，画出来就是「凭空冒出的 AI 发言」；它会被「加载更早」整轮补回。
+ *
+ * 三种「出卡」工具的调用块要留一条（定时任务 / 计划 / 扩展卡）：轮尾那几张卡是从工具块
+ * 现算的（`services/viewmodels/turn-tail-cards` 的 scheduleTailCard / planTailCard /
+ * extensionTailCard），整块丢掉会让卡在收口时凭空不见。它们体量很小。
+ * **新增一种轮尾卡时要同步这里**，否则那张卡只在「点开过程之后」才出现。
+ */
+const ENTRY_OUTCOME_TOOLS = new Set(['schedule_create', 'exit_plan_mode', 'extension_present']);
+
+/** 一轮的起点：用户自己发的消息，或定时任务唤醒的那一行。 */
+function isEntryTurnOpener(item) {
+  return Boolean(item) && typeof item === 'object'
+    && (item.role === 'user' || item.kind === 'wake');
+}
+
+function thinEntryMessages(items, options = {}) {
+  if (!Array.isArray(items) || items.length === 0) return items;
+  const hasMore = options.hasMore === true;
+  const groups = [];
+  let group = null;
+  for (const item of items) {
+    if (!item || typeof item !== 'object') continue;
+    if (isEntryTurnOpener(item) || group === null) {
+      group = { opener: isEntryTurnOpener(item) ? item : null, items: [] };
+      groups.push(group);
+    }
+    group.items.push(item);
+  }
+  const out = [];
+  for (let index = 0; index < groups.length; index += 1) {
+    const { opener, items: groupItems } = groups[index];
+    // 最老那半轮：没有用户消息当起点，整组丢掉（交给「加载更早」）。整页只有这一组时不丢 ——
+    // 那是「单独一轮就超过入口上限」的极端形状，丢了等于入口全空，宁可先摊开这一轮的文字。
+    if (opener === null && hasMore && index === 0 && groups.length > 1) continue;
+    let processCount = 0;
+    let hasKeptAssistant = false;
+    const kept = [];
+    for (const item of groupItems) {
+      // 结构化行与唤醒行原样保留：体量小，而且「已停止 / 处理失败 / 已压缩」是这一轮的状态。
+      if (isEntryTurnOpener(item) || item.kind !== undefined) {
+        kept.push(item);
+        continue;
+      }
+      if (item.role === 'user') { kept.push(item); continue; }
+      if (item.role !== 'assistant') { kept.push(item); continue; }
+      const blocks = Array.isArray(item.blocks) ? item.blocks : [];
+      const keptBlocks = [];
+      let stripped = 0;
+      for (const block of blocks) {
+        if (!block || typeof block !== 'object') continue;
+        // **每一个过程块都记进 processCount**，包括因为要出轮尾卡而留下的那几个 ——
+        // 这个数是给 App 的「这一轮一共多少项过程」用的，它按自己派生出的过程项递减；
+        // 只数「被摘掉的」会让保留的那几块扣不掉，App 那边提前减到 0、加载入口消失，
+        // 真正没载入的过程反倒没处点了。
+        // 空推理块在 deriveMessages 里就被丢掉了（`parseBlocks` 只留有文字的），这里也
+        // 不能数 —— 数了 App 就少扣一项，那一轮的加载入口永远差着数。
+        if (block.type === 'reasoning') {
+          if (typeof block.text === 'string' && block.text) { processCount += 1; stripped += 1; }
+          continue;
+        }
+        if (block.type === 'tool-call') {
+          processCount += 1;
+          if (typeof block.name === 'string' && ENTRY_OUTCOME_TOOLS.has(block.name)) keptBlocks.push(block);
+          else stripped += 1;
+          continue;
+        }
+        keptBlocks.push(block);
+      }
+      const hasText = typeof item.text === 'string' && item.text !== '';
+      const hasContent = hasText
+        || keptBlocks.some((block) => block.type === 'image' || block.type === 'tool-call')
+        || (Array.isArray(item.images) && item.images.length > 0)
+        || (Array.isArray(item.unavailableImages) && item.unavailableImages.length > 0);
+      if (!hasContent) continue;
+      kept.push(stripped > 0 ? { ...item, blocks: keptBlocks } : item);
+      hasKeptAssistant = true;
+    }
+    // 一轮里一条助手消息都没留下（整轮只在跑工具、被停止）：交付声明照样得留个落脚处。
+    if (opener !== null && !hasKeptAssistant) {
+      const presented = groupItems
+        .filter((item) => Array.isArray(item.presentedFiles) && item.presentedFiles.length > 0)
+        .flatMap((item) => item.presentedFiles);
+      if (presented.length > 0) {
+        const at = kept.indexOf(opener);
+        if (at >= 0) kept[at] = { ...opener, presentedFiles: presented };
+      }
+    }
+    if (opener !== null && processCount > 0 && Number.isSafeInteger(opener.seq)) {
+      const last = groupItems[groupItems.length - 1];
+      const endSeq = Number.isSafeInteger(last.seq) ? last.seq : opener.seq;
+      const at = kept.indexOf(opener);
+      if (at >= 0) {
+        kept[at] = {
+          ...kept[at],
+          turnProcess: {
+            startSeq: opener.seq,
+            endSeq,
+            count: processCount,
+            ...(typeof last.time === 'number' ? { endTime: last.time } : {}),
+          },
+        };
+      }
+    }
+    for (const item of kept) out.push(item);
+  }
+  return out;
+}
+
 // 信封拆解的唯一实现在 lib/mobile/envelope.js。这里只是为了让既有
 // `require('./history-derive.js').unwrap` 继续可用（对外导出面不变）。
 const { unwrap } = require('./envelope.js');
@@ -798,6 +955,7 @@ module.exports = {
   listTitle,
   presentedPathsOf,
   deriveMessages,
+  thinEntryMessages,
   unwrap,
   errorDetails,
   promptErrorObject,
@@ -805,6 +963,7 @@ module.exports = {
   capDiffText,
   normalizeResultDiffs,
   buildToolResultMap,
+  toolResultPatchesFor,
   parseBlocks,
   blocksToText,
   lastMessageOf,

package/lib/mobile/host-bridge/event-synthesis.js

@@ -10,7 +10,35 @@
  * 按 frame.payload 里的 type 分发，形状对上了它们一行都不用改。
  */
 
-const { openStream, warn } = require('./transport.js');
+const { gatewayOf, openStream, warn } = require('./transport.js');
+
+const warnedUnavailableContexts = new WeakSet();
+
+/**
+ * Keep the compatibility SSE alive when a host has no streaming gateway. The
+ * device stream also carries plugin-owned signals and heartbeats, so ending it
+ * here would cause reconnect churn and disable that independent data path.
+ */
+async function* unavailableHostStream(ctx, signal) {
+  const gateway = gatewayOf(ctx);
+  if (gateway && typeof gateway.stream === 'function') return false;
+
+  if (ctx && typeof ctx === 'object' && !warnedUnavailableContexts.has(ctx)) {
+    warnedUnavailableContexts.add(ctx);
+    warn(ctx, '宿主未提供 typertGateway.stream，跳过宿主事件并保持设备流空闲');
+  }
+
+  if (!signal || signal.aborted) return true;
+  await new Promise((resolve) => {
+    const finish = () => {
+      signal.removeEventListener('abort', finish);
+      resolve();
+    };
+    signal.addEventListener('abort', finish, { once: true });
+    if (signal.aborted) finish();
+  });
+  return true;
+}
 
 // ── 事件合成 ──────────────────────────────────────────────────────────────
 
@@ -339,8 +367,19 @@ function muxFrames(ctx, request, signal) {
   const sessionId = sessionHint(request);
   const payload = request && request.payload;
   return (async function* run() {
+    if (yield* unavailableHostStream(ctx, signal)) return;
     if (!sessionId) {
       yield* deviceFrames(ctx, signal);
+      // **设备级这一支不能跟着宿主那几条流一起结束**：这条 SSE 还捎带着插件自己产的
+      // 清单变更、正文水位与 15s 心跳（由 `handleDeviceStream` 直接写这条连接）。
+      // 迭代器一返回，SSE 立刻收尾，手机端只会看到「连几秒就断」：信号永远不「活着」，
+      // 兜底轮询降不下去，每次重连还要重放一遍水位（2026-10-24 现场：17 帧后 loopEnded）。
+      // 单会话那一支不适用 —— 会话结束了就该收尾。
+      if (!signal || signal.aborted) return;
+      await new Promise((resolve) => {
+        signal.addEventListener('abort', resolve, { once: true });
+        if (signal.aborted) resolve();
+      });
       return;
     }
     const address = sessionAddress(payload);