agentworkshop 0.7.44 → 0.7.46

package/server/services/workshop/daq/drivers.ts

@@ -1,1196 +0,0 @@
-/**
- * DAQ 采集驱动 —— 采样值的生产者抽象(工业协议接入点)。
- *
- * 契约(DaqDriver):
- *  - sample():控制器生产循环按节点周期调用,返回工程量读数;
- *  - test():连接测试(建连 + 读一次),前端"测试连接"按钮直达;
- *  - available():协议栈包是否已安装(node-opcua 体积大,动态探测)。
- *
- * 实现:
- *  - mock:内置模拟(正弦基线 + 随机游走 + 偶发越限;按 id 定相位);
- *  - modbus-tcp:modbus-serial 真实实现(连接池按 host:port:unitId 复用,
- *    保持/输入寄存器,int16~float32 解码,字节序/缩放);
- *  - opcua:node-opcua 真实实现(会话池按 endpoint 复用,NodeId 读取,
- *    安全策略/账号可选);
- *  - s7:预留(实现 nodes7 poll 后注册即可,链路零改动)。
- */
-import { createLogger } from '../logger'
-import { createRequire } from 'node:module'
-import { encodePng } from './png-enc'
-import { DAQ_DRIVERS, type DaqDriverKind, type DriverTestResult } from '../../../../shared/daq-protocol'
-
-const log = createLogger('daq.drivers')
-
-/** createRequire 加载原生/重型协议栈(nitro Windows 动态 import external 的 'd:' scheme 规避) */
-const reqNative = createRequire(import.meta.url)
-
-/** 采样上下文(controller 注入) */
-export interface DaqSampleCtx {
-  nodeId: string
-  now: number
-  ageMs: number
-}
-
-/** 驱动配置:模板域(采样波形/兜底量程)+ 协议连接参数(driverConfig) */
-export interface DaqDriverInput {
-  ctx: DaqSampleCtx
-  config: { base: number, amp: number, min: number, max: number }
-  /** 节点保存的协议连接参数(host/register/endpoint/nodeId...) */
-  driverConfig: Record<string, unknown>
-  /** 模板信号形态(v2 帧管线;缺省 scalar —— 既有驱动零感知) */
-  signalKind?: 'scalar' | 'vector' | 'image'
-  /** vector 声明(模板;mock 生成点列/校验依据) */
-  vector?: { points: number, min: number, max: number }
-}
-
-/**
- * 帧采样值(v2 多形态信号):驱动 sample() 可返回标量(既有契约)或帧信封。
- *  - vector:多点工程量轮廓(≤4096 点,经队列 JSON 传输)
- *  - image :像素 blob(仅生产侧管线内存续;controller 落对象存储后剥离为 objectKey)
- */
-export type DaqFrameSample = {
-  frame:
-    | { kind: 'vector', points: number[], metrics?: Record<string, number> }
-    | {
-      kind: 'image'
-      blob: Buffer
-      mime: string
-      width: number
-      height: number
-      metrics?: Record<string, number>
-      /** 驱动侧通常未设;controller 落对象存储后回填引用(队列信封只传引用) */
-      objectKey?: string
-      thumbKey?: string
-    }
-}
-
-export interface DaqDriver {
-  readonly kind: DaqDriverKind
-  /** 协议栈是否可用(包缺失时 false,节点测试连接给出可行动提示) */
-  available(): Promise<boolean>
-  sample(input: DaqDriverInput): Promise<number | DaqFrameSample | null> | number | DaqFrameSample | null
-  test(driverConfig: Record<string, unknown>): Promise<DriverTestResult>
-}
-
-// ============================================================
-// mock 内置模拟源
-// ============================================================
-
-const hashPhase = (id: string): number => {
-  let h = 0
-  for (const c of id) h = (h * 31 + c.charCodeAt(0)) % 628
-  return h
-}
-
-interface MockState {
-  phase: number
-  value: number | null
-  excursionLeft: number
-  excursionDir: number
-  excursionDepth: number
-  lastAt: number
-}
-
-const g = globalThis as typeof globalThis & { __daqMockStates?: Map<string, MockState> }
-function mockStates(): Map<string, MockState> {
-  return g.__daqMockStates ??= new Map()
-}
-
-export const mockDaqDriver: DaqDriver = {
-  kind: 'mock',
-  async available() {
-    return true
-  },
-  sample({ ctx, config, signalKind, vector }) {
-    // 多形态分支(v2 帧管线):vector=多点波形轮廓;image=程序化灰度 PNG;scalar=既有单点波形
-    if (signalKind === 'vector') return mockVectorSample(ctx, config, vector)
-    if (signalKind === 'image') return mockImageSample(ctx, config)
-    return mockScalarSample(ctx, config)
-  },
-  async test() {
-    return { ok: true, message: 'Mock 驱动无需连接,采样即模拟波形' }
-  },
-}
-
-/** 既有单点波形(原 sample() 主体,零行为变化) */
-function mockScalarSample(ctx: DaqSampleCtx, config: { base: number, amp: number, min: number, max: number }): number {
-  const states = mockStates()
-  let st = states.get(ctx.nodeId)
-  if (!st) {
-    st = { phase: hashPhase(ctx.nodeId), value: null, excursionLeft: 0, excursionDir: 0, excursionDepth: 0, lastAt: ctx.now }
-    states.set(ctx.nodeId, st)
-  }
-  const dt = Math.max(0, Math.min(ctx.now - st.lastAt, 60_000))
-  st.lastAt = ctx.now
-  if (st.excursionLeft <= 0 && Math.random() < 0.008 * Math.max(1, dt / 1000)) {
-    st.excursionLeft = 6 + Math.floor(Math.random() * 9)
-    st.excursionDir = Math.random() < 0.5 ? -1 : 1
-    st.excursionDepth = (config.max - config.min) * (0.08 + Math.random() * 0.1)
-  }
-  const t = (ctx.ageMs + st.phase * 100) / 1000
-  const sine = Math.sin(t * 0.35) * config.amp * 0.55 + Math.sin(t * 0.11 + 1.3) * config.amp * 0.3
-  let v = config.base + sine
-  if (st.value != null) v += (config.base - st.value) * 0.06 + (Math.random() - 0.5) * config.amp * 0.5
-  if (st.excursionLeft > 0) {
-    st.excursionLeft -= 1
-    const ramp = Math.min(1, (10 - st.excursionLeft) / 4)
-    v += st.excursionDir * st.excursionDepth * (0.4 + 0.6 * ramp)
-    if (st.excursionLeft === 0) st.excursionDir = 0
-  }
-  v = Math.min(config.max + config.amp * 2.2, Math.max(config.min - config.amp * 2.2, v))
-  st.value = v
-  return v
-}
-
-/** 多点波形轮廓(测厚仪/扫描仪语义:横向 n 点,带漂移与偶发局部尖峰) */
-function mockVectorSample(
-  ctx: DaqSampleCtx,
-  config: { base: number, amp: number, min: number, max: number },
-  vector?: { points: number, min: number, max: number },
-): { frame: { kind: 'vector', points: number[], metrics: Record<string, number> } } {
-  const n = Math.max(2, Math.min(4096, vector?.points ?? 64))
-  const vMin = vector?.min ?? config.min
-  const vMax = vector?.max ?? config.max
-  const span = vMax - vMin
-  const t = (ctx.ageMs + hashPhase(ctx.nodeId) * 100) / 1000
-  const points: number[] = []
-  // 横向轮廓:慢波(工艺整体偏移)+ 位置抛物面(边缘偏厚)+ 噪声 + 偶发局部尖峰(缺陷)
-  const drift = Math.sin(t * 0.21) * config.amp
-  const spikePos = Math.floor((Math.sin(t * 0.07) * 0.5 + 0.5) * n)
-  for (let i = 0; i < n; i++) {
-    const rel = i / (n - 1)
-    const crown = -4 * (rel - 0.5) ** 2 * span * 0.03 // 边缘略薄(负抛物面)
-    let v = config.base + drift + crown + (Math.random() - 0.5) * config.amp * 0.4
-    if (Math.abs(i - spikePos) <= 1) v += span * 0.06 // 偶发局部尖峰
-    points.push(Math.round(Math.min(vMax, Math.max(vMin, v)) * 1e6) / 1e6)
-  }
-  return { frame: { kind: 'vector', points, metrics: {} } }
-}
-
-/** 程序化灰度图像(CCD 语义:纹理背景 + 移动暗斑;零外部依赖 zlib PNG) */
-function mockImageSample(
-  ctx: DaqSampleCtx,
-  config: { base: number, amp: number, min: number, max: number },
-): { frame: { kind: 'image', blob: Buffer, mime: string, width: number, height: number, metrics: Record<string, number> } } {
-  // 偶发"曝光异常"帧(低亮度)驱动 quality-gate 告警链路可观测
-  const dark = Math.random() < 0.03
-  const baseGray = dark ? 22 : Math.round(Math.min(230, Math.max(60, config.base)))
-  const w = 320
-  const h = 240
-  const px = new Uint8Array(w * h)
-  const t = (ctx.ageMs + hashPhase(ctx.nodeId) * 100) / 1000
-  const spotX = Math.floor(((Math.sin(t * 0.4) + 1) / 2) * (w - 60)) + 30
-  const spotY = Math.floor(((Math.cos(t * 0.3) + 1) / 2) * (h - 60)) + 30
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      // 编织纹理 + 随机噪声 + 移动暗斑(表面缺陷模拟)
-      let v = baseGray + Math.sin(x * 0.35) * 8 + Math.sin(y * 0.22 + 1.7) * 6 + (Math.random() - 0.5) * 10
-      const dx = x - spotX
-      const dy = y - spotY
-      const d2 = dx * dx + dy * dy
-      if (d2 < 400) v -= (1 - d2 / 400) * 90
-      px[y * w + x] = Math.max(0, Math.min(255, Math.round(v)))
-    }
-  }
-  const blob = encodePng(w, h, px)
-  return { frame: { kind: 'image', blob, mime: 'image/png', width: w, height: h, metrics: {} } }
-}
-
-// ============================================================
-// Modbus TCP 真实驱动(modbus-serial;连接池按 host:port:unitId 复用)
-// ============================================================
-
-/**
- * modbus-serial 客户端实例类型。
- *
- * 该包 index.d.ts 只写 `import { ModbusRTU } from "./ModbusRTU"` + `export default ModbusRTU`,
- * **没有**具名 re-export(运行时 module.exports = 构造器,并自挂 module.exports.default = 自己),
- * 因此 `import('modbus-serial').ModbusRTU` 在类型上并不存在 —— 从 default 导出取才与实际导出形态一致。
- */
-type ModbusRtuClient = InstanceType<typeof import('modbus-serial').default>
-
-export interface ModbusConn {
-  client: ModbusRtuClient
-  lastUsed: number
-  /** 连接级操作队列尾(采/控共用链路串行化:TCP 网关并发事务会协议错乱) */
-  tail: Promise<unknown>
-  /** 在队列中等待/执行中的操作数(0 = 链路空闲) */
-  pending: number
-  errors: number
-}
-
-const modbusPool = new Map<string, ModbusConn>()
-/** 空闲连接回收(10 分钟未用断开;采样周期最长 60s,足够保守) */
-const MODBUS_IDLE_MS = 600_000
-
-export type ModbusTransport = 'tcp' | 'rtu-tcp'
-
-/** 连续故障自愈:关闭并移除池内连接(下次操作重建) */
-export function evictModbusConn(cfg: Record<string, unknown>, transport: ModbusTransport = 'tcp'): void {
-  const key = modbusKey(cfg, transport)
-  const conn = modbusPool.get(key)
-  if (!conn) return
-  try {
-    void conn.client.close()
-  }
-  catch { /* 已断 */ }
-  modbusPool.delete(key)
-}
-
-/**
- * 安全关闭:半开 socket(对端断电)时 modbus-serial close() 等待 FIN 永不返回,
- * 一律 500ms 超时保护(fire-and-forget 底层 close,调用方不阻塞)。
- */
-export async function closeModbusSafely(client: ModbusRtuClient): Promise<void> {
-  await Promise.race([
-    Promise.resolve()
-      .then(() => client.close())
-      .catch(() => { /* 已断 */ }),
-    new Promise(r => setTimeout(r, 500)),
-  ])
-}
-
-/**
- * 连接级排队执行:操作串行入队,完成后链路归还。
- * 数控写入等当前采样读完成再执行(不再 409 快速失败);数采采样忙时仍跳帧让路防堆积。
- * per-request 3s 硬超时:半开连接(对端断电/SYN 黑洞)时底层请求永不 settle,
- * 超时后作废连接并重置 tail 链,防止单条死连接堵死该 host:port 的全部后续请求。
- */
-export function withModbusConn<R>(conn: ModbusConn, fn: () => Promise<R>): Promise<R> {
-  conn.pending++
-  const run = conn.tail.then(() => fn(), () => fn())
-  let timer: NodeJS.Timeout | undefined
-  let dead = false
-  const guarded: Promise<R> = Promise.race([
-    run,
-    new Promise<never>((_, rej) => {
-      timer = setTimeout(() => {
-        dead = true
-        try {
-          void conn.client.close()
-        }
-        catch { /* 已断 */ }
-        rej(new Error('Modbus 响应超时(3s)——连接可能半开,已作废重连'))
-      }, 3000)
-    }),
-  ])
-  void guarded.catch(() => { /* 超时分支先 reject,防 unhandled */ })
-  conn.tail = guarded.then(
-    () => {
-      clearTimeout(timer)
-      conn.pending--
-    },
-    () => {
-      clearTimeout(timer)
-      conn.pending--
-    },
-  ).then(() => {
-    if (dead) conn.tail = Promise.resolve()
-  })
-  return guarded
-}
-
-export function modbusKey(cfg: Record<string, unknown>, transport: ModbusTransport = 'tcp'): string {
-  return `${transport}:${cfg.host}:${cfg.port ?? 502}:${cfg.unitId ?? 1}`
-}
-
-export async function getModbusConn(cfg: Record<string, unknown>, transport: ModbusTransport = 'tcp'): Promise<ModbusConn> {
-  const key = modbusKey(cfg, transport)
-  const existing = modbusPool.get(key)
-  if (existing && existing.client.isOpen) return existing
-  if (existing) {
-    try {
-      await closeModbusSafely(existing.client)
-    }
-    catch { /* 已断 */ }
-    modbusPool.delete(key)
-  }
-  // CJS 互操作:require 形状可能是 { ModbusRTU } / default.ModbusRTU / 构造器本身
-  const mod = reqNative('modbus-serial') as unknown as { ModbusRTU?: unknown, default?: { ModbusRTU?: unknown } | unknown }
-  const ModbusRTU = (mod.ModbusRTU ?? (mod.default as { ModbusRTU?: unknown } | undefined)?.ModbusRTU ?? mod) as new () => ModbusRtuClient
-  const client = new ModbusRTU()
-  client.setTimeout(3000)
-  // tcp = Modbus TCP(MBAP 封装);rtu-tcp = RTU over TCP(串口网关透传,CRC16 帧,无 MBAP)
-  // 连接硬超时(3s):connectTCP 无内建超时,PLC 离线/半开连接时 SYN 黑洞会悬挂调用方
-  const connect = transport === 'rtu-tcp'
-    ? client.connectTcpRTUBuffered(String(cfg.host), { port: Number(cfg.port ?? 502) })
-    : client.connectTCP(String(cfg.host), { port: Number(cfg.port ?? 502) })
-  await Promise.race([
-    connect,
-    new Promise((_, rej) => setTimeout(() => rej(new Error(`连接超时(3s)——检查 PLC 电源/IP/端口与防火墙`)), 3000)),
-  ]).catch((err) => {
-    try {
-      void client.close()
-    }
-    catch { /* 未连上 */ }
-    throw err
-  })
-  client.setID(Number(cfg.unitId ?? 1))
-  // 吸收底层 socket 错误(write-after-end / ECONNRESET 等):超时作废重连路径关闭 socket 后,
-  // 队列中滞留的写入会触发 modbus-serial 内部 socket.write 异步错误 —— 若不挂 error 处理器,
-  // 会以 unhandledRejection 打崩进程(stability-guard fatal)。池层已有 evict 自愈,这里只需静默。
-  const sock = (client as unknown as { port?: { client?: { on?: (ev: string, cb: (e: Error) => void) => void } } }).port?.client
-  sock?.on?.('error', () => {})
-  // write-after-end 防线:evict/close 与在飞事务竞态时,modbus-serial 仍可能对已 end/destroy 的
-  // socket 调 write —— 该错误的 emit 路径并不总走 'error' 事件(实测同步抛出打崩进程,
-  // ERR_STREAM_WRITE_AFTER_END)。在 socket 层直接拦截:已终结即丢弃写入,让上层超时兜底。
-  const sockWritable = sock as unknown as { writableEnded?: boolean, destroyed?: boolean, write?: (...a: unknown[]) => unknown } | null
-  if (sockWritable?.write) {
-    const rawWrite = sockWritable.write.bind(sock)
-    sockWritable.write = (...a: unknown[]) => {
-      if (sockWritable.writableEnded || sockWritable.destroyed) return false
-      return rawWrite(...a)
-    }
-  }
-  const conn: ModbusConn = { client, lastUsed: Date.now(), tail: Promise.resolve(), pending: 0, errors: 0 }
-  modbusPool.set(key, conn)
-  return conn
-}
-
-/** 寄存器值解码(1~2 word;字节序:big/little/wordSwap) */
-export function decodeRegisters(data: number[], dataType: string, byteOrder: string): number {
-  if (dataType === 'int16' || dataType === 'uint16') {
-    const raw = data[0] ?? 0
-    return dataType === 'int16' ? (raw << 16) >> 16 : raw
-  }
-  // 字节序约定(寄存器字 w0=[A B], w1=[C D],float32 内存字节序按 4 字节解):
-  //   big = ABCD(w0 高字在前,w0/w1 各自大端) —— Modbus 标准大端,最常用
-  //   little = DCBA(全小端:w1 字节反转在前)
-  //   wordSwap = CDAB(字交换:每字内部仍大端,低字在前)
-  const hi = (x: number) => (x >> 8) & 0xFF
-  const lo = (x: number) => x & 0xFF
-  let b: number[]
-  if (byteOrder === 'little') b = [hi(data[1]!), lo(data[1]!), hi(data[0]!), lo(data[0]!)].reverse()
-  else if (byteOrder === 'wordSwap') b = [hi(data[1]!), lo(data[1]!), hi(data[0]!), lo(data[0]!)]
-  else b = [hi(data[0]!), lo(data[0]!), hi(data[1]!), lo(data[1]!)]
-  const buf = Buffer.from(b)
-  if (dataType === 'float32') return buf.readFloatBE(0)
-  if (dataType === 'uint32') return buf.readUInt32BE(0)
-  return buf.readInt32BE(0)
-}
-
-/** 4xxxx 保持寄存器 → 协议偏移(40001 → 0);3xxxx 输入寄存器同理 */
-export function registerOffset(addr: number, area: string): number {
-  if (area === 'input') return addr >= 30001 ? addr - 30001 : addr
-  return addr >= 40001 ? addr - 40001 : addr
-}
-
-/**
- * 通信故障分类(数采/数控共用):底层异常 → 可操作的中文诊断 + 处理提示。
- * 前端/Agent/写历史直接透出该文案,运维按提示即可定位问题层级。
- */
-export function classifyCommError(err: unknown): string {
-  const raw = err instanceof Error ? err.message : String(err)
-  const m = raw.toLowerCase()
-  if (/econnrefused|connection refused|connect etimedout/.test(m) || /port connection failed/.test(m))
-    return `无法建立连接——检查 PLC 电源/IP/端口与防火墙(${raw})`
-  if (/etimedout|timed out|timeout/.test(m))
-    return `PLC 响应超时——网络抖动或从站负载高,稍后自动重连(${raw})`
-  if (/ehostunreach|enetunreach|network unreachable/.test(m))
-    return `网络不可达——检查本机与 PLC 的路由/网段(${raw})`
-  if (/enotfound|eai_again/.test(m))
-    return `主机名无法解析——检查 host 配置(${raw})`
-  if (/crc/.test(m))
-    return `CRC 校验失败——串口线路干扰或波特率/校验位不匹配(${raw})`
-  if (/illegal|exception|function code/.test(m))
-    return `PLC 拒绝该操作——功能码或寄存器地址不被支持,检查地址区配置(${raw})`
-  if (/protocol/.test(m))
-    return `协议响应异常——数据长度/帧格式不符,检查寄存器数量与从站型号(${raw})`
-  if (/not connected|socket|closed|econnreset/.test(m))
-    return `连接已断开——将自动重建连接,若持续失败请检查线缆(${raw})`
-  return raw
-}
-
-/** 4xxxx 保持寄存器 → 协议偏移(40001 → 0);3xxxx 输入寄存器同理 */
-export const WORDS_OF: Record<string, number> = { int16: 1, uint16: 1, int32: 2, uint32: 2, float32: 2 }
-
-async function modbusRead(conn: ModbusConn, cfg: Record<string, unknown>, transport: ModbusTransport = 'tcp'): Promise<number> {
-  const area = String(cfg.registerType ?? 'holding')
-  const offset = registerOffset(Number(cfg.register ?? 0), area)
-  const dataType = String(cfg.dataType ?? 'float32')
-  const words = WORDS_OF[dataType] ?? 2
-  const res = area === 'input'
-    ? await conn.client.readInputRegisters(offset, words)
-    : await conn.client.readHoldingRegisters(offset, words)
-  const raw = decodeRegisters(res.data as number[], dataType, String(cfg.byteOrder ?? 'big'))
-  const scale = Number(cfg.scale ?? 1)
-  void transport
-  return raw * (Number.isFinite(scale) ? scale : 1)
-}
-
-export const modbusTcpDriver: DaqDriver = {
-  kind: 'modbus-tcp',
-  async available() {
-    try {
-      reqNative('modbus-serial')
-      return true
-    }
-    catch {
-      return false
-    }
-  },
-  async sample({ driverConfig }) {
-    const conn = await getModbusConn(driverConfig)
-    // 连接级串行队列:读 ~20ms、采样周期 >=120ms,正常排队深度 1~2;仅当队列深积
-    // (PLC 慢/离线,单读逼近超时)时跳帧保护,阈值 pending>8 防雪崩。
-    // (不用 busy>0 一票跳帧:同链路多节点同节拍会互相跳帧,新节点长期出不了首值)
-    if (conn.pending > 8) return null
-    conn.lastUsed = Date.now()
-    return withModbusConn(conn, async () => {
-      try {
-        const v = await modbusRead(conn, driverConfig)
-        conn.errors = 0
-        return v
-      }
-      catch (err) {
-        conn.errors++
-        // 连续故障 → 主动断开,下次采样重建(自愈)
-        if (conn.errors >= 3) evictModbusConn(driverConfig)
-        throw err
-      }
-    })
-  },
-  async test(driverConfig) {
-    const t0 = Date.now()
-    try {
-      if (!driverConfig.host) return { ok: false, message: '缺少设备地址 host' }
-      if (driverConfig.register == null) return { ok: false, message: '缺少寄存器地址 register' }
-      const conn = await getModbusConn(driverConfig)
-      const v = await withModbusConn(conn, () => modbusRead(conn, driverConfig))
-      return {
-        ok: true,
-        message: `连接成功,读取 ${driverConfig.register} = ${v}`,
-        sampleValue: v,
-        latencyMs: Date.now() - t0,
-      }
-    }
-    catch (err) {
-      try {
-        const key = modbusKey(driverConfig)
-        const conn = modbusPool.get(key)
-        if (conn) {
-          await closeModbusSafely(conn.client)
-          modbusPool.delete(key)
-        }
-      }
-      catch { /* ignore */ }
-      return { ok: false, message: `Modbus 连接失败: ${err instanceof Error ? err.message : String(err)}` }
-    }
-  },
-}
-
-// 空闲回收 sweep(挂 globalThis 防 HMR 重复)
-const sweepGlobal = globalThis as typeof globalThis & { __daqModbusSweep?: NodeJS.Timeout }
-if (!sweepGlobal.__daqModbusSweep) {
-  sweepGlobal.__daqModbusSweep = setInterval(() => {
-    const now = Date.now()
-    for (const [key, conn] of modbusPool) {
-      if (now - conn.lastUsed > MODBUS_IDLE_MS && conn.pending === 0) {
-        try {
-          void conn.client.close()
-        }
-        catch { /* ignore */ }
-        modbusPool.delete(key)
-      }
-    }
-  }, 120_000)
-  sweepGlobal.__daqModbusSweep.unref?.()
-}
-
-// ============================================================
-// OPC UA 真实驱动(node-opcua;会话池按 endpoint+账号 复用)
-// ============================================================
-
-export interface OpcUaConn {
-  session: import('node-opcua').ClientSession
-  client: import('node-opcua').OPCUAClient
-  lastUsed: number
-  errors: number
-}
-
-const opcuaPool = new Map<string, OpcUaConn>()
-
-/**
- * 在飞建连去重表（同池 key → 尚未 settle 的建连任务）。
- *
- * 修复动因(实测事故):同端点**并发首连**此前无去重——两条采样/写控请求同时进入时
- * 各建一条 OPCUAClient,而后一条的 `opcuaPool.set` 会**覆盖**前一条:
- * 被覆盖的 session 与 TCP 连接从此无人持有,空闲 sweep 也扫不到 → **永久泄漏**;
- * 重连 churn(断链演练/反复建节点)下还会触发 node-opcua 内部
- * `_internal_create_secure_channel failed, this._secureChannel is supposed to be null`。
- */
-const opcuaInflight = new Map<string, Promise<OpcUaConn>>()
-
-// OPC UA 会话空闲回收(对照 modbus 池 sweep;节点删除/端点弃用后不再有读取
-// 路径触发 3 错误驱逐,无 sweep 会话与 TCP 连接会永久驻留)
-const OPCUA_IDLE_MS = 600_000
-const opcuaSweepGlobal = globalThis as typeof globalThis & { __daqOpcUaSweep?: NodeJS.Timeout }
-if (!opcuaSweepGlobal.__daqOpcUaSweep) {
-  opcuaSweepGlobal.__daqOpcUaSweep = setInterval(() => {
-    const now = Date.now()
-    for (const [key, conn] of opcuaPool) {
-      if (now - conn.lastUsed > OPCUA_IDLE_MS) {
-        try {
-          void conn.session.close()
-        }
-        catch { /* ignore */ }
-        try {
-          void conn.client.disconnect()
-        }
-        catch { /* ignore */ }
-        opcuaPool.delete(key)
-      }
-    }
-  }, 120_000)
-  opcuaSweepGlobal.__daqOpcUaSweep.unref?.()
-}
-
-/** 已告警过的 OPC UA 端点(进程内,按 `类别|安全模式|endpoint` 键;同端点重连风暴只告警一次)。
- *  与 logger 的同指纹限流互补:Set 管「同端点反复重连」,限流器管「大量不同端点」的同形文本。 */
-const gOpcUaSecWarned = globalThis as typeof globalThis & { __daqOpcUaSecWarned?: Set<string> }
-function opcUaSecWarned(): Set<string> {
-  return gOpcUaSecWarned.__daqOpcUaSecWarned ??= new Set()
-}
-
-export function opcuaKey(cfg: Record<string, unknown>): string {
-  // S3:证书/安全模式必须纳入池 key——不同证书/安全策略绝不能复用同一连接
-  return `${cfg.endpoint}|${cfg.username ?? ''}|${cfg.securityMode ?? 'None'}|${cfg.certificateFile ?? ''}|${cfg.privateKeyFile ?? ''}`
-}
-
-export async function getOpcUaConn(cfg: Record<string, unknown>): Promise<OpcUaConn> {
-  const key = opcuaKey(cfg)
-  const existing = opcuaPool.get(key)
-  if (existing) {
-    existing.lastUsed = Date.now()
-    return existing
-  }
-  // 在飞去重:同 key 并发首连复用同一条建连任务(否则后写覆盖 pool → 前一条 session/socket 永久泄漏)
-  const pending = opcuaInflight.get(key)
-  if (pending) return pending
-  const task = createOpcUaConn(cfg, key)
-  opcuaInflight.set(key, task)
-  try {
-    return await task
-  }
-  finally {
-    opcuaInflight.delete(key)
-  }
-}
-
-async function createOpcUaConn(cfg: Record<string, unknown>, key: string): Promise<OpcUaConn> {
-  const opcua = reqNative('node-opcua') as typeof import('node-opcua')
-  const securityMode = (['None', 'Sign', 'SignAndEncrypt'] as const).includes(cfg.securityMode as 'None')
-    ? (cfg.securityMode as 'None')
-    : 'None'
-  if (securityMode === 'None' && process.env.NODE_ENV === 'production') {
-    // P0:该告警原先每次建连都写一行(实测把生产日志灌到 18MB 且全是同一句)。
-    // 去重键 = endpoint:同端点反复重连只告警一次;warnThrottled 再兜一层同形文本洪水。
-    const noneKey = `none|${String(cfg.endpoint)}`
-    if (!opcUaSecWarned().has(noneKey)) {
-      opcUaSecWarned().add(noneKey)
-      log.warnThrottled(`[daq-opcua] WARN:节点 endpoint=${String(cfg.endpoint)} 使用 securityMode=None(匿名/明文),仅限测试环境;生产请配置 Sign/SignAndEncrypt + 证书`)
-    }
-  }
-  const clientOpts: Record<string, unknown> = {
-    endpointMustExist: false,
-    securityMode: opcua.MessageSecurityMode[securityMode],
-    securityPolicy: securityMode === 'None' ? opcua.SecurityPolicy.None : opcua.SecurityPolicy.Basic256Sha256,
-    connectionStrategy: { maxRetry: 1, initialDelay: 500, maxDelay: 2000 },
-    requestTimeout: 4000,
-  }
-  // S3:自签客户端证书/私钥(可选;driverConfig 透传,存储层 Record 无需改)
-  const certFile = typeof cfg.certificateFile === 'string' && cfg.certificateFile ? cfg.certificateFile : ''
-  const keyFile = typeof cfg.privateKeyFile === 'string' && cfg.privateKeyFile ? cfg.privateKeyFile : ''
-  if (securityMode !== 'None') {
-    if (certFile && keyFile) {
-      const fs = reqNative('node:fs') as typeof import('node:fs')
-      clientOpts.certificateFile = fs.readFileSync(certFile)
-      clientOpts.privateKeyFile = keyFile
-    }
-    else {
-      // 无证书时由 node-opcua 自动生成自签证书(仍加密,但身份不可信);生产建议显式证书
-      // 同端点同模式只告警一次(重连不再重复);限流器兜同形文本洪水
-      const noCertKey = `nocert|${securityMode}|${String(cfg.endpoint)}`
-      if (!opcUaSecWarned().has(noCertKey)) {
-        opcUaSecWarned().add(noCertKey)
-        log.warnThrottled(`[daq-opcua] WARN:securityMode=${securityMode} 但未配置 certificateFile/privateKeyFile,将使用自动生成自签证书`)
-      }
-    }
-  }
-  const client = opcua.OPCUAClient.create(clientOpts as Parameters<typeof opcua.OPCUAClient.create>[0])
-  await client.connect(String(cfg.endpoint))
-  // type 是 node-opcua 的 UserIdentityInfo 判别式(node-opcua-client createUserIdentityToken →
-  // coerceUserIdentityInfo:userName 存在时正是补成 UserTokenType.UserName 走同一分支),
-  // 显式写出既满足协议类型,也免去"字段漏写、等库回填"的隐式依赖;两个分支都返回 Promise<ClientSession>。
-  const session = cfg.username
-    ? await client.createSession({ type: opcua.UserTokenType.UserName, userName: String(cfg.username), password: String(cfg.password ?? '') })
-    : await client.createSession()
-  const conn: OpcUaConn = { session, client, lastUsed: Date.now(), errors: 0 }
-  // 竞态二次校验:建连期间若已有连接入池(并发首连的另一方完成),关闭本次新建并复用既有,
-  // 避免 opcuaPool.set 覆盖导致 session/socket 永久泄漏。
-  const raced = opcuaPool.get(key)
-  if (raced) {
-    try {
-      await session.close()
-    }
-    catch { /* 清理失败不覆盖原始错误 */ }
-    try {
-      await client.disconnect()
-    }
-    catch { /* 清理失败不覆盖原始错误 */ }
-    return raced
-  }
-  opcuaPool.set(key, conn)
-  return conn
-}
-
-/** 驱逐 OPC UA 连接(采样/写控共享池;连续故障后触发,下次调用重建)。
- *  只作用于**已入池**的连接:在飞建连本身就是新建的,交由竞态二次校验处理。 */
-export async function evictOpcUaConn(cfg: Record<string, unknown>): Promise<void> {
-  const key = opcuaKey(cfg)
-  const conn = opcuaPool.get(key)
-  if (!conn) return
-  opcuaPool.delete(key)
-  try {
-    await conn.session.close()
-  }
-  catch { /* ignore */ }
-  try {
-    await conn.client.disconnect()
-  }
-  catch { /* ignore */ }
-}
-
-async function opcuaRead(conn: OpcUaConn, cfg: Record<string, unknown>): Promise<number> {
-  const opcua = reqNative('node-opcua') as typeof import('node-opcua')
-  const node = opcua.coerceNodeId(String(cfg.nodeId ?? ''))
-  const dv = await conn.session.read({ nodeId: node, attributeId: opcua.AttributeIds.Value })
-  if (dv.statusCode.value !== 0) {
-    throw new Error(`NodeId 读取状态异常: 0x${dv.statusCode.value.toString(16)}(检查 ns 与标识)`)
-  }
-  const v = dv.value?.value
-  const num = typeof v === 'number' ? v : Number(v)
-  if (!Number.isFinite(num)) throw new Error(`值类型不可数值化: ${typeof v}`)
-  return num
-}
-
-export const opcUaDriver: DaqDriver = {
-  kind: 'opcua',
-  async available() {
-    try {
-      reqNative('node-opcua')
-      return true
-    }
-    catch {
-      return false
-    }
-  },
-  async sample({ driverConfig }) {
-    const conn = await getOpcUaConn(driverConfig)
-    try {
-      const v = await opcuaRead(conn, driverConfig)
-      conn.errors = 0
-      return v
-    }
-    catch (err) {
-      conn.errors++
-      if (conn.errors >= 3) await evictOpcUaConn(driverConfig)
-      throw err
-    }
-  },
-  async test(driverConfig) {
-    const t0 = Date.now()
-    try {
-      if (!driverConfig.endpoint) return { ok: false, message: '缺少端点 endpoint(opc.tcp://…)' }
-      if (!driverConfig.nodeId) return { ok: false, message: '缺少节点 ID nodeId(ns=…;s=…)' }
-      const conn = await getOpcUaConn(driverConfig)
-      const v = await opcuaRead(conn, driverConfig)
-      return {
-        ok: true,
-        message: `会话建立成功,读取 ${driverConfig.nodeId} = ${v}`,
-        sampleValue: v,
-        latencyMs: Date.now() - t0,
-      }
-    }
-    catch (err) {
-      return { ok: false, message: `OPC UA 连接失败: ${err instanceof Error ? err.message : String(err)}` }
-    }
-  },
-}
-
-// ============================================================
-// Modbus RTU over TCP 真实驱动(串口网关透传;connectTcpRTUBuffered,CRC16 帧)
-// ============================================================
-
-export const modbusRtuDriver: DaqDriver = {
-  kind: 'modbus-rtu',
-  async available() {
-    try {
-      reqNative('modbus-serial')
-      return true
-    }
-    catch {
-      return false
-    }
-  },
-  async sample({ driverConfig }) {
-    const conn = await getModbusConn(driverConfig, 'rtu-tcp')
-    if (conn.pending > 8) return null
-    conn.lastUsed = Date.now()
-    return withModbusConn(conn, async () => {
-      try {
-        const v = await modbusRead(conn, driverConfig)
-        conn.errors = 0
-        return v
-      }
-      catch (err) {
-        conn.errors++
-        if (conn.errors >= 3) evictModbusConn(driverConfig, 'rtu-tcp')
-        throw err
-      }
-    })
-  },
-  async test(driverConfig) {
-    const t0 = Date.now()
-    try {
-      if (!driverConfig.host) return { ok: false, message: '缺少网关地址 host' }
-      if (driverConfig.register == null) return { ok: false, message: '缺少寄存器地址 register' }
-      const conn = await getModbusConn(driverConfig, 'rtu-tcp')
-      const v = await withModbusConn(conn, () => modbusRead(conn, driverConfig))
-      return {
-        ok: true,
-        message: `网关连接成功,读取 ${driverConfig.register} = ${v}`,
-        sampleValue: v,
-        latencyMs: Date.now() - t0,
-      }
-    }
-    catch (err) {
-      try {
-        const conn = modbusPool.get(modbusKey(driverConfig, 'rtu-tcp'))
-        if (conn) {
-          await closeModbusSafely(conn.client)
-          modbusPool.delete(modbusKey(driverConfig, 'rtu-tcp'))
-        }
-      }
-      catch { /* ignore */ }
-      return { ok: false, message: `Modbus RTU 连接失败: ${err instanceof Error ? `${err.message}(${JSON.stringify({ ...(err as object), name: err.name })})` : String(err)}` }
-    }
-  },
-}
-
-// ============================================================
-// MQTT 真实驱动(mqtt 包;broker 连接池复用,订阅缓存 topic 最新报文)
-// ============================================================
-
-export interface MqttConn {
-  client: import('mqtt').MqttClient
-  /** topic → 最新原始报文(解析按节点 jsonPath 在采样时进行) */
-  topics: Map<string, { raw: string, at: number }>
-}
-
-const mqttPool = new Map<string, MqttConn>()
-
-function mqttKey(cfg: Record<string, unknown>): string {
-  return `mqtt://${cfg.host}:${cfg.port ?? 1883}|${cfg.username ?? ''}`
-}
-
-async function getMqttConn(cfg: Record<string, unknown>): Promise<MqttConn> {
-  const key = mqttKey(cfg)
-  const existing = mqttPool.get(key)
-  // 池命中必须验证活性:一次 error 事件后 client.end(true) 的"死连接"若留在池里,
-  // 该 broker 下所有节点会静默永久停采(空 raw → sample 全部 null 被当跳帧)
-  if (existing) {
-    if (existing.client.connected) return existing
-    try {
-      existing.client.end(true)
-    }
-    catch { /* 已死 */ }
-    mqttPool.delete(key)
-  }
-  const mqtt = reqNative('mqtt') as typeof import('mqtt')
-  const url = `mqtt://${String(cfg.host)}:${Number(cfg.port ?? 1883)}`
-  const client = await new Promise<import('mqtt').MqttClient>((resolve, reject) => {
-    const c = mqtt.connect(url, {
-      username: cfg.username ? String(cfg.username) : undefined,
-      password: cfg.password ? String(cfg.password) : undefined,
-      connectTimeout: 4000,
-      reconnectPeriod: 5000,
-    })
-    c.once('connect', () => resolve(c))
-    c.once('error', (err) => {
-      // 仅首次建连阶段的 error 走 reject;连接成功后的运行期 error 由下方 error 监听驱逐
-      try {
-        c.end(true)
-      }
-      catch { /* 未连上 */ }
-      reject(new Error(`MQTT 连接失败: ${err.message}`))
-    })
-  })
-  const conn: MqttConn = { client, topics: new Map() }
-  client.on('message', (topic, payload) => {
-    const t = conn.topics.get(topic)
-    if (t) {
-      t.raw = payload.toString()
-      t.at = Date.now()
-    }
-  })
-  // 运行期错误/关闭:从池中驱逐并强制终止(含 mqtt.js 自动重连),下次采样自动重建。
-  // 此前一次 error 即"永久打死整池"——死连接留在池里,该 broker 下全部节点静默停采。
-  const evict = () => {
-    if (mqttPool.get(key) === conn) {
-      mqttPool.delete(key)
-      try {
-        client.end(true)
-      }
-      catch { /* 已死 */ }
-    }
-  }
-  client.on('error', evict)
-  client.on('close', evict)
-  client.on('close', () => {
-    // 断线期间清空缓存,避免恢复后消费陈旧值
-    for (const t of conn.topics.values()) {
-      t.raw = ''
-      t.at = 0
-    }
-  })
-  mqttPool.set(key, conn)
-  return conn
-}
-
-/** 从报文提取数值:纯数字直取;JSON 按路径(jsonPath,点分隔含数组下标)取 */
-export function extractNumeric(text: string, jsonPath?: string): number {
-  const trimmed = text.trim()
-  const direct = Number(trimmed)
-  if (Number.isFinite(direct) && trimmed !== '') return direct
-  const parsed: unknown = JSON.parse(trimmed)
-  const target = jsonPath
-    ? jsonPath.split('.').reduce<unknown>((acc, k) => (acc == null ? undefined : (acc as Record<string, unknown>)[k]), parsed)
-    : parsed
-  const num = typeof target === 'number' ? target : Number(target)
-  if (!Number.isFinite(num)) throw new Error(`无法提取数值(jsonPath=${jsonPath || '未配置'};报文 ${trimmed.slice(0, 60)})`)
-  return num
-}
-
-/** HTTP 请求头解析(headersJSON → Record;非法输入给可读错误) */
-export function parseHeaders(headersJSON: unknown): Record<string, string> {
-  if (!headersJSON || !String(headersJSON).trim()) return {}
-  const parsed: unknown = JSON.parse(String(headersJSON))
-  if (typeof parsed !== 'object' || parsed == null || Array.isArray(parsed)) throw new Error('headersJSON 必须是 JSON 对象')
-  const out: Record<string, string> = {}
-  for (const [k, v] of Object.entries(parsed)) out[k] = String(v)
-  return out
-}
-
-const sleep = (ms: number): Promise<void> => new Promise(r => setTimeout(r, ms))
-
-export const mqttDaqDriver: DaqDriver = {
-  kind: 'mqtt',
-  async available() {
-    try {
-      reqNative('mqtt')
-      return true
-    }
-    catch {
-      return false
-    }
-  },
-  async sample({ driverConfig }) {
-    const topic = String(driverConfig.topic ?? '')
-    if (!topic) throw new Error('缺少主题 topic')
-    const conn = await getMqttConn(driverConfig)
-    if (!conn.topics.has(topic)) {
-      conn.topics.set(topic, { raw: '', at: 0 })
-      await new Promise<void>((resolve, reject) => {
-        conn.client.subscribe(topic, (err) => {
-          if (err)
-            reject(new Error(`订阅失败: ${err.message}`))
-          else
-            resolve()
-        })
-      })
-    }
-    // 首帧等待(最多 3s):之后由消息事件持续刷新缓存
-    const entry = conn.topics.get(topic)!
-    const t0 = Date.now()
-    while (!entry.raw && Date.now() - t0 < 3000) await sleep(100)
-    if (!entry.raw) return null
-    return extractNumeric(entry.raw, driverConfig.jsonPath ? String(driverConfig.jsonPath) : undefined)
-  },
-  async test(driverConfig) {
-    const t0 = Date.now()
-    try {
-      if (!driverConfig.host) return { ok: false, message: '缺少 Broker 地址 host' }
-      if (!driverConfig.topic) return { ok: false, message: '缺少主题 topic' }
-      const conn = await getMqttConn(driverConfig)
-      const topic = String(driverConfig.topic)
-      if (!conn.topics.has(topic)) {
-        conn.topics.set(topic, { raw: '', at: 0 })
-        await new Promise<void>((resolve, reject) => {
-          conn.client.subscribe(topic, (err) => {
-            if (err)
-              reject(new Error(`订阅失败: ${err.message}`))
-            else
-              resolve()
-          })
-        })
-      }
-      const entry = conn.topics.get(topic)!
-      const t1 = Date.now()
-      while (!entry.raw && Date.now() - t1 < 4000) await sleep(100)
-      if (entry.raw) {
-        const v = extractNumeric(entry.raw, driverConfig.jsonPath ? String(driverConfig.jsonPath) : undefined)
-        return { ok: true, message: `Broker 连接成功,收到 ${topic} = ${v}`, sampleValue: v, latencyMs: Date.now() - t0 }
-      }
-      return {
-        ok: true,
-        message: `Broker 已连接并订阅 ${topic}(4s 内未收到消息;设备发布后采样即开始)`,
-        latencyMs: Date.now() - t0,
-      }
-    }
-    catch (err) {
-      return { ok: false, message: `MQTT 连接失败: ${err instanceof Error ? err.message : String(err)}` }
-    }
-  },
-}
-
-// ============================================================
-// HTTP/REST 轮询真实驱动(无状态 GET;JSON 路径或纯文本取值)
-// ============================================================
-
-export const httpDaqDriver: DaqDriver = {
-  kind: 'http',
-  async available() {
-    return true
-  },
-  async sample({ driverConfig, signalKind }) {
-    if (!driverConfig.url) throw new Error('缺少接口地址 url')
-    const headers = parseHeaders(driverConfig.headersJSON)
-    const res = await fetch(String(driverConfig.url), { headers, signal: AbortSignal.timeout(5000) })
-    if (!res.ok) throw new Error(`HTTP ${res.status}`)
-    // v2 多形态分支(vector/image 由模板信号形态门控;标量端点零感知)
-    if (signalKind === 'vector') {
-      const j: unknown = JSON.parse(await res.text())
-      const path = driverConfig.jsonPath ? String(driverConfig.jsonPath) : 'points'
-      const target = path.split('.').reduce<unknown>((acc, k) => (acc == null ? undefined : (acc as Record<string, unknown>)[k]), j)
-      if (!Array.isArray(target)) throw new Error(`vector 帧报文缺少点列(jsonPath=${path})`)
-      const points = (target as unknown[]).map(Number)
-      if (points.length === 0 || points.length > 4096 || !points.every(Number.isFinite)) {
-        throw new Error(`vector 帧点列非法(1~4096 个有限数值,实际 ${points.length})`)
-      }
-      return { frame: { kind: 'vector', points } }
-    }
-    if (signalKind === 'image') {
-      const ct = res.headers.get('content-type') ?? ''
-      if (ct.includes('image/')) {
-        const blob = Buffer.from(await res.arrayBuffer())
-        if (blob.length === 0) throw new Error('image 帧响应体为空')
-        // PNG 尺寸兜底:IHDR 宽高在固定偏移(width@16, height@20;大端)——端点不必额外传
-        let width = Number(driverConfig.width ?? 0) || 0
-        let height = Number(driverConfig.height ?? 0) || 0
-        if ((!width || !height) && blob.length >= 24 && blob.readUInt32BE(12) === 0x49484452) {
-          width = width || blob.readUInt32BE(16)
-          height = height || blob.readUInt32BE(20)
-        }
-        return { frame: { kind: 'image', blob, mime: ct.split(';')[0]!, width, height } }
-      }
-      // JSON 报文:{ png: base64, width?, height? }
-      const j = JSON.parse(await res.text()) as Record<string, unknown>
-      const b64 = typeof j.png === 'string' ? j.png : typeof j.blob === 'string' ? j.blob : ''
-      const blob = Buffer.from(b64, 'base64')
-      if (blob.length === 0) throw new Error('image 帧报文缺少 png/blob(base64)字段')
-      return { frame: { kind: 'image', blob, mime: 'image/png', width: Number(j.width ?? 0) || 0, height: Number(j.height ?? 0) || 0 } }
-    }
-    const text = await res.text()
-    return extractNumeric(text, driverConfig.jsonPath ? String(driverConfig.jsonPath) : undefined)
-  },
-  async test(driverConfig) {
-    const t0 = Date.now()
-    try {
-      if (!driverConfig.url) return { ok: false, message: '缺少接口地址 url' }
-      const headers = parseHeaders(driverConfig.headersJSON)
-      const res = await fetch(String(driverConfig.url), { headers, signal: AbortSignal.timeout(5000) })
-      if (!res.ok) return { ok: false, message: `接口返回 HTTP ${res.status}` }
-      const ct = res.headers.get('content-type') ?? ''
-      // 帧形态感知测试:同一端点形态可能是 vector(JSON 点列)/ image(PNG 或 base64)/ 标量
-      if (ct.includes('image/')) {
-        const n = (await res.arrayBuffer()).byteLength
-        return { ok: true, message: `接口可达,image 帧 ${n}B(${ct.split(';')[0]})`, latencyMs: Date.now() - t0 }
-      }
-      const text = await res.text()
-      try {
-        const j = JSON.parse(text) as Record<string, unknown>
-        if (Array.isArray(j.points) && (j.points as unknown[]).length > 0) {
-          return { ok: true, message: `接口可达,vector 帧 ${(j.points as unknown[]).length} 点`, latencyMs: Date.now() - t0 }
-        }
-        if (typeof j.png === 'string' || typeof j.blob === 'string') {
-          // 与生产分支同构:png/blob 至少一个是 base64 字符串(见上一行守卫)。
-          // b64 的取值表达式与原来逐字一致(断言运行时擦除),只是把 unknown 标注成 string 以取 .length
-          const b64 = (j.png as string | undefined) ?? (j.blob as string)
-          return { ok: true, message: `接口可达,image 帧(base64, ${b64.length} chars)`, latencyMs: Date.now() - t0 }
-        }
-        const v = extractNumeric(text, driverConfig.jsonPath ? String(driverConfig.jsonPath) : undefined)
-        return { ok: true, message: `接口可达,取值 = ${v}`, sampleValue: v, latencyMs: Date.now() - t0 }
-      }
-      catch {
-        const v = extractNumeric(text, driverConfig.jsonPath ? String(driverConfig.jsonPath) : undefined)
-        return { ok: true, message: `接口可达,取值 = ${v}`, sampleValue: v, latencyMs: Date.now() - t0 }
-      }
-    }
-    catch (err) {
-      return { ok: false, message: `HTTP 请求失败: ${err instanceof Error ? err.message : String(err)}` }
-    }
-  },
-}
-
-// ============================================================
-// S7 预留
-// ============================================================
-
-class PlannedProtocolStub implements DaqDriver {
-  constructor(
-    readonly kind: DaqDriverKind,
-    private readonly hint: string,
-  ) {}
-
-  async available() {
-    return false
-  }
-
-  async sample(): Promise<number | null> {
-    throw new Error(`DRIVER_NOT_IMPLEMENTED: ${this.hint} 协议栈尚未安装(npm i nodes7 后在 REGISTRY 注册即可)`)
-  }
-
-  async test(): Promise<DriverTestResult> {
-    return { ok: false, message: `${this.hint} 驱动尚未实现:安装 nodes7 并实现 poll 后开放` }
-  }
-}
-
-// ============================================================
-// 注册表 + 解析(旧命名归一)
-// ============================================================
-
-const REGISTRY: Record<DaqDriverKind, DaqDriver> = {
-  'mock': mockDaqDriver,
-  'modbus-tcp': modbusTcpDriver,
-  'modbus-rtu': modbusRtuDriver,
-  'opcua': opcUaDriver,
-  'mqtt': mqttDaqDriver,
-  'http': httpDaqDriver,
-  's7': new PlannedProtocolStub('s7', 'S7comm'),
-}
-
-/** 插件注册的驱动(经 ctx.daq.registerDriver;热重载重复注册幂等覆盖) */
-const g_plugins = globalThis as typeof globalThis & { __daqPluginDrivers?: Map<string, DaqDriver> }
-function pluginRegistry(): Map<string, DaqDriver> {
-  return g_plugins.__daqPluginDrivers ??= new Map()
-}
-
-/**
- * 插件驱动的自描述目录(前端「添加节点」下拉与动态参数表单的数据源)。
- * 插件驱动在 DaqDriver 上携带可选 meta(label/status/configFields,与 DaqDriverMeta 同形、
- * kind 放宽为 string);未带 meta 的插件驱动只在 meta.pluginDrivers 里以 kind 出现,
- * 前端能感知存在但不出表单(如实降级,不猜测参数 schema)。
- */
-export interface PluginDriverMeta {
-  kind: string
-  label: string
-  status: 'builtin' | 'real' | 'planned'
-  configFields?: import('../../../../shared/daq-protocol').DriverConfigField[]
-  /** true = 来自插件协议插件(前端展示「插件」徽标) */
-  plugin: true
-}
-
-const g_metas = globalThis as typeof globalThis & { __daqPluginDriverMetas?: Map<string, PluginDriverMeta> }
-function pluginMetaRegistry(): Map<string, PluginDriverMeta> {
-  return g_metas.__daqPluginDriverMetas ??= new Map()
-}
-
-/** 插件驱动注册(kind 与内置冲突时覆盖并告警;resolveDaqDriver 插件优先) */
-export function registerPluginDriver(driver: DaqDriver): void {
-  if (driver.kind in REGISTRY) log.warn(`[daq-drivers] 插件驱动覆盖内置:「${driver.kind}」`)
-  pluginRegistry().set(driver.kind, driver)
-  const meta = (driver as DaqDriver & { meta?: Omit<PluginDriverMeta, 'kind' | 'plugin'> }).meta
-  if (meta && typeof meta.label === 'string') {
-    pluginMetaRegistry().set(driver.kind, {
-      kind: driver.kind,
-      label: meta.label,
-      status: meta.status === 'builtin' || meta.status === 'planned' ? meta.status : 'real',
-      configFields: Array.isArray(meta.configFields) ? meta.configFields : [],
-      plugin: true,
-    })
-  }
-  else {
-    // 同名驱动重注册(热重载)可能这次不带 meta:旧 meta 一并清除,保持两边一致
-    pluginMetaRegistry().delete(driver.kind)
-  }
-}
-
-export function listPluginDrivers(): string[] {
-  return [...pluginRegistry().keys()]
-}
-
-/**
- * 清空插件驱动与自描述目录(插件宿主热重载前调用):停用/卸载的插件驱动随之失效,
- * 只有本轮重新装载成功的插件驱动会再注册进来 —— 否则被停用的驱动会一直生效到进程重启。
- */
-export function clearPluginDrivers(): void {
-  pluginRegistry().clear()
-  pluginMetaRegistry().clear()
-}
-
-/** 插件驱动自描述目录(驱动目录合并端点用;热重载随重注册刷新) */
-export function listPluginDriverMetas(): PluginDriverMeta[] {
-  return [...pluginMetaRegistry().values()]
-}
-
-export function normalizeDriverKind(kind: string): DaqDriverKind {
-  if (kind === 'modbus') return 'modbus-tcp'
-  if (kind === 'rtu' || kind === 'modbus-rtu-tcp') return 'modbus-rtu'
-  return (kind in REGISTRY || pluginRegistry().has(kind) ? kind : 'mock') as DaqDriverKind
-}
-
-export function resolveDaqDriver(kind: DaqDriverKind): DaqDriver {
-  return pluginRegistry().get(kind) ?? REGISTRY[kind] ?? mockDaqDriver
-}
-
-/** 驱动可用性探测(meta 报告:包缺失时 UI 显示"未安装"而非硬失败;含插件驱动) */
-export async function probeDriverAvailability(): Promise<Record<string, boolean>> {
-  const out: Record<string, boolean> = {}
-  const all: Array<[string, DaqDriver]> = [...Object.entries(REGISTRY), ...pluginRegistry()]
-  for (const [kind, drv] of all) {
-    try {
-      out[kind] = await drv.available()
-    }
-    catch {
-      out[kind] = false
-    }
-  }
-  return out
-}
-
-/**
- * 驱动目录合并(内置 DAQ_DRIVERS + 插件自描述;同名插件条目覆盖内置并标记 plugin)。
- * index.get.ts 以 `drivers` 下发,前端据此渲染「添加节点」下拉与动态参数表单。
- */
-export async function driverCatalog(): Promise<Array<{
-  kind: string
-  label: string
-  status: 'builtin' | 'real' | 'planned'
-  configFields: import('../../../../shared/daq-protocol').DriverConfigField[]
-  plugin?: boolean
-}>> {
-  const out: Array<{ kind: string, label: string, status: 'builtin' | 'real' | 'planned', configFields: import('../../../../shared/daq-protocol').DriverConfigField[], plugin?: boolean }> = DAQ_DRIVERS.map(d => ({
-    kind: d.kind,
-    label: d.label,
-    status: d.status,
-    configFields: d.configFields,
-  }))
-  for (const m of listPluginDriverMetas()) {
-    const i = out.findIndex(d => d.kind === m.kind)
-    const entry = { kind: m.kind, label: m.label, status: m.status, configFields: m.configFields ?? [], plugin: true }
-    if (i >= 0) out[i] = entry
-    else out.push(entry)
-  }
-  return out
-}