dsh-mobile-plugin 0.5.24 → 0.5.27

package/lib/mobile/phone/confirm.js

@@ -0,0 +1,189 @@
+'use strict';
+
+/**
+ * 付款确认：把「这一下点下去要花钱」送去宿主已有的审批通道，等人点了「同意」再放行。
+ *
+ * ## 为什么复用审批通道，而不是自己推一张卡
+ *
+ * 手机上那张确认卡、用户点按钮、结论交回来，这条链在 0.2.x 上已经由审批桥
+ * （`mobile/approvals.js`）铺好了：它 `prepend` 了宿主的 `approval/request` 钩子，钩子一响
+ * 就把卡推给正在看这条会话的手机，用户点了同意再 `settle` 回钩子的 promise。我们自己再造
+ * 一条推卡的路，等于让手机上同时存在两套确认卡、两套回答接口，谁先答都说不清。
+ *
+ * 所以这里只做一件事：以 `ctx.get('approval')` 的身份发起一次真正的审批请求。宿主的
+ * `ApprovalService.request()` 会把这次的 `approval/asked` / `approval/decided` 记进会话日志
+ * （审计里就是这么写的），再走一遍 `approval/request` waterfall —— 审批桥在那一步把卡交给
+ * 手机。拿回 `allowed-once` 才等于「用户就这一下点了同意」。
+ *
+ * ## 为什么绝对不会挂死
+ *
+ * 三处都可能「永远没人答」：手机没在看（卡没有去处）、用户在别处把这一轮取消了、钩子上
+ * 下游是个不回答的转发器。前两处各自有出路（下面判 unavailable / 跟着 signal 取消），
+ * 第三处靠一道自己的硬期限兜底：到点就回 `unavailable`，且先 `abort()` 让宿主那头把
+ * 挂起的审批一起收掉。工具调用挂在这里，模型的整轮就会一直转下去 —— 那比「没确认」
+ * 严重得多，所以宁可超时也不要等。
+ *
+ * ## 三个返回值
+ *
+ * `allowed-once`（就这一次可以） / `rejected`（问过了，答案是拒绝或取消） /
+ * `unavailable`（压根没能问到人）。调用点只认 `allowed-once`，别的一律不执行。
+ */
+
+/**
+ * 一次确认最多等多久。
+ *
+ * 够用户拿起手机看一眼再点同意，又不至于让模型的这一发停在那里。之所以不设「等到有人答
+ * 为止」：卡没推到人手上（手机没在看这条会话、用户把 App 切走了）时，等的是一个永远不来
+ * 的答案；而一次工具调用挂着一分钟以上，在模型那边就是「卡住了」。
+ */
+const APPROVAL_TIMEOUT_MS = 90_000;
+
+/**
+ * 这一步要不要人确认。判定仍由 `irreversible.js` 给，这里只挑出付款 / 下单那一类 ——
+ * 发送、提交、删除虽然也收不回来，但它们是这条任务本来就该做的事，每一步都拦会让
+ * 「让它发条消息」变成一连串确认框。
+ */
+function needsConfirmation(judged) {
+  return Boolean(judged && judged.irreversible === true && judged.kind === 'payment');
+}
+
+/**
+ * 宿主的审批服务。`ctx.get()` 而不是写进 inject：这个服务的装配顺序跟手机那几条路由无关，
+ * 注入一个当前宿主版本里没有的服务会把整个插件装载拖垮（与 `mobile/host-web.js` 同一口径）。
+ */
+function approvalOf(ctx) {
+  if (!ctx) return null;
+  try {
+    if (typeof ctx.get === 'function') {
+      const service = ctx.get('approval');
+      if (service && typeof service.request === 'function') return service;
+    }
+  } catch { /* 服务没装就往下试属性那一种写法 */ }
+  const direct = ctx.approval;
+  return direct && typeof direct.request === 'function' ? direct : null;
+}
+
+/**
+ * 这条会话的 agent。审批请求要求请求方带着自己的会话（`ApprovalService.request()` 要往
+ * 那条会话里记审计事件，还要看它的 `approval/policy`），拿不到就等于没人能答。
+ *
+ * 工具层手上一般已经握着这次调用的 agent，优先用它 —— 比按 id 去服务里捞更准，
+ * 子代理那条路径上 `agents.get(childSessionId)` 本来就取不到。
+ */
+function agentOf(ctx, sessionId, hint) {
+  if (hint && hint.session) return hint;
+  if (!ctx || typeof ctx.get !== 'function' || !sessionId) return null;
+  try {
+    const agents = ctx.get('agents');
+    if (agents && typeof agents.get === 'function') return agents.get(sessionId) || null;
+  } catch { /* 没这个服务就没有别的路可走 */ }
+  return null;
+}
+
+/** 卡片上那句话：做了什么都写进去，用户看着手机就能判断这一下该不该点。 */
+function summaryText(summary, amountText) {
+  const parts = [];
+  const head = typeof summary === 'string' ? summary.trim().slice(0, 200) : '';
+  const amount = typeof amountText === 'string' ? amountText.trim().slice(0, 60) : '';
+  if (head) parts.push(head);
+  if (amount) parts.push(`金额 ${amount}`);
+  return parts.join('；') || '操作手机：这一步涉及付款 / 下单，需要你确认';
+}
+
+/** 宿主那套结论词表收成一个三选一。取消与拒绝对调用点是一回事：都别执行。 */
+function normalizeOutcome(outcome) {
+  if (outcome === 'allowed-once') return 'allowed-once';
+  if (outcome === 'rejected' || outcome === 'cancelled') return 'rejected';
+  return 'unavailable';
+}
+
+/**
+ * 发起一次确认并等结论。
+ *
+ * @param {object} ctx 插件上下文（要能 `get('approval')`）
+ * @param {object} options
+ * @param {string} options.sessionId 这条对话
+ * @param {string} [options.summary] 卡片摘要：这一步在做什么
+ * @param {string} [options.amountText] 金额一类的字样，有就一起上卡
+ * @param {object} [options.agent] 工具层手上这次调用的 agent（有就用，没有按会话捞）
+ * @param {string} [options.toolName] 卡片上那个「工具 X」的名字
+ * @param {string} [options.callId] 与这一步的工具调用对上，便于手机与桌面对同一张卡
+ * @param {AbortSignal} [options.signal] 这一轮工具的取消信号（用户取消整轮时跟着结束）
+ * @param {boolean} [options.watching] 有没有手机在看着这条会话；明确为 false 就不必问了
+ * @param {number} [options.timeoutMs] 覆盖默认期限：调用方自己的预算比三分钟还短时用它，
+ *   确认不该比整条调用活得久
+ * @returns {Promise<'allowed-once'|'rejected'|'unavailable'>}
+ */
+async function requestConfirmation(ctx, options) {
+  const opts = options && typeof options === 'object' ? options : {};
+  const sessionId = typeof opts.sessionId === 'string' ? opts.sessionId.trim() : '';
+  // 认不出是哪条对话：卡片没有归属，宿主也会因为「没有开着的轮次」拒绝记账。
+  if (!sessionId) return 'unavailable';
+  // 没有手机在看：卡推不出去，问也白问。如实说「没问到」，别把这一步挂在那儿。
+  if (opts.watching === false) return 'unavailable';
+
+  const approval = approvalOf(ctx);
+  if (!approval) return 'unavailable';
+  const agent = agentOf(ctx, sessionId, opts.agent);
+  if (!agent || !agent.session) return 'unavailable';
+
+  const reason = summaryText(opts.summary, opts.amountText);
+  const controller = new AbortController();
+  const parent = opts.signal;
+  const onAbort = () => controller.abort();
+  if (parent && typeof parent.addEventListener === 'function') {
+    // 工具已经被取消了就别再发一张卡出来：那一轮已经没有人在等这个答案。
+    if (parent.aborted) return 'unavailable';
+    parent.addEventListener('abort', onAbort, { once: true });
+  }
+
+  const waitMs = Number.isFinite(opts.timeoutMs) && opts.timeoutMs > 0
+    ? Math.min(APPROVAL_TIMEOUT_MS, Math.round(opts.timeoutMs))
+    : APPROVAL_TIMEOUT_MS;
+  let timer = null;
+  // 硬期限与请求本身赛跑：即便宿主那头不理会 abort，这里也一定在期限内交出结论。
+  const deadline = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      resolve('unavailable');
+    }, waitMs);
+    if (typeof timer.unref === 'function') timer.unref();
+  });
+
+  try {
+    const asked = Promise.resolve()
+      .then(() => approval.request({
+        agent,
+        ...(typeof opts.toolName === 'string' && opts.toolName ? { toolName: opts.toolName } : {}),
+        ...(typeof opts.callId === 'string' && opts.callId ? { callId: opts.callId } : {}),
+        reason,
+        // 桌面与手机上的卡片都优先用这句（审批桥的 `displayReasonOf` 认 zh）。
+        displayReason: { zh: reason },
+        signal: controller.signal,
+      }))
+      // 宿主在「没有开着的轮次」「策略是 never」这些情况下会抛，一律折算成没问到。
+      .then((outcome) => normalizeOutcome(outcome), () => 'unavailable');
+    return await Promise.race([asked, deadline]);
+  } catch {
+    return 'unavailable';
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (parent && typeof parent.removeEventListener === 'function') parent.removeEventListener('abort', onAbort);
+  }
+}
+
+/** 确认没拿到时给模型的那句话。两种没拿到的原因要分开说，模型据此决定要不要请用户回来。 */
+function blockedMessage(outcome, what) {
+  const step = typeof what === 'string' && what ? what : '这一步';
+  if (outcome === 'rejected') {
+    return `${step}是付款 / 下单，需要用户确认；用户没有同意（或者这一轮被取消了），所以没有执行。把这件事如实告诉用户，别自己重试。`;
+  }
+  return `${step}是付款 / 下单，需要用户确认，但刚才没能把确认卡送到用户手上（手机没有在看这条对话，或者确认通道不可用），所以没有执行。请用户回到这条对话、在手机上看着屏幕再试一次；也可以让用户自己点这一下。`;
+}
+
+module.exports = {
+  needsConfirmation,
+  requestConfirmation,
+  blockedMessage,
+  APPROVAL_TIMEOUT_MS,
+};

package/lib/mobile/phone/index.js

@@ -15,8 +15,12 @@
 
 const { createPhoneService } = require('./service.js');
 const { installPhoneTools } = require('./tools.js');
+const { installRouteHint } = require('./route-hint.js');
 const { listDevices, describeDevice } = require('./routes.js');
 const binding = require('./binding.js');
+const pacing = require('./pacing.js');
+const irreversible = require('./irreversible.js');
+const routesMemory = require('./routes-memory.js');
 
 /**
  * @param {object} ctx 插件上下文
@@ -52,12 +56,28 @@ function mountPhoneControl(ctx, deps) {
     if (!message.includes('without inject')) throw error;
   }
 
+  // 只读的历史路线查询工具：单独一路注册，不经过 tools.js 那套步数/死循环守卫（它不发动作）。
+  // 同一口径：缺 tools 注入的 profile 只少这一条，不要把整块装配掀掉。
+  try {
+    installRouteHint(ctx);
+  } catch (error) {
+    const message = error && error.message ? error.message : String(error);
+    if (!message.includes('without inject')) throw error;
+  }
+
   ctx.effect(() => () => service.close(), `${deps.name || 'dsh-mobile-plugin'}: phone control`);
   // 路由表那边要凭据库与实例号来报设备名，而它只拿得到这个服务（装配层只转交一个对象）。
   // 挂在服务上而不是再走一遍依赖注入：多一处注入就多一处能不同步的地方。
   service.credentials = deps.credentials;
   service.instanceId = deps.instanceId;
+  // 节奏与不可逆判定是纯函数模块，挂到服务上，工具层拿同一个服务就能顺手取到，
+  // 省得再开一路依赖注入 —— 少一处注入就少一处能不同步的地方。
+  service.pacing = pacing;
+  service.irreversible = irreversible;
+  // 成功路线记忆：工具层在结局判定为成功后调 `service.routesMemory.record(...)`，查询走
+  // `phone_route_hint`。挂到服务上，与 pacing / irreversible 同一口径，少一路依赖注入。
+  service.routesMemory = routesMemory;
   return service;
 }
 
-module.exports = { mountPhoneControl, binding };
+module.exports = { mountPhoneControl, binding, pacing, irreversible, routesMemory };

package/lib/mobile/phone/irreversible.js

@@ -0,0 +1,146 @@
+'use strict';
+
+/**
+ * 不可逆动作判定：纯函数，只回答「这一下点下去是不是收不回来」，不做任何动作。
+ *
+ * 给 tools 层做单步提示、给 batch 做熔断用。判据刻意窄：只有 **tap** 且能读到「点的是哪个
+ * 按钮的文字」才算数。读不到文字（只有 ref、只有坐标而没 target）就判不了，宁可放过也不
+ * 误判 —— 把整屏文字当成这一下的目标，会把「聊天页里恰好有『删除』两个字」判成删除，
+ * 那比漏判更烦人（每次点都停下来问）。
+ *
+ * 词表繁简两边都认，加上英文的 send / submit / order / pay / buy / delete。分成五类，
+ * 但输出的 kind 只有 payment / submit / send / delete / none —— 下单、购买、付款这类收钱的
+ * 都归 payment（对熔断来说它们是一回事：都花钱）。
+ *
+ * 已知局限：这是词表兜底，不看语义。订单状态一类的文字（「待付款」「付款成功」「订单记录」）
+ * 里也有付款 / 订单词，会被当成对外动作 —— 方向是「宁可多停一次」，不会误执行。
+ */
+
+/** 只有点屏幕才有「点的是哪个按钮」这回事。 */
+const TAP_ACTIONS = new Set(['tap']);
+
+/**
+ * 词表按 kind 分组，顺序即优先级：先看样子最重的付款 / 下单，再提交、发送、删除。
+ * 中文按包含判；纯英文词按单词边界判，免得 order 在 reorder、delete 在 undelete 里误命中。
+ */
+const WORD_TABLE = [
+  {
+    kind: 'payment',
+    words: [
+      '支付', '付款', '买单', '买單', '下单', '下單', '购买', '購買',
+      '结算', '結算', '订单', '訂單', '收银台', '收銀台',
+      'pay', 'payment', 'order', 'buy', 'purchase', 'checkout',
+    ],
+  },
+  {
+    kind: 'submit',
+    words: ['提交', '确认提交', '確認提交', '送出', 'submit'],
+  },
+  {
+    kind: 'send',
+    words: ['发送', '傳送', '传送', '发布', '發布', '发表', '發表', 'send', 'post'],
+  },
+  {
+    kind: 'delete',
+    words: ['删除', '刪除', '清空', '移除', 'delete', 'remove', 'clear'],
+  },
+];
+
+/** 这些字段可能装着「点的是哪个按钮」的文字；按顺序取，取到非空就用。 */
+const LABEL_FIELDS = [
+  'text', 'target', 'label', 'name', 'description', 'desc',
+  'contentDescription', 'title', 'content', 'value',
+];
+
+function isEnglishWord(word) {
+  return /^[a-z]+$/.test(word);
+}
+
+/** 在一个文字里找第一个命中的词，返回 {kind, word} 或 null。 */
+function matchLabel(label) {
+  const lower = label.toLowerCase();
+  for (const group of WORD_TABLE) {
+    for (const word of group.words) {
+      if (isEnglishWord(word)) {
+        // 英文按整词匹配，避免 order 命中 reorder / preorder。
+        if (new RegExp(`\\b${word}\\b`, 'i').test(lower)) return { kind: group.kind, word };
+      } else if (label.includes(word)) {
+        return { kind: group.kind, word };
+      }
+    }
+  }
+  return null;
+}
+
+/** 从参数里能读到的、像「被点元素文字」的那几条。 */
+function labelsOf(args) {
+  const out = [];
+  for (const key of LABEL_FIELDS) {
+    const value = args[key];
+    if (typeof value === 'string') {
+      const text = value.trim();
+      if (text) out.push(text);
+    }
+  }
+  return out;
+}
+
+/** 一个孤零零的短串才可能是按钮文字；长段多行的是整屏，不能当目标。 */
+function looksLikeLabel(text) {
+  const trimmed = text.trim();
+  if (!trimmed || trimmed.length > 32) return false;
+  return !/[\r\n]/.test(trimmed);
+}
+
+function none(reason) {
+  return { irreversible: false, kind: 'none', reason };
+}
+
+/**
+ * judge({ action, args, screenText }) → { irreversible, kind, reason }。
+ *
+ * `screenText` 只在「既没 ref / 坐标、也没有任何文字字段」且它本身像个按钮短串时才当目标文字；
+ * 有 ref 或坐标却没有文字时一律判不了 —— 这是「ref 点按不误判」那条要求的落点。
+ */
+function judge(input) {
+  const { action, args, screenText } = input || {};
+  const a = args && typeof args === 'object' ? args : {};
+
+  if (typeof action !== 'string' || !TAP_ACTIONS.has(action)) {
+    return none('只判 tap：别的动作没有「点的是哪个按钮」这回事');
+  }
+
+  const hasRef = typeof a.ref === 'string' && a.ref.trim() !== '';
+  const hasPoint = Number.isFinite(a.x) && Number.isFinite(a.y);
+  let labels = labelsOf(a);
+
+  if (labels.length === 0) {
+    if (hasRef || hasPoint) {
+      return none('只有 ref / 坐标、没有说话文字，判定不了');
+    }
+    if (typeof screenText === 'string' && looksLikeLabel(screenText)) {
+      labels = [screenText.trim()];
+    }
+  }
+
+  if (labels.length === 0) return none('没有可判的文字');
+
+  for (const label of labels) {
+    const hit = matchLabel(label);
+    if (hit) {
+      return {
+        irreversible: true,
+        kind: hit.kind,
+        reason: `「${label}」命中不可逆词「${hit.word}」`,
+      };
+    }
+  }
+  return none('没有命中不可逆词表');
+}
+
+module.exports = {
+  judge,
+  // 下面几个给守卫直接用真值表，不重复实现匹配逻辑。
+  WORD_TABLE,
+  matchLabel,
+};

package/lib/mobile/phone/pacing.js

@@ -0,0 +1,173 @@
+'use strict';
+
+/**
+ * 操作节奏：决定「动作之间停多久」「对外动作之间至少隔多久」。
+ *
+ * 三档 fast / standard / human，默认 standard，存在插件设置里（与播报开关同一处：
+ * `<DSH_HOME>/storages/mobile-plugin/phone-pacing.json`）。这里只给数字，**自己不 sleep**：
+ * 真正等待的是执行动作的那一层，本模块一睡就把测试和宿主都拖住。
+ *
+ * 对外动作的间隔照 Mika 的 OutwardPacing：最近 30 分钟内做得越多，间隔越往上涨，
+ * 上下限各 +0.5s / +1s，封顶 30s。第一次不额外等 —— 一条消息本来就要花那几个动作，
+ * 从第一条起就硬等只会让人以为手机卡了。
+ *
+ * 落盘失败不抛：节奏是锦上添花，写不进去也要让这一轮按新节奏继续跑。
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { dshHome } = require('../../shared/paths');
+
+/** 可选的三档。 */
+const MODES = ['fast', 'standard', 'human'];
+const DEFAULT_MODE = 'standard';
+
+/** 对外动作计数的时间窗：只算最近半小时做过的。 */
+const OUTWARD_WINDOW_MS = 30 * 60 * 1000;
+/** 每多做一次对外动作，间隔下限 / 上限各加这么多毫秒。 */
+const PER_ACTION_MS = [500, 1000];
+/** 间隔封顶，再密也不等超过半分钟。 */
+const MAX_OUTWARD_MS = 30 * 1000;
+
+/**
+ * 三档的具体数字。
+ *
+ * `betweenActionsMs`：同一轮里相邻两个动作之间的停留范围；
+ * `outwardMinMs`：两个对外动作（发送 / 提交 / 下单这类）之间的最小间隔范围，起点也会被
+ *   noteOutward 按次数往上加；
+ * `typingChunkMs`：一段一段打字时每段之间停多久（fast 一次写全文，所以是 0）。
+ */
+const TABLES = {
+  fast: {
+    betweenActionsMs: [0, 0],
+    outwardMinMs: [0, 0],
+    typingChunkMs: 0,
+  },
+  standard: {
+    betweenActionsMs: [500, 1200],
+    outwardMinMs: [8000, 20000],
+    typingChunkMs: 40,
+  },
+  human: {
+    betweenActionsMs: [1000, 2000],
+    outwardMinMs: [15000, 30000],
+    typingChunkMs: 90,
+  },
+};
+
+function settingsFile() {
+  return path.join(dshHome(), 'storages', 'mobile-plugin', 'phone-pacing.json');
+}
+
+/** 把大小写 / 空白各异的输入收成一个合法档名；认不出返回 null。 */
+function normalizeMode(mode) {
+  if (typeof mode !== 'string') return null;
+  const m = mode.trim().toLowerCase();
+  return MODES.includes(m) ? m : null;
+}
+
+/** 上一轮写盘失败时记住的档名：写不进去也不能让调用方读回旧值。 */
+let memoryMode = null;
+
+function readStoredMode() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(settingsFile(), 'utf8'));
+    return normalizeMode(raw && raw.mode);
+  } catch {
+    // 文件不存在 / 读坏 / 字段不对都当没设过，走默认档。
+    return null;
+  }
+}
+
+/** 当前档。读不到就是 standard（坏文件同样落在这里）。 */
+function get() {
+  if (memoryMode) return memoryMode;
+  return readStoredMode() || DEFAULT_MODE;
+}
+
+/**
+ * 改成某一档并落盘。非法档名是调用方写错了，直接抛；写盘失败只记住内存值、不抛。
+ * 返回改后的当前档，方便调用方直接回给界面。
+ */
+function set(mode) {
+  const m = normalizeMode(mode);
+  if (!m) throw new RangeError(`未知的操作节奏：${String(mode)}（可选 ${MODES.join(' / ')}）`);
+  try {
+    const file = settingsFile();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify({ mode: m }, null, 2)}\n`);
+    memoryMode = null;
+  } catch {
+    memoryMode = m;
+  }
+  return m;
+}
+
+/** 某一档的数字。认不出的档按 standard 给，避免调用方拿到 undefined 再炸开。 */
+function paceFor(mode) {
+  const table = TABLES[normalizeMode(mode) || DEFAULT_MODE];
+  return {
+    betweenActionsMs: [...table.betweenActionsMs],
+    outwardMinMs: [...table.outwardMinMs],
+    typingChunkMs: table.typingChunkMs,
+  };
+}
+
+/** 最近做过的对外动作时间点（升序）。只有一台手机，不按包名分组。 */
+let outwardAt = [];
+
+function prune(now) {
+  while (outwardAt.length > 0 && now - outwardAt[0] > OUTWARD_WINDOW_MS) outwardAt.shift();
+}
+
+/**
+ * 记一次「现在要做对外动作」，返回这一发至少要等多少毫秒。
+ *
+ * 返回的是**最小**值（下限），不是随机值：调用方自己决定要不要在这个余量之外再多停。
+ * 第一次对外动作返回 0；之后按最近 30 分钟已做的次数把下限往上抬（每次 +0.5s），
+ * 封顶 30s；如果从上一次到现在已经隔够了，返回 0。
+ */
+function noteOutward(nowMs) {
+  const now = Number.isFinite(nowMs) ? nowMs : Date.now();
+  const pace = paceFor(get());
+  prune(now);
+
+  let minWaitMs = 0;
+  const baseLowMs = pace.outwardMinMs[0];
+  // fast 档下限是 0：不计数、不加码，永远不等（与 Mika 的 Off 一个意思）。
+  if (outwardAt.length > 0 && baseLowMs > 0) {
+    const extra = outwardAt.length - 1;
+    const required = Math.min(baseLowMs + extra * PER_ACTION_MS[0], MAX_OUTWARD_MS);
+    const elapsed = now - outwardAt[outwardAt.length - 1];
+    minWaitMs = Math.max(0, required - elapsed);
+  }
+
+  outwardAt.push(now);
+  return minWaitMs;
+}
+
+/** 单测用：清掉对外动作的计数。 */
+function resetOutwardForTest() {
+  outwardAt = [];
+}
+
+/** 单测用：把内存里「写盘失败留下的档」也清掉。 */
+function resetCacheForTest() {
+  memoryMode = null;
+}
+
+module.exports = {
+  get,
+  set,
+  paceFor,
+  noteOutward,
+  resetOutwardForTest,
+  resetCacheForTest,
+  settingsFile,
+  MODES,
+  DEFAULT_MODE,
+  OUTWARD_WINDOW_MS,
+  PER_ACTION_MS,
+  MAX_OUTWARD_MS,
+};