dsh-router-core 0.4.7 → 0.4.9

package/src/client/ExtTestPanel.tsx

@@ -1,392 +0,0 @@
-/**
- * 插件自检面板 —— 扩展「插件自检」(`dsh-router-ext-test` / 扩展 id `test`) 的详情内容。
- *
- * **入口只有一处**：设置 → 路由 → 扩展 → 点开「插件自检」那张卡片（`ExtDetail` 查
- * `ext-panels.ts` 的注册表拿到本组件）。
- *
- * 刻意**不给插件页那一行也挂一个详情页**：那一行的宿主行开关已经能开/关它，再点进去
- * 看同一块面板就是同一个东西有两个入口 —— 与「内置扩展不在自绘节里重复列」同理。
- * 插件页那一行只负责开关。
- *
- * 视觉上照着宿主的插件页写（`--dsw-alias-*` 那套 token），**不复用设置页的
- * `dshr-*` 组件样式**：那些样式依赖 `--rs-*` 变量，而那套变量只定义在
- * `.dshr-settings` / `.dshr-shell` 下，插件页不在其祖先里（未定义的 `var()` 会让
- * 整条声明失效）。按钮直接用宿主的 `Button` 原语 —— 配色由原语自己的 token 家族
- * 决定，不必在这里猜「主色底上该配什么字色」。
- */
-import { useEffect, useState } from 'react'
-import { Button } from '@deepseek-ai/dsh-client-ui-primitives'
-import { ROUTER_API_BASE, type RouterAccount, type RouterHealthResponse } from '../shared.ts'
-import { modelChoice, type ModelRow } from './model-choice.ts'
-import type { ProbeReport } from '../suppliers/probe.ts'
-
-/** 一次测试的结果。`ok` 为 false 时 `error` 是核心给的真实原因（上游响应 / chatOnce message）。 */
-interface TestResult {
-  ok: boolean
-  error?: string
-  /** 实际测的是哪个连接（空串 = 池内任选，与面板「测试」按钮同义）。 */
-  uid: string
-  /** 测的时候选的是哪三样，回显出来 —— 一条「通过」必须可归因。 */
-  supplier: string
-  model: string
-}
-
-/** 结果区的一个状态。`network` 是请求本身失败，与「上游拒了」分开。 */
-type Notice =
-  | { tone: 'ok'; result: TestResult }
-  | { tone: 'fail'; result: TestResult }
-  | { tone: 'network'; text: string }
-
-/** 每个契约成员状态的字形（颜色由 data-state 给）。 */
-/** 模型启用状态那一行属于核心侧，没在 members 里，状态由「拿不拿得到」决定。 */
-function coreModelsState(report: ProbeReport): ProbeReport['members'][number]['state'] {
-  return report.core.models.total === null ? 'unverified' : 'ok'
-}
-
-const MEMBER_MARK: Record<ProbeReport['members'][number]['state'], string> = {
-  ok: '✓',
-  fail: '✕',
-  absent: '–',
-  unverified: '⊘',
-}
-
-const TONE_ICON: Record<Notice['tone'], string> = {
-  ok: 'M20 6L9 17l-5-5',
-  fail: 'M18 6L6 18M6 6l12 12',
-  network: 'M12 9v4m0 4h.01M10.3 3.9L2 18a2 2 0 003 2h16a2 2 0 002-2L13.7 3.9a2 2 0 00-3.4 0z',
-}
-
-function Glyph({ d }: { d: string }): JSX.Element {
-  return (
-    <svg className="dshr-compNoticeIcon" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2"
-      strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
-      <path d={d} />
-    </svg>
-  )
-}
-
-/** 三个下拉里的一栏：标题行（可带右侧小注）+ 控件。`emptyHint` 在没得选时说明「为什么没有」。 */
-function Picker(props: {
-  label: string
-  /** 标题右侧的小注（这一栏的用法要点，比塞进顶部那段长文字更容易被读到）。 */
-  note?: string
-  value: string
-  options: Array<{ value: string; label: string }>
-  emptyHint: string
-  disabled?: boolean
-  onChange: (value: string) => void
-}): JSX.Element {
-  const empty = props.options.length === 0
-  return (
-    <div className="dshr-compField">
-      <div className="dshr-compFieldHead">
-        <label className="dshr-compFieldLabel">{props.label}</label>
-        {props.note !== undefined && <span className="dshr-compFieldNote">{props.note}</span>}
-      </div>
-      <select
-        className="dshr-compSelect"
-        value={props.value}
-        disabled={props.disabled === true || empty}
-        aria-label={props.label}
-        onChange={(e) => { props.onChange(e.target.value) }}
-      >
-        {empty
-          ? <option value="">{props.emptyHint}</option>
-          : <>
-            <option value="">请选择</option>
-            {props.options.map((o) => <option key={o.value} value={o.value}>{o.label}</option>)}
-          </>}
-      </select>
-    </div>
-  )
-}
-
-export function ExtTestPanel(): JSX.Element {
-  const [suppliers, setSuppliers] = useState<NonNullable<RouterHealthResponse['suppliers']>>([])
-  const [accounts, setAccounts] = useState<RouterAccount[]>([])
-  const [models, setModels] = useState<{ ids: string[]; empty?: 'none' | 'all-disabled' }>({ ids: [] })
-  const [supplierId, setSupplierId] = useState('')
-  const [modelId, setModelId] = useState('')
-  const [uid, setUid] = useState('')
-  const [busy, setBusy] = useState(false)
-  const [notice, setNotice] = useState<Notice | null>(null)
-  const [loaded, setLoaded] = useState(false)
-  // 契约体检：只针对**外部供应商插件**（内置供应商随核心分发，没有独立插件可体检）
-  const [pluginId, setPluginId] = useState('')
-  const [probing, setProbing] = useState(false)
-  const [report, setReport] = useState<ProbeReport | null>(null)
-  const [probeError, setProbeError] = useState('')
-
-  // 供应商与连接各读一次：/health 给供应商（开着的那批，与面板一致），
-  // /status 给账号（uid + 昵称 + 冷却状态）。
-  useEffect(() => {
-    let live = true
-    void (async () => {
-      try {
-        const [health, status] = await Promise.all([
-          fetch(`${ROUTER_API_BASE}/health`, { cache: 'no-store' }).then((r) => r.json() as Promise<RouterHealthResponse>),
-          fetch(`${ROUTER_API_BASE}/status`, { cache: 'no-store' }).then((r) => r.json() as Promise<{ ok: boolean; accounts?: RouterAccount[] }>),
-        ])
-        if (!live) return
-        setSuppliers((health.suppliers ?? []).filter((s) => s.enabled !== false))
-        setAccounts(status.ok ? (status.accounts ?? []) : [])
-      } catch (err) {
-        if (live) setNotice({ tone: 'network', text: (err as Error).message })
-      } finally {
-        if (live) setLoaded(true)
-      }
-    })()
-    return () => { live = false }
-  }, [])
-
-  // 换供应商 → 重拉模型、清掉模型/连接选择与旧结果（旧结果对新选择没有意义，
-  // 留着会被误读成「刚测过这个」）。
-  useEffect(() => {
-    setModelId('')
-    setUid('')
-    setNotice(null)
-    if (supplierId === '') { setModels({ ids: [] }); return }
-    let live = true
-    void (async () => {
-      try {
-        const data = await fetch(`${ROUTER_API_BASE}/suppliers/${encodeURIComponent(supplierId)}/models`, { cache: 'no-store' })
-          .then((r) => r.json() as Promise<{ ok: boolean; models?: ModelRow[] }>)
-        // 端点给的是**全部**模型（含用户停用的），这里只取可用的 —— 见 model-choice.ts
-        if (live) setModels(data.ok ? modelChoice(data.models ?? []) : { ids: [] })
-      } catch {
-        if (live) setModels({ ids: [] })
-      }
-    })()
-    return () => { live = false }
-  }, [supplierId])
-
-  // 外部供应商插件 = source 为 external 的那些（内置随核心分发，不进这个下拉）
-  const pluginSuppliers = suppliers.filter((x) => x.source === 'external')
-
-  const runProbe = async (): Promise<void> => {
-    if (pluginId === '' || probing) return
-    setProbing(true)
-    setProbeError('')
-    setReport(null)
-    try {
-      const response = await fetch(`${ROUTER_API_BASE}/suppliers/${encodeURIComponent(pluginId)}/probe`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({}),
-        cache: 'no-store',
-      })
-      const data = await response.json() as { ok: boolean; error?: string; report?: ProbeReport }
-      if (data.ok && data.report !== undefined) setReport(data.report)
-      else setProbeError(data.error ?? '体检失败')
-    } catch (err) {
-      setProbeError((err as Error).message)
-    } finally {
-      setProbing(false)
-    }
-  }
-
-  const links = accounts.filter((a) => a.supplier === supplierId)
-  const runnable = supplierId !== '' && modelId !== ''
-  const supplierName = suppliers.find((s) => s.id === supplierId)?.name ?? supplierId
-
-  const run = async (): Promise<void> => {
-    if (!runnable || busy) return
-    setBusy(true)
-    setNotice(null)
-    try {
-      const response = await fetch(`${ROUTER_API_BASE}/suppliers/${encodeURIComponent(supplierId)}/models/test`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        // uid 留空 = 池内任选可用号（与面板「测试」按钮同义）；选了 = 只测它。
-        body: JSON.stringify({ id: modelId, uid }),
-        cache: 'no-store',
-      })
-      const data = await response.json() as { ok: boolean; error?: string }
-      const result: TestResult = {
-        ok: data.ok,
-        uid,
-        supplier: supplierName,
-        model: modelId,
-        ...(data.error === undefined ? {} : { error: data.error }),
-      }
-      setNotice({ tone: data.ok ? 'ok' : 'fail', result })
-    } catch (err) {
-      setNotice({ tone: 'network', text: (err as Error).message })
-    } finally {
-      setBusy(false)
-    }
-  }
-
-  return (
-    <div className="dshr-tabBody dshr-comp">
-      {/* 两节各自有标题：两个按钮都叫「测试」，没有标题就分不清点的是哪一个 */}
-      <div className="dshr-compHead">
-        <h4 className="dshr-compSectionTitle">连接测试</h4>
-        <span className="dshr-compSectionNote">选供应商 / 模型 / 连接</span>
-      </div>
-
-      <div className="dshr-compForm">
-        <Picker
-          label="供应商"
-          value={supplierId}
-          options={suppliers.map((s) => ({ value: s.id, label: s.name }))}
-          emptyHint={loaded ? '没有已启用的供应商' : '加载中…'}
-          onChange={setSupplierId}
-        />
-        <Picker
-          label="模型"
-          note="仅可用"
-          value={modelId}
-          options={models.ids.map((id) => ({ value: id, label: id }))}
-          emptyHint={supplierId === ''
-            ? '先选供应商'
-            : models.empty === 'all-disabled'
-              ? '模型都被停用了（在供应商详情里开启）'
-              : models.empty === 'none' ? '没有模型（可先在供应商详情里拉取）' : '请选择'}
-          disabled={supplierId === ''}
-          onChange={(v) => { setModelId(v); setNotice(null) }}
-        />
-        <Picker
-          label="连接"
-          note="留空 = 池内任选"
-          value={uid}
-          options={links.map((a) => ({
-            value: a.uid,
-            label: `${a.nickname ?? a.uid}${a.cooling ? '（冷却中）' : ''}`,
-          }))}
-          emptyHint={supplierId === '' ? '先选供应商' : '没有连接（留空则不指定）'}
-          disabled={supplierId === ''}
-          onChange={(v) => { setUid(v); setNotice(null) }}
-        />
-      </div>
-
-      <div className="dshr-compActions dshr-compBtnRow">
-        <Button
-          variant="primary"
-          size="md"
-          disabled={!runnable || busy}
-          onClick={() => { void run() }}
-        >
-          {busy ? '测试中…' : '测试'}
-        </Button>
-        {!runnable && <span className="dshr-compHint">先选供应商与模型</span>}
-      </div>
-
-      {notice !== null && (
-        <div className="dshr-compNotice" data-tone={notice.tone} role="status">
-          <Glyph d={TONE_ICON[notice.tone]} />
-          <div className="dshr-compNoticeBody">
-            {notice.tone === 'network' ? (
-              <>
-                <div className="dshr-compNoticeTitle">请求失败</div>
-                <div className="dshr-compNoticeText">{notice.text}</div>
-              </>
-            ) : (
-              <>
-                <div className="dshr-compNoticeTitle">
-                  {notice.tone === 'ok' ? '测试通过' : '测试失败'}
-                </div>
-                <div className="dshr-compNoticeText">
-                  {notice.tone === 'ok'
-                    ? '这个连接能正常访问该模型。'
-                    : (notice.result.error ?? '上游没有给出原因')}
-                </div>
-                {/* 回显测的是哪三样：一条「通过」如果不带对象，就是没法归因的一串绿字。 */}
-                <div className="dshr-compNoticeMeta">
-                  {notice.result.supplier} · {notice.result.model} · {notice.result.uid === '' ? '池内任选' : notice.result.uid}
-                </div>
-              </>
-            )}
-          </div>
-        </div>
-      )}
-
-      {/* ---- 契约体检：外部供应商插件的每个契约成员 ---- */}
-      <div className="dshr-compSection">
-        <div className="dshr-compHead">
-          <h4 className="dshr-compSectionTitle">插件测试</h4>
-          <span className="dshr-compSectionNote">外部供应商插件</span>
-        </div>
-        <p className="dshr-compIntro">前提：连接池里先有一个可用 token，剩下交给它。</p>
-        <div className="dshr-compProbeRow">
-          <Picker
-            label="供应商插件"
-            value={pluginId}
-            options={pluginSuppliers.map((x) => ({ value: x.id, label: x.name }))}
-            emptyHint={pluginSuppliers.length === 0 ? '没有装外部供应商插件' : '请选择'}
-            onChange={(v) => { setPluginId(v); setReport(null); setProbeError('') }}
-          />
-          <div className="dshr-compProbeBtn dshr-compBtnRow">
-            <Button variant="primary" size="md" disabled={pluginId === '' || probing} onClick={() => { void runProbe() }}>
-              {probing ? '测试中…' : '测试'}
-            </Button>
-          </div>
-        </div>
-
-        {probeError !== '' && (
-          <div className="dshr-compNotice" data-tone="network" role="status">
-            <Glyph d={TONE_ICON.network} />
-            <div className="dshr-compNoticeBody">
-              <div className="dshr-compNoticeTitle">体检失败</div>
-              <div className="dshr-compNoticeText">{probeError}</div>
-            </div>
-          </div>
-        )}
-
-        {report !== null && (
-          <div className="dshr-compReport">
-            <div className="dshr-compReportHead">
-              <span className="dshr-compReportName">{report.name}</span>
-              {/* 只报数字，不下判词。合格与否是判断，应当由看报告的人自己做 ——
-                  工具给数字和逐条事实就够，替人定性既越位，也会在判据本身有偏差
-                  时把话说死。 */}
-              <span className="dshr-compReportSum">
-                共 {report.summary.total} 个 · 实现 {report.summary.implemented} · 实跑 {report.summary.ran} · 通过 {report.summary.ok} · 失败 {report.summary.fail} · 未验 {report.summary.unverified} · 未实现 {report.summary.absent}
-                {report.summary.bulk === 'fail' ? ' · 全部启用/禁用有问题' : report.summary.bulk === 'ok' ? ' · 全部启用/禁用通过' : ''}
-              </span>
-            </div>
-            <ul className="dshr-compMembers">
-              {/* 核心侧那两项与契约成员**同构**（同一个列表、同一种行），只是它们不属于
-                  插件契约（是核心代劳）。原先给它们单画了个带框的区块，反而让它们看着
-                  像是另一个模块、比真问题还显眼。 */}
-              <li className="dshr-compMember" data-state={coreModelsState(report)}>
-                <span className="dshr-compMemberState" aria-hidden="true">{MEMBER_MARK[coreModelsState(report)]}</span>
-                <span className="dshr-compMemberName">
-                  模型启用状态
-                  <code className="dshr-compMemberKey">core</code>
-                </span>
-                <span className="dshr-compMemberDetail">
-                  {report.core.models.total === null
-                    ? (report.core.models.note ?? '拿不到')
-                    : `共 ${report.core.models.total} 个 · 启用 ${report.core.models.enabled} · 停用 ${report.core.models.disabled}`}
-                </span>
-              </li>
-              {report.core.operations.map((o) => (
-                <li key={o.key} className="dshr-compMember" data-state={o.ran === false ? 'unverified' : o.ok === true ? 'ok' : 'fail'}>
-                  <span className="dshr-compMemberState" aria-hidden="true">
-                    {MEMBER_MARK[o.ran === false ? 'unverified' : o.ok === true ? 'ok' : 'fail']}
-                  </span>
-                  <span className="dshr-compMemberName">
-                    {o.label}
-                    <code className="dshr-compMemberKey">core</code>
-                  </span>
-                  <span className="dshr-compMemberDetail">{o.detail}</span>
-                </li>
-              ))}
-              {report.members.map((m) => (
-                <li key={m.key} className="dshr-compMember" data-state={m.state}>
-                  <span className="dshr-compMemberState" aria-hidden="true">{MEMBER_MARK[m.state]}</span>
-                  <span className="dshr-compMemberName">
-                    {m.label}
-                    <code className="dshr-compMemberKey">{m.key}</code>
-                  </span>
-                  <span className="dshr-compMemberDetail">{m.detail ?? ''}</span>
-                </li>
-              ))}
-            </ul>
-          </div>
-        )}
-      </div>
-    </div>
-  )
-}

package/src/client/comp-button-scope.test.ts

@@ -1,58 +0,0 @@
-/**
- * 面板按钮的字色判据 —— 锁住「每个按钮都在那条抬特异性的规则覆盖范围内」。
- *
- * ## 为什么需要这条
- *
- * 宿主的 `Button` 原语在 `primary` 变体里要把字色设成
- * `--dsw-alias-label-primary-foreground`，但 `router.css` 顶部那条兜底
- * `.dshr-settings button { color: inherit; font: inherit }` 特异性 (1,1) **高于**
- * 原语的 (1,0)，赢的是它 —— 于是按钮变「#0f1115 底 + 继承来的 #0f1115 字」，
- * **黑底黑字**。这个插件已经因此翻车两次：第一次是访问测试按钮，第二次是新增的
- * 契约体检按钮（上一版修复只挂在 `.dshr-compActions` 上，新按钮在另一个容器里，
- * 规则没盖到）。症状完全一样、且不报任何错。
- *
- * 修法是给每个动作行挂 `dshr-compBtnRow`，由一条 (2,1) 的规则统一还原字色。
- * （这个类名特意**不是** `dshr-compActions` 的前缀：否则下面按子串计数会把它
- * 一起算进去，判据自己就成了摆设。）
- * 那么「新增按钮忘了挂这个类」就会退化成同样的黑底黑字 —— 这条判据就是拦它的。
- */
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-const panel = readFileSync(fileURLToPath(new URL('./ExtTestPanel.tsx', import.meta.url)), 'utf8')
-const css = readFileSync(fileURLToPath(new URL('./router.css', import.meta.url)), 'utf8')
-
-test('面板里每个 Button 都在一个带 dshr-compBtnRow 的动作行里', () => {
-  // 一个动作行可以放多个按钮（「只读体检」+「深度体检」并排），所以判据是
-  // **每个 Button 在源码里都处于某个 dshr-compBtnRow 容器之内** —— 早期版本
-  // 用「按钮数 == 行数」来近似，被并排两个按钮的布局直接顶红了（这正是它的价值：
-  // 假设一旦不成立就会暴露，而不是继续绿）。
-  const opens = [...panel.matchAll(/<div className="([^"]*)">/g)].map((m) => m[1])
-  const rows = opens.filter((c) => (c ?? '').includes('dshr-compBtnRow')).length
-  assert.ok(rows > 0, '面板里应当有动作行（这条判据才有意义）')
-  const buttons = [...panel.matchAll(/<Button\b/g)]
-  assert.ok(buttons.length > 0, '面板里应当有 Button')
-  for (const b of buttons) {
-    const before = panel.slice(0, b.index)
-    // 取该 Button 之前最近一个开着的 <div>，看它是不是动作行
-    const nearest = [...before.matchAll(/<div className="([^"]*)">/g)].pop()
-    assert.ok((nearest?.[1] ?? '').includes('dshr-compBtnRow'),
-      `有一个 Button 不在任何 dshr-compBtnRow 动作行里（最近的容器：${nearest?.[1] ?? '无'}）—— 会变回黑底黑字`)
-  }
-})
-
-test('那条字色规则挂在共用类上（不能再写死某个容器）', () => {
-  assert.match(css, /\.dshr-comp \.dshr-compBtnRow button\s*\{/,
-    '字色规则必须挂在 .dshr-compBtnRow 上：写死某个容器的话，下次新增按钮换个容器就漏')
-  assert.match(css, /\.dshr-comp \.dshr-compBtnRow button\s*\{[^}]*color:\s*var\(--dsw-alias-label-primary-foreground\)/,
-    '字色仍由原语那个 token 决定，不自己另挑一个颜色')
-})
-
-test('规则特异性高于那条兜底（不依赖源码顺序）', () => {
-  // 兜底 = `.dshr-settings button` (1,1)；本规则 = `.dshr-comp .dshr-compBtnRow button` (2,1)
-  const rule = css.match(/(\.[\w-]+)\s+(\.[\w-]+)\s+button\s*\{[^}]*color:\s*var\(--dsw-alias-label-primary-foreground\)/)
-  assert.ok(rule !== null, '找不到那条字色规则')
-  assert.notEqual(rule[1], '.dshr-settings', '不能和兜底规则同容器 —— 同特异性就变成靠源码顺序了')
-})

package/src/client/comp-panel-layout.test.ts

@@ -1,58 +0,0 @@
-/**
- * 插件自检面板的**版面**判据 —— 不是像素级的样式测试，是「结构上别退回去」。
- *
- * 背景：核心侧那两项（模型启用状态 / 全部启用禁用）原先单独画了个带框的区块
- * （`.dshr-compCore`，加粗、垫底色、单独一栏）。看着比真问题还显眼，而它们本来就是
- * 体检结果的一部分，用户要的是「一眼扫完」。所以并进契约成员那一份列表，同一种行。
- */
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-const panel = readFileSync(fileURLToPath(new URL('./ExtTestPanel.tsx', import.meta.url)), 'utf8')
-const css = readFileSync(fileURLToPath(new URL('./router.css', import.meta.url)), 'utf8')
-
-test('核心侧那两项和契约成员同构：不另起区块', () => {
-  assert.equal(/className="dshr-compCore"/.test(panel), false,
-    '核心侧不该有自己的区块 —— 要和契约成员用同一份列表、同一种行')
-  assert.equal(/\.dshr-compCore\s*\{/.test(css), false, '核心侧区块的样式也该删掉')
-})
-
-test('「模型启用状态」和「全部启用/禁用」都渲染成 dshr-compMember 行', () => {
-  const rowCount = (panel.match(/className="dshr-compMember"/g) ?? []).length
-  assert.ok(rowCount >= 3, '至少要有：模型启用状态、全部启用禁用、契约成员各自的行')
-  assert.match(panel, /模型启用状态/, '模型启用状态要在面板上出现')
-  assert.match(panel, /report\.core\.operations\.map/, '全部启用/禁用由 core.operations 渲染')
-})
-
-test('面板顶部说明是一句话（不是写给维护者的长篇）', () => {
-  const intro = panel.match(/<p className="dshr-compIntro">([\s\S]*?)<\/p>/g) ?? []
-  for (const block of intro) {
-    const text = block.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim()
-    assert.ok(text.length <= 60, `说明要一句话（现在 ${text.length} 字）：${text}`)
-  }
-})
-
-test('两节各有一个标题，两个按钮都叫「测试」（否则分不清点的是哪一个）', () => {
-  // 两个按钮同名是有意的（用户就是要一个统一的动词），代价是两节必须有标题来区分
-  assert.match(panel, /<h4 className="dshr-compSectionTitle">连接测试<\/h4>/, '第一节要有标题')
-  assert.match(panel, /<h4 className="dshr-compSectionTitle">插件测试<\/h4>/, '第二节叫「插件测试」')
-  assert.equal((panel.match(/'测试'|'测试中…'/g) ?? []).length, 4,
-    '两节各一对（常态 + 进行中）')
-  assert.equal(panel.includes('跑一次访问测试'), false, '旧的按钮长称别回来')
-  assert.equal(panel.includes('跑一次出厂体检'), false, '旧的按钮长称别回来')
-  assert.equal(panel.includes('插件契约体检'), false, '旧的节名别回来')
-})
-
-test('报告头只给数字，不给判词（合格/不合格该由看报告的人自己下）', () => {
-  for (const word of ['可以出厂', '不合格', '有未验项', '结论']) {
-    assert.equal(panel.includes(word), false, `判词「${word}」不该出现在面板上`)
-  }
-  assert.equal(panel.includes('dshr-compVerdict'), false, '徽标整块删掉')
-  assert.equal(/\.dshr-compVerdict/.test(css), false, '徽标样式也删掉')
-  // 数字要够：实跑数与「未验」都不能少 —— 没条件验的项混进「通过」就是撒谎
-  for (const field of ['total', 'implemented', 'ran', 'ok', 'fail', 'unverified', 'absent', 'bulk']) {
-    assert.match(panel, new RegExp(`summary\\.${field}`), `汇总里要能看到 ${field}`)
-  }
-})

package/src/client/ext-panels.test.ts

@@ -1,44 +0,0 @@
-/**
- * 扩展开放详情面板的注册表测试。
- *
- * 为什么要测：注册表错了**不报任何错** —— 详情页只是安静地退回通用只读页，
- * 用户看到的是「面板没出来」，没有任何线索指向「面板没被登记」。所以「登记 →
- * 取用 → 清理」这条链要钉住。
- */
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { registerExtPanel, hasExtPanel, extPanel } from './ext-panels.ts'
-
-const A = (): null => null
-const B = (): null => null
-
-test('登记后能按扩展 id 取到同一个组件', () => {
-  const dispose = registerExtPanel('t-a', A)
-  assert.equal(hasExtPanel('t-a'), true)
-  assert.equal(extPanel('t-a'), A, '取到的必须就是登记进去的那个（两处详情页共用同一份）')
-  dispose()
-})
-
-test('没登记的扩展取不到（调用方据此走通用只读页）', () => {
-  assert.equal(hasExtPanel('t-missing'), false)
-  assert.equal(extPanel('t-missing'), undefined)
-})
-
-test('重复登记同 id：后者顶掉前者（apply 可能跑多次）', () => {
-  const first = registerExtPanel('t-b', A)
-  const second = registerExtPanel('t-b', B)
-  assert.equal(extPanel('t-b'), B)
-  first()
-  assert.equal(extPanel('t-b'), B, '清理旧的那次不该把新登记的也删掉')
-  second()
-  assert.equal(extPanel('t-b'), undefined)
-})
-
-test('清理只删自己那次登记', () => {
-  const first = registerExtPanel('t-c', A)
-  const disposeB = registerExtPanel('t-c', B)
-  first()
-  assert.equal(extPanel('t-c'), B, '旧登记被顶掉后，它的清理不该误删新登记')
-  disposeB()
-  assert.equal(hasExtPanel('t-c'), false)
-})

package/src/client/ext-panels.ts

@@ -1,49 +0,0 @@
-/**
- * 扩展自带详情面板的注册表 —— 客户端，按扩展 id 索引。
- *
- * 为什么要有这个：`router.ext` 契约里只有 `id / name / description / icon /
- * getState`，**没有「自带详情内容」的口子**。于是扩展详情页（设置 → 路由 → 扩展 →
- * 点开卡片）只能是一张写死的只读页：名字、id、状态、一段说明，扩展自己想放的
- * 东西（要选的模型、要跑的测试、要看的诊断）**没地方放**。
- *
- * 本表就是那个口子：扩展（按扩展 id）登记一个组件，详情页优先渲染它。
- *
- * 两处详情页共用它，两处都以扩展 id 为键，所以**同一个面板注册一次**：
- *   - 设置 → 路由 → 扩展：卡片点开的详情页（`ExtDetail`）
- *   - 设置 → 插件 → dsh-router-core：「包含的组件」里那一行的详情页
- *     （宿主的 `plugins.row.config` 座位，key 是 `<包名>#<行 id>`，与扩展 id 不同，
- *     所以那一处由注册处用一个薄适配器转接，不在这里登记第二份）
- *
- * 这是**客户端**注册表（不是 cordis service）：扩展的服务端对象活在宿主进程里，
- * 面板是浏览器里的组件，两边不在一个地址空间。模块级 Map 够用 —— 面板在单个
- * client bundle 里，模块只有一份实例。
- */
-import type { FC } from 'react'
-
-/** 扩展 id → 它的详情面板。 */
-const panels = new Map<string, FC>()
-
-/**
- * 给某个扩展登记详情面板。同 id 后登记的**顶掉**先登记的（热重载/重复 apply
- * 时的常见情形）；返回清理函数。
- *
- * @param extId - 扩展 id（`router.ext` 表里的键）
- * @param panel - 详情面板组件。**不收 props**：面板的渲染点只有详情页一处
- *   （`ExtDetail`），没有第二种调用形状。
- */
-export function registerExtPanel(extId: string, panel: FC): () => void {
-  panels.set(extId, panel)
-  return () => {
-    if (panels.get(extId) === panel) panels.delete(extId)
-  }
-}
-
-/** 某个扩展是否自带详情面板。 */
-export function hasExtPanel(extId: string): boolean {
-  return panels.has(extId)
-}
-
-/** 取某个扩展的详情面板；没登记返回 undefined（调用方据此走通用只读页）。 */
-export function extPanel(extId: string): FC | undefined {
-  return panels.get(extId)
-}

package/src/client/model-choice.test.ts

@@ -1,41 +0,0 @@
-/**
- * 「只列可用模型」这条判据的测试。
- *
- * 为什么要有：错了不会抛异常、不会白屏，只是下拉里多了几个用户明明关掉的模型 ——
- * 挑中一个去测，测通了也不代表配置是对的，而用户看不出自己挑错了。
- */
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { modelChoice } from './model-choice.ts'
-
-test('只列用户没停用的模型（端点给的是全部模型）', () => {
-  const c = modelChoice([
-    { id: 'a', enabled: true },
-    { id: 'b', enabled: false },
-    { id: 'c', enabled: true },
-    { id: 'd', enabled: false },
-  ])
-  assert.deepEqual(c.ids, ['a', 'c'])
-  assert.equal(c.empty, undefined)
-})
-
-test('保持端点给的顺序（端点已按优先级排好，重排会毁掉它）', () => {
-  const c = modelChoice([{ id: 'z', enabled: true }, { id: 'a', enabled: true }])
-  assert.deepEqual(c.ids, ['z', 'a'])
-})
-
-test('缺 enabled 按「未停用」读 —— 不凭空把模型藏起来', () => {
-  const c = modelChoice([{ id: 'a' }, { id: 'b', enabled: false }])
-  assert.deepEqual(c.ids, ['a'])
-})
-
-test('一个模型都没有 vs 全被停用：两种空得指去不同的地方', () => {
-  assert.equal(modelChoice([]).empty, 'none', '没模型 → 该去拉取')
-  assert.equal(modelChoice([{ id: 'a', enabled: false }]).empty, 'all-disabled', '有模型但全关 → 该去开启')
-})
-
-test('全停用时 ids 为空，不会把停用的模型漏进下拉', () => {
-  const c = modelChoice([{ id: 'a', enabled: false }, { id: 'b', enabled: false }])
-  assert.deepEqual(c.ids, [])
-  assert.equal(c.empty, 'all-disabled')
-})