dsh-mobile-use 1.0.0 → 1.0.3

package/stream.js

@@ -211,6 +211,8 @@ function containsIdr(chunk) {
 
 /** 最后一个观众走后，录屏再活这么久：侧栏重载/切页回来时能立刻出画面，不用等 2 秒起流。 */
 const IDLE_GRACE_MS = 20000
+/** 本进程的随机标识：设备端 pid 文件名带上它，多开/重启不会互相认领对方的录屏。 */
+const RUN_TAG = Math.random().toString(36).slice(2, 8)
 
 export class LiveStream {
   /**
@@ -224,10 +226,14 @@ export class LiveStream {
     this.height = options.height ?? 1280
     this.bitrate = options.bitrate ?? 4_000_000
     this.recorder = null
+    /* 设备端 pid 文件名：停止时只按这个 pid 精确收尾，绝不 pkill 别人在录的屏。 */
+    this.recorderPidFile = ''
     this.remuxer = null
     this.stopping = false
     this.restartTimer = null
     this.clients = new Set()
+    /* 由 mirror 装上：问一句「镜像那边还有人在看吗」，空闲回收时用。 */
+    this.stillWanted = null
     this.init = null
     this.pending = Buffer.alloc(0)
     /** 待拼的 box 字节。 @type {Buffer} */
@@ -307,11 +313,17 @@ export class LiveStream {
   /** 有人要看 JPEG 帧时才起解码器：不看不花 CPU。 @returns {boolean} 是否可用（解码器起来后 300 ms 内有帧）。 */
   enableJpeg() {
     this.jpegWantedAt = Date.now()
-    if (this.jpegChild !== null) return true
+    /* 只看帧（/frame 轮询）也会起录屏：没人再来取帧就按同一套宽限停掉，否则设备一直在录。
+       必须排在这里之后：start() 会清掉空闲定时器（它以为有人回来了）。 */
+    if (this.jpegChild !== null) {
+      this.scheduleIdleStop()
+      return true
+    }
     if (this.stopping) return false
     if (Date.now() - this.jpegOpenAt < 2000) return false
     this.jpegOpenAt = Date.now()
     this.start()
+    this.scheduleIdleStop()
     LiveStream.reapJpeg(this.serial)
     const child = spawn('ffmpeg', [
       '-hide_banner', '-loglevel', 'error',
@@ -330,7 +342,7 @@ export class LiveStream {
     if (!(globalThis.__dshAdbJpeg.get(this.serial) instanceof Set)) globalThis.__dshAdbJpeg.set(this.serial, new Set())
     globalThis.__dshAdbJpeg.get(this.serial).add(child)
     child.on('exit', () => globalThis.__dshAdbJpeg.get(this.serial)?.delete(child))
-    child.stdout.on('data', (chunk) => this.feedJpeg(chunk))
+    child.stdout.on('data', (chunk) => this.guard('feed-jpeg', () => this.feedJpeg(chunk)))
     child.stderr.on('data', (buf) => {
       const text = String(buf).trim()
       if (text !== '') this.error = text.slice(-300)
@@ -394,12 +406,24 @@ export class LiveStream {
   }
 
   /** 观众都走了：留一段宽限再停，重开侧栏就不用重新起流。 @returns {void} */
-  scheduleIdleStop() {
+  scheduleIdleStop(delayMs = IDLE_GRACE_MS) {
     if (this.idleTimer !== null) return
-    this.idleTimer = setTimeout(() => {
+    this.idleTimer = setTimeout(() => this.guard('idle-stop', () => {
       this.idleTimer = null
-      if (this.clients.size === 0 && this.waiting.size === 0 && Date.now() - this.jpegWantedAt > IDLE_GRACE_MS) this.stop()
-    }, IDLE_GRACE_MS)
+      if (this.clients.size > 0 || this.waiting.size > 0) return
+      /* 只看帧的人每隔一秒来一次，取帧时间戳会被不断刷新；差多少补多少，不重复排满宽限。 */
+      /* 镜像那边还有常连观看者（/live）时不能停：它不走 clients，只靠这个回调说话。 */
+      if (typeof this.stillWanted === 'function' && this.stillWanted()) {
+        this.scheduleIdleStop()
+        return
+      }
+      const left = IDLE_GRACE_MS - (Date.now() - this.jpegWantedAt)
+      if (left > 250) {
+        this.scheduleIdleStop(left)
+        return
+      }
+      this.stop()
+    }), Math.max(0, delayMs))
     this.idleTimer.unref?.()
   }
 
@@ -429,6 +453,8 @@ export class LiveStream {
     this.intentional = true
     const child = this.recorder
     this.recorder = null
+    /* 换 IDR 前先收掉自己这次的设备端录屏，只按 pid 杀，不碰别人的。 */
+    this.killOwnRecorder()
     this.init = null
     this.error = ''
     this.lastKeyChunks = []
@@ -445,17 +471,62 @@ export class LiveStream {
   }
 
   /**
-   * 设备端兜底清理：本地 adb 被杀掉后，设备上的 screenrecord 还会活到 time-limit，
-   * 占着编码器让下一次录屏直接失败（another recording is running）。
+   * 设备端精确收尾：按启动时写下的 pid 文件找到「自己这一次」的 screenrecord，
+   * 核对进程名还是 screenrecord 再 kill。pid 拿不到就不杀（只记日志），
+   * 让它按 time-limit 自己结束，也不会误伤别人的录屏。
+   * @param {string} [pidFile] - pid 文件；默认用当前这次录屏的。
    * @returns {void}
    */
-  killStale() {
+  killOwnRecorder(pidFile = this.recorderPidFile) {
+    const safe = String(pidFile).replace(/[^\w./-]/g, '')
+    if (safe === '') {
+      this.debug('kill-device skipped: no pid file')
+      return
+    }
+    if (this.recorderPidFile === pidFile) this.recorderPidFile = ''
+    const script = `p='${safe}'; r=$(cat "$p" 2>/dev/null); rm -f "$p"; if [ -n "$r" ] && [ "$(cat /proc/$r/comm 2>/dev/null)" = 'screenrecord' ]; then kill -9 "$r"; echo killed:$r; else echo skip:$r; fi`
     try {
-      const child = spawn(this.adbPath, ['-s', this.serial, 'shell', 'pkill -f screenrecord'], { stdio: 'ignore' })
+      const child = spawn(this.adbPath, ['-s', this.serial, 'shell', script], { stdio: ['ignore', 'pipe', 'ignore'] })
+      let out = ''
+      child.stdout?.on('data', (chunk) => { out = (out + String(chunk)).slice(-120) })
+      child.on('exit', () => this.debug('kill-device ' + (out.trim() || 'no-reply')))
+      child.on('error', () => this.debug('kill-device spawn-error'))
+      child.unref?.()
+    } catch {
+      this.debug('kill-device threw')
+    }
+  }
+
+  /**
+   * 正常到时长退出的清理：只删自己的 pid 文件，不 kill（pid 可能已被别人复用）。
+   * @returns {void}
+   */
+  dropRecorderPidFile() {
+    const pidFile = this.recorderPidFile
+    this.recorderPidFile = ''
+    const safe = String(pidFile).replace(/[^\w./-]/g, '')
+    if (safe === '') return
+    try {
+      const child = spawn(this.adbPath, ['-s', this.serial, 'shell', 'rm', '-f', safe], { stdio: 'ignore' })
       child.on('error', () => {})
       child.unref?.()
     } catch {
-      /* 清理失败不影响主流程 */
+      /* 清不掉就留着，几十字节，不影响主流程 */
+    }
+  }
+
+  /**
+   * 定时器与子进程回调的兜底：这里抛出的异常会冒到 host 顶层，整个 DSH 以 1 退出
+   * （2026-10-27 `this.killStale` 两次事故），所以宁可这一步不做也要写日志。
+   * @param {string} where - 出问题的路径，写进 stream-debug.log。
+   * @param {() => void} run - 真正要做的事。
+   * @returns {void}
+   */
+  guard(where, run) {
+    try {
+      run()
+    } catch (error) {
+      this.debug(`guard ${where}: ${String(error?.stack ?? error).slice(0, 400)}`)
     }
   }
 
@@ -475,30 +546,28 @@ export class LiveStream {
   spawnRecorder() {
     if (this.stopping) return
     const size = `${this.width}x${this.height}`
-    const args = [
-      '-s', this.serial, 'exec-out', 'screenrecord',
-      '--output-format=h264',
-      `--time-limit=${RECORD_LIMIT}`,
-      `--size=${size}`,
-      `--bit-rate=${this.bitrate}`,
-      '-',
-    ]
+    this.sessions += 1
+    const safeSerial = this.serial.replace(/[^\w.-]/g, '_')
+    const pidFile = `/data/local/tmp/dsh-mobile-use-stream-${safeSerial}-${RUN_TAG}-${this.sessions}.pid`
+    this.recorderPidFile = pidFile
+    /* exec 让 shell 的 pid 就是 screenrecord 的 pid：停止时按这个 pid 精确 kill。 */
+    const command = `sh -c 'echo $$ > ${pidFile}; exec screenrecord --output-format=h264 --time-limit=${RECORD_LIMIT} --size=${size} --bit-rate=${this.bitrate} -'`
+    const args = ['-s', this.serial, 'exec-out', command]
     const child = spawn(this.adbPath, args, { stdio: ['ignore', 'pipe', 'pipe'] })
     this.recorder = child
-    this.sessions += 1
     this.debug('spawn')
     let stderr = ''
     child.stderr.setEncoding('utf8')
     child.stderr.on('data', (chunk) => {
       stderr = (stderr + chunk).slice(-2000)
     })
-    child.stdout.on('data', (chunk) => this.feedRaw(chunk))
-    child.on('error', (error) => {
+    child.stdout.on('data', (chunk) => this.guard('feed-raw', () => this.feedRaw(chunk)))
+    child.on('error', (error) => this.guard('recorder-error', () => {
       this.error = String(error?.message ?? error)
       this.recorder = null
       this.scheduleRestart()
-    })
-    child.on('exit', (code) => {
+    }))
+    child.on('exit', (code) => this.guard('recorder-exit', () => {
       if (this.recorder === child) this.recorder = null
       this.closeRemuxer()
       if (this.stopping) return
@@ -512,23 +581,25 @@ export class LiveStream {
       }
       /* 正常到时长或编码器重启都走这里：换一份 moov，前端按 INIT 帧重建 MediaSource。 */
       if (this.clients.size > 0) this.broadcast(packFrame(FRAME_END, Buffer.alloc(0)))
+      /* 录满时长正常退出：screenrecord 已经不在了，只删自己的 pid 文件（不 kill，免 pid 复用误伤）。 */
+      if (code === 0) this.dropRecorderPidFile()
       if (wasIntentional && this.stopping) return
       this.scheduleRestart()
-    })
+    }))
   }
 
   /** 到点自动续上，避免中断超过半秒。 @returns {void} */
   scheduleRestart() {
     if (this.stopping || this.restartTimer !== null) return
     if (this.clients.size === 0 && this.waiting.size === 0) return
-    this.restartTimer = setTimeout(() => {
+    this.restartTimer = setTimeout(() => this.guard('restart', () => {
       this.restartTimer = null
       if (!this.stopping && (this.clients.size > 0 || this.waiting.size > 0)) {
-        /* 上一轮可能是被 SIGKILL 的 adb：先清掉设备端残留，再开新录屏。 */
-        if (this.sessions > 0) this.killStale()
+        /* 上一轮可能是被 SIGKILL 的 adb：先按自己的 pid 清掉设备端残留，再开新录屏。 */
+        this.killOwnRecorder()
         this.spawnRecorder()
       }
-    }, 120)
+    }), 120)
     this.restartTimer.unref?.()
   }
 
@@ -587,7 +658,7 @@ export class LiveStream {
       '-f', 'mp4', 'pipe:1',
     ], { stdio: ['pipe', 'pipe', 'pipe'] })
     this.remuxer = child
-    child.stdout.on('data', (chunk) => this.feedMp4(chunk))
+    child.stdout.on('data', (chunk) => this.guard('feed-mp4', () => this.feedMp4(chunk)))
     child.stderr.on('data', (buf) => {
       const text = String(buf).trim()
       if (text !== '') this.error = text.slice(-300)
@@ -776,6 +847,8 @@ export class LiveStream {
     this.closeJpeg()
     const child = this.recorder
     this.recorder = null
+    /* 本地杀进程不等于设备端停了：先按自己记下的 pid 收掉设备端录屏，否则下一次开流会撞上。 */
+    this.killOwnRecorder()
     if (child !== null) {
       try {
         child.kill('SIGKILL')
@@ -785,8 +858,6 @@ export class LiveStream {
     }
     this.intentional = true
     this.stopping = false
-    /* 本地杀进程不等于设备端停了：显式收掉，否则下一次开流会撞上另一个录屏在跑。 */
-    if (this.sessions > 0) this.killStale()
     this.init = null
     this.lastKeyChunks = []
     this.waiting.clear()

package/test/coords.test.mjs

@@ -0,0 +1,129 @@
+/**
+ * 坐标换算回归：从 client.js 里切出真实的 pictureRect / turned / devicePoint 源码，
+ * 在 node 里用假 DOM 矩形跑。侧栏在右边时坐标曾经被减两次（视觉中心点成 0,600），
+ * 这条测试就是那份审阅复现的固化版：改坏就红。
+ *
+ *   node test/coords.test.mjs
+ */
+
+import fs from 'node:fs'
+import assert from 'node:assert/strict'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+const source = fs.readFileSync(path.join(here, '..', 'client.js'), 'utf8')
+
+const start = source.indexOf('/* 画面元素：MSE 用 video')
+const end = source.indexOf('/* 平移边界')
+assert.ok(start > 0 && end > start, '没找到几何换算那一段源码')
+
+const geometry = source.slice(start, end)
+const factory = new Function(
+  'engine', 'videoRef', 'imgRef', 'canvasRef', 'screen', 'frameSize', 'Math',
+  `${geometry}\n return { devicePoint, pictureRect, turned }`,
+)
+
+/**
+ * 造一个用给定矩形假装的 DOM 元素。
+ * @param {number} left - 视口左边缘。
+ * @param {number} top - 视口上边缘。
+ * @param {number} width - 宽。
+ * @param {number} height - 高。
+ * @returns {{ getBoundingClientRect: () => any }} 元素桩。
+ */
+const box = (left, top, width, height) => ({ getBoundingClientRect: () => ({ left, top, width, height, right: left + width, bottom: top + height }) })
+
+/**
+ * 造一台设备状态下的换算器。
+ * @param {{ device: {w: number, h: number}, frame: {w: number, h: number}, canvas: any, media: any, engine?: string }} config - 现场。
+ * @returns {(point: {x: number, y: number}) => {x: number, y: number}} 换算函数。
+ */
+const make = ({ device, frame, canvas, media, engine = 'jpeg' }) => {
+  const { devicePoint } = factory(engine, { current: null }, { current: media }, { current: canvas }, device, frame, Math)
+  return devicePoint
+}
+
+let pass = 0
+/**
+ * 断言一点。
+ * @param {string} label - 检查项。
+ * @param {() => void} run - 断言体。
+ * @returns {void}
+ */
+const it = (label, run) => {
+  try {
+    run()
+    pass += 1
+    console.log(`  ✅ ${label}`)
+  } catch (error) {
+    console.log(`  ❌ ${label}`)
+    throw error
+  }
+}
+
+console.log('\n坐标换算（源码级）\n')
+
+/* 审阅给的复现：右栏里画面框 left=1000/top=100，显示 300x533.33，设备 1080x1920。
+   取画面正中心，正确结果是 (540,960)；旧代码会算成 (0,600)。 */
+it('右栏里点画面正中心 = 设备正中心', () => {
+  const toDevice = make({
+    device: { w: 1080, h: 1920 },
+    frame: { w: 300, h: 533.333 },
+    canvas: box(1000, 100, 300, 533.333),
+    media: box(1000, 100, 300, 533.333),
+  })
+  assert.deepEqual(toDevice({ x: 150, y: 266.666 }), { x: 540, y: 960 })
+})
+
+it('画面有上下留边时按画面矩形换算（不是画布）', () => {
+  const toDevice = make({
+    device: { w: 1080, h: 1350 },
+    frame: { w: 400, h: 500 },
+    canvas: box(20, 40, 400, 600),
+    media: box(20, 90, 400, 500),
+  })
+  assert.deepEqual(toDevice({ x: 200, y: 250 }), { x: 540, y: 540 })
+})
+
+it('画面有左右留边时按画面矩形换算', () => {
+  const toDevice = make({
+    device: { w: 1080, h: 1080 },
+    frame: { w: 400, h: 400 },
+    canvas: box(0, 0, 500, 400),
+    media: box(50, 0, 400, 400),
+  })
+  assert.deepEqual(toDevice({ x: 250, y: 200 }), { x: 540, y: 540 })
+})
+
+it('画面外沿夹到边界，不会溢成负数', () => {
+  const toDevice = make({
+    device: { w: 1080, h: 1920 },
+    frame: { w: 300, h: 533 },
+    canvas: box(1000, 100, 300, 533),
+    media: box(1000, 100, 300, 533),
+  })
+  assert.deepEqual(toDevice({ x: -50, y: 900 }), { x: 0, y: 1920 })
+})
+
+it('横屏画面 + 竖屏设备（转过 90°）映射到长边', () => {
+  const toDevice = make({
+    device: { w: 2136, h: 3200 },
+    frame: { w: 2400, h: 1080 },
+    canvas: box(0, 0, 2400, 1080),
+    media: box(0, 0, 2400, 1080),
+  })
+  assert.deepEqual(toDevice({ x: 1200, y: 540 }), { x: 1068, y: 1600 })
+})
+
+it('MSE 走 video 元素，抓帧走 img，两条路都拿画面矩形', () => {
+  const canvas = box(0, 0, 300, 500)
+  const video = box(0, 0, 300, 500)
+  const img = box(10, 20, 280, 460)
+  const mse = factory('mse', { current: video }, { current: img }, { current: canvas }, { w: 1080, h: 1800 }, { w: 300, h: 500 }, Math)
+  assert.deepEqual(mse.devicePoint({ x: 150, y: 250 }), { x: 540, y: 900 })
+  const jpeg = factory('jpeg', { current: video }, { current: img }, { current: canvas }, { w: 1080, h: 1800 }, { w: 300, h: 500 }, Math)
+  assert.deepEqual(jpeg.devicePoint({ x: 150, y: 250 }), { x: 540, y: 900 })
+})
+
+console.log(`\n${pass} 项通过\n`)

package/test/symbols.test.mjs

@@ -0,0 +1,73 @@
+/**
+ * 悬空 this 调用扫描：rename 后残留 `this.oldName()` 会让插件在回调里抛 TypeError，
+ * 而宿主不隔离插件异常 —— 一次空转定时器就能打死整个 DSH（2026-10-27 的 killStale 事故）。
+ * 只做一件事：文件里每个 `this.foo(` 都要能找到定义（方法简写或 this.foo = 赋值）。
+ */
+import { readFileSync } from 'node:fs'
+
+const FILES = ['stream.js', 'mirror.js', 'index.js', 'client.js']
+
+/** 从源码里收集「哪些名字在这份文件里是可调用的 this 成员」。 */
+function knownMembers(source) {
+  const names = new Set()
+  /* this.foo = ... 的赋值（含 this.foo = function / 箭头函数）。 */
+  for (const m of source.matchAll(/this\.([A-Za-z_$][\w$]*)\s*=(?!=)/g)) names.add(m[1])
+  /* 方法简写 / 类字段箭头函数：行首缩进后的 `foo(...) {` 或 `foo = (...) =>`。 */
+  for (const m of source.matchAll(/^\s{2,}(?:async\s+)?(?:get\s+|set\s+)?([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*\{/gm)) names.add(m[1])
+  for (const m of source.matchAll(/^\s{2,}([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\(/gm)) names.add(m[1])
+  /* 对象字面量里的方法（route 表这类）也给过。 */
+  for (const m of source.matchAll(/([A-Za-z_$][\w$]*)\s*:\s*(?:async\s*)?(?:function|\()/g)) names.add(m[1])
+  return names
+}
+
+/** 常见内置/外部注入成员，不要求在文件内定义。 */
+const BUILTIN = new Set([
+  'constructor', 'then', 'catch', 'finally', 'apply', 'call', 'bind', 'toString', 'valueOf',
+  'hasOwnProperty', 'push', 'pop', 'shift', 'unshift', 'slice', 'splice', 'map', 'filter',
+  'forEach', 'find', 'findIndex', 'some', 'every', 'reduce', 'join', 'split', 'trim',
+  'replace', 'includes', 'startsWith', 'endsWith', 'padStart', 'padEnd', 'toFixed',
+  'getTime', 'toISOString', 'keys', 'values', 'entries', 'set', 'get', 'delete', 'has',
+  'clear', 'add', 'size', 'length', 'emit', 'on', 'once', 'off', 'removeListener', 'end',
+  'write', 'pipe', 'read', 'kill', 'ref', 'unref', 'stdin', 'stdout', 'stderr',
+])
+
+let failures = 0
+const it = (label, run) => {
+  try {
+    run()
+    console.log(`  ✅ ${label}`)
+  } catch (error) {
+    failures += 1
+    console.log(`  ❌ ${label}\n     ${String(error?.message ?? error)}`)
+  }
+}
+const assert = (cond, msg) => {
+  if (!cond) throw new Error(msg)
+}
+
+for (const file of FILES) {
+  it(`${file}：this.* 调用都有定义`, () => {
+    const source = readFileSync(new URL(`../${file}`, import.meta.url), 'utf8')
+    const known = knownMembers(source)
+    const dangling = new Set()
+    for (const m of source.matchAll(/this\.([A-Za-z_$][\w$]*)\s*\(/g)) {
+      const name = m[1]
+      if (known.has(name) || BUILTIN.has(name)) continue
+      dangling.add(name)
+    }
+    assert(dangling.size === 0, `悬空调用：${[...dangling].join(', ')}（改名后残留会让插件回调抛 TypeError，host 直接退出）`)
+  })
+}
+
+/* 自检：故意造一份带残留调用的源码，确认扫描器抓得到，别写成永远绿的摆设。 */
+it('扫描器能抓到悬空调用（自检）', () => {
+  const broken = 'class A {\n  killOwn() {}\n  stop() {\n    if (this.n > 0) this.killStale()\n  }\n}\n'
+  const known = knownMembers(broken)
+  const dangling = [...broken.matchAll(/this\.([A-Za-z_$][\w$]*)\s*\(/g)]
+    .map((m) => m[1])
+    .filter((name) => !known.has(name) && !BUILTIN.has(name))
+  assert(dangling.includes('killStale'), '扫描器没抓到 killStale，说明这个测试本身失效了')
+})
+
+console.log(failures === 0 ? `\n=== 全部通过 ===` : `\n=== ${failures} 项失败 ===`)
+process.exitCode = failures === 0 ? 0 : 1

package/test/timers.test.mjs

@@ -0,0 +1,60 @@
+/**
+ * 定时器兜底扫描：宿主不隔离插件异常，定时器回调里任何一个 TypeError 都会冒到顶层，
+ * 整个 DSH 以 1 退出（2026-10-27 `this.killStale` 两次事故就是空闲回收定时器 → stop()）。
+ * 规则：host 侧所有节拍器/回收定时器的回调都要经过 guard()，单拍出错只记日志。
+ */
+import { readFileSync } from 'node:fs'
+
+/** 以 this 成员形式挂出去的定时器（节拍器与空闲/续录回收）。 */
+const PATTERN = /this\.(timer|pushTimer|idleTimer|restartTimer)\s*=\s*(?:setInterval|setTimeout)\(/g
+
+/** 从注册点往后看多远算「同一个回调」。 */
+const WINDOW = 160
+
+/** 找出没走 guard 的定时器注册。 @param {string} source - 文件源码。 @returns {string[]} 违规点。 */
+function unguarded(source) {
+  const bad = []
+  for (const m of source.matchAll(PATTERN)) {
+    const tail = source.slice(m.index, m.index + WINDOW)
+    if (!tail.includes('guard(')) bad.push(source.slice(m.index, m.index + 60).split('\n')[0])
+  }
+  return bad
+}
+
+let failures = 0
+const it = (label, run) => {
+  try {
+    run()
+    console.log(`  ✅ ${label}`)
+  } catch (error) {
+    failures += 1
+    console.log(`  ❌ ${label}\n     ${String(error?.message ?? error)}`)
+  }
+}
+const assert = (cond, msg) => {
+  if (!cond) throw new Error(msg)
+}
+
+for (const file of ['stream.js', 'mirror.js']) {
+  it(`${file}：定时器回调都经过 guard`, () => {
+    const bad = unguarded(readFileSync(new URL(`../${file}`, import.meta.url), 'utf8'))
+    assert(bad.length === 0, `未兜底的定时器：${bad.join(' | ')}`)
+  })
+}
+
+it('自检：没兜底的定时器会被抓出来', () => {
+  const fake = 'this.idleTimer = setTimeout(() => { this.stop() }, 20000)'
+  assert(unguarded(fake).length === 1, '扫描放过了一个裸定时器')
+})
+
+it('自检：兜底后的定时器不误报', () => {
+  const fake = "this.idleTimer = setTimeout(() => guard('idle-stop', () => { this.stop() }), 20000)"
+  assert(unguarded(fake).length === 0, '兜底写法被误判')
+})
+
+if (failures > 0) {
+  console.log(`=== ${failures} 项失败 ===`)
+  process.exitCode = 1
+} else {
+  console.log('=== 全部通过 ===')
+}