dsh-panel-control 0.7.2 → 0.9.1

package/docs/bridged-settings-pages.md

@@ -0,0 +1,85 @@
+# 设置页补入口：怎么识别，怎么渲染
+
+## 问题
+
+宿主把「侧栏面板」和「设置页」做成两套注册：
+
+- 面板入口 = `sidebar.panellist` 里的一行图标 + 同 id 的 root 作用域 `main` keyed 条目；
+- 设置页 = `settings.section` 里的一个 id。
+
+多数插件两者都注册。少数只注册 `settings.section`，于是它的页面只能从设置弹窗里翻到——
+侧栏没有入口，也没法被单独选中。设置弹窗的打开状态是宿主私有的，没有公开 API 能直接定位到
+某个 section，所以「点一行就打开那个设置页」只能由本插件自己造一页。
+
+## 识别
+
+宿主的槽条目确实带有 `registrant`，但在当前客户端里它**不能用来区分插件**：client runner 把
+大量插件放在同一个 fiber 里 apply，实测 `account/general/models/plugins/agent-presets` 以及
+`plan-mode`、`bili`、`workspace-control-settings`、`composer-rewind-settings` 这些设置页的
+`registrant` 都是同一个 `tk`，侧栏里大多数行也是 `tk`；只有插件市场是它自己的 `dsh-market`。
+按 registrant 过滤会把所有第三方设置页都当成「已有入口」。
+
+因此改为按**侧栏归属**判断，一个设置页有入口当且仅当满足任一条：
+
+1. 它的 id 等于某个 `sidebar.panellist` 的 id；
+2. 去掉末尾 `-settings` 后的 id 等于某个面板 id（`panel-control-settings` ↔ `panel-control`）；
+3. 某个面板 id 以 `-<id>` 结尾（`market` ↔ `dsh-market`）；
+4. 它的 label 与某个面板 label 相同（`market` / `workspace-control-settings` 都命中）。
+
+内置设置页没有面板，因此单独列一组 id 排除：`account`、`general`、`models`、`agent-presets`、
+`plugins`（`plugins` 同时也有面板，列在这里只是双保险）。剩下的每个 section 补一行，id 为
+`dpc-bridge-<section id>`，order 85（在普通入口之后、本插件之前）。标题取该 section 的 label；
+与已有行撞名时追加 ` · <section id>`。
+
+这套判断不读第三方包内部文件，也不依赖插件白名单；代价是**启发式**：一个第三方设置页若恰好
+与某个面板同名/id 同源，会被当成已有入口；未来新增的内置设置页若不在上面的 id 列表里，会被
+多补一行（此时把它加进 `CORE_SECTION_IDS` 即可）。
+
+## 渲染
+
+桥接面板自己注册同 id 的 `main` keyed 条目，并在该条目上声明一个自有子槽（`dpc-bridge-slot-<section id>`）。
+之所以不直接用 `ctx.slots.renderSlot('settings.section', ...)`：ctx 级 `renderSlot` 只渲染 `root`，
+子槽只能通过「声明了它的那个条目的 props 面」渲染；`settings.section` 由设置壳声明，本插件无权调用。
+因此桥接条目把原 section 的组件以同一份 `inject/store/locale` 重新注册进自有子槽，再通过宿主注入的
+`props.renderSlot(slotName, { close: back }, {})` 渲染它。
+
+这样 section 的 `inject`、`store`、locale `t`、`useStore` 和 error boundary 仍由宿主照常提供；直接调用
+section 组件会缺这些。面板只负责外壳：顶部一条 40px 的栏（「返回对话」+ 来源 section id），
+下面一块随页面滚动的主体。`close` 与设置壳里一样只做「关掉这一页」，这里落回对话
+（`layout.selectPanel(null)`）。
+
+桥接面板不常驻：开关关闭、section 消失、插件卸载时，`dispose()` 成对撤掉 `main` 与
+`sidebar.panellist` 注册；若当时正停在这一页，先 `selectPanel(null)` 回到对话，避免选中一个
+已经不存在的 key。
+
+## 同步
+
+`settings.section`、`sidebar.panellist` 与 locale 任意一处变化都会触发一次同步，120ms 去抖。
+启动时还会按 `[350, 900, 2000, 4200, 8000, 15000]ms` 主动重扫：boot 清单的顺序不是应用顺序，
+排在后面的插件可能在第一次同步之后才注册设置页。`settings.section` 槽声明时会重新建立订阅，
+因为槽声明之前 `subscribe` 观察不到这个注册表。
+
+同步本身只做增删对账，不重建未变化的行；注册成对失败时回滚已注册的那一半。
+
+开关存在 `prefs.bridge`（默认 `true`），在「侧栏布局」卡片里；它和排序、隐藏、分组是正交的：
+补出来的行可以像普通行一样拖动、隐藏、分组，关掉开关才会整体消失。
+
+## 验证
+
+- `npm run check`：`layout-smoke` 断言桥接的常量、持久化字段与自有子槽渲染没有被改掉；
+  `bridge-smoke` 在假 `ctx` 上验证识别、成对注册、开关撤回与返回对话。
+- 刷新插件后看 `~/.dsh/panel-control/host.log`：`bridge-scan` 行记录每次扫描看到的 section 与
+  侧栏条目（`id:registrant`），`kind=bridge` 行记录最终补出的 id。目标 section 在 `sections`
+  里却没进 `ids`，说明它被归属规则当成了已有入口（或 id 不在内置列表里而被排除）；一直不在
+  `sections` 里，是注册时序问题。
+- `bridge-smoke` 里另有一条晚注册用例：先启动、后注册 section，订阅必须把新行补出来。
+- 界面：侧栏应多出对应行；点开后是完整设置页，顶部「返回对话」可退回；设置 → 面板管理里
+  「侧栏布局」应出现开关。
+
+## 边界
+
+- 第三方设置页在设置壳外渲染时，若它依赖弹窗的私有上下文（宽度、滚动容器、`close` 之外的 props），
+  可能和设置弹窗里不完全一致；本插件只保证宿主注入的公开部分齐全。
+- 补出来的行参与自动分类，会被分进 2–4 个组之一；想固定位置就手动拖动或分组。
+- 识别是启发式：设置页 id / label 与面板重合时视为已有入口；新增内置设置页需要加进
+  `CORE_SECTION_IDS`。同一个包注册多个设置页会补多行，这是有意的。

package/docs/renaming-panels.md

@@ -0,0 +1,74 @@
+# 重命名与包名标签
+
+侧栏入口名由插件自己注册，通常是包名或英文短名。面板管理允许把这层显示改成你熟悉的叫法，同时在行尾留一枚插件包名标签，避免过几天忘了它是谁。
+
+## 只改显示层
+
+宿主拥有侧栏 DOM，插件注册的 `id`、`order`、`label` 都不该被另一个插件改写。重命名因此只覆盖三处显示：
+
+- 面板按钮的 `span.panelTitle` 文本；
+- 按钮的 `aria-label`（屏幕阅读器与工具提示读它）；
+- 行尾的 `span.dpc-nameTag`，内容是**插件包名**（见下一节），不是注册时的显示名。
+
+按钮上的 `data-dpc-label` 保存原名，供引擎下一轮把自己映射回同一条注册；入口 id 和宿主数据不变。
+
+## 包名从哪来
+
+`sidebar.panellist` 条目只有 `id/order/label/registrant`，没有包名字段；`registrant` 是 Cordis fiber 名，运行时大多数插件共享同一个 fiber，无法拿去区分插件。包名只存在于宿主自己的模块图里，所以：
+
+1. 客户端把当前面板 id 与桥接设置页 id 发给 Host 的 `packages` RPC；
+2. Host 用 `clientModules.graph().entries` 拿到模块 id（即包名）与 `clientModules.clientPath(id)` 返回的 bundle 路径；
+3. 逐个 bundle 查找槽字面量 `sidebar.panellist` / `settings.section`，并优先接受紧邻 `id:` / `key:`（或赋值）的该 id；没有注册字段时只接受距离 400 字符以内的提及，避免把注释里顺带提到的通用词当成归属；
+4. 命中的模块 id 就是包名，按模块图 revision 缓存。
+
+标签文本会去掉 scope 与 `dsh-` 前缀，再退掉 `client-ui-`：
+
+| 模块 id | 标签 |
+| --- | --- |
+| `dsh-panel-control` | `panel-control` |
+| `@furongjun1999/dsh-memory` | `memory` |
+| `dshmarket` | `market` |
+| `@deepseek-ai/dsh-client-ui-plugin-manager` | `plugin-manager` |
+
+Host 尚未返回或确实找不到时，回退到入口 id 本身（同样去 `dsh-` 前缀），所以标签绝不会空白。
+
+## 映射回原条目
+
+每一轮扫描都会先读 `data-dpc-label`，没有才退回 `aria-label`：
+
+1. 按原名唯一匹配注册项；
+2. 名称重复时，如果待匹配的注册项与未匹配的按钮数量相同、且顺序上名称逐项一致，按位置匹配；
+3. 仍无法判断的按钮不接管，避免把顺序写到错误的面板上。
+
+因此改名后的行在宿主重渲染、分组重排或侧栏重挂载后仍能找回自己的注册项。图标条模式没有标题文本，只更新 `aria-label`，不显示标签。
+
+## 配置
+
+`prefs.json` 里新增两个字段：
+
+```jsonc
+{
+  "names": { "billion-context": "上下文百科" },
+  "tags": true
+}
+```
+
+- `names`：入口 id → 显示名。保存时去控制字符、压空白、`trim`，最多 40 字符；最多保留 200 条。
+- `tags`：是否显示包名标签，默认 `true`。关掉只影响标签，不影响已保存的名称。
+
+设置页「侧栏布局」卡片里有「包名标签」开关；每行的铅笔按钮打开行内输入：
+
+- `Enter` 或失焦保存；
+- `Esc` 取消；
+- 清空并保存即删除自定义名称，恢复注册名。
+
+## 边界
+
+- 只覆盖显示，不改变插件加载、入口 id 或插件自己的配置；停用本插件后宿主标题原样恢复。
+- 包名识别依赖 Host 的模块图接口与 bundle 内容。接口不存在、模块读不到或代码里没有可识别的注册字面量时，标签退化为入口 id；不会影响改名本身。
+- 宿主大改版若移除 `span.panelTitle` 或改写按钮结构，重命名会退化为只改 `aria-label`；找不到对应行时该行保持原样，不会报错。
+- 标签 `pointer-events: none`，不参与点击与拖拽；分组下拉菜单铺了不透明底色，避免透出下面的行。
+
+## 验证
+
+`scripts/names-smoke.mjs` 用迷你 DOM 驱动真实引擎，覆盖改名、关标签、清空恢复、窄侧栏、重复名称映射、包名标签、未知包回退与 `dispose` 还原；`npm run check` 会运行它。

package/index.js

@@ -486,6 +486,7 @@ async function handle(scope, request) {
     if (method === 'load') return reply(rpcId, await loadPreferences());
     if (method === 'save') return reply(rpcId, await savePreferences(call.payload));
     if (method === 'inventory') return reply(rpcId, inventorySnapshot(scope));
+    if (method === 'packages') return reply(rpcId, await packageMap(scope, call.payload));
     if (method === 'report') {
       const detail = isRecord(call.payload) ? call.payload : {};
       const text = JSON.stringify(detail).slice(0, 4_000);
@@ -536,6 +537,126 @@ function inventorySnapshot(scope) {
   };
 }
 
+/**
+ * Which package serves each panel / settings section.
+ *
+ * A slot entry carries no package field: `registrant` is the fiber that ran the
+ * registration, and the client runner applies most plugins inside one shared
+ * fiber. The package name exists only in the Host's module graph, so this maps
+ * an entry id to its module id by reading each module's served bundle and
+ * looking for the registration site: the slot literal plus the id as a quoted
+ * string. Constant-style registrations keep the two strings close together;
+ * an id is only accepted from a module that contains both.
+ */
+const PACKAGE_SCAN_LIMIT = 8 * 1024 * 1024;
+const PACKAGE_CACHE_KEPT = 4;
+const packageCache = new Map();
+
+/**
+ * How strongly one bundle looks like the registration of `id` in `slot`.
+ *
+ * `strong` means the quoted id sits immediately after an `id:` / `key:` field
+ * (or an `id =` / `key =` assignment), which is the shape of a slot
+ * registration. Everything else is only a distance guess and must be close;
+ * a long comment can mention both words without registering anything.
+ */
+function slotMatch(text, slot, id) {
+  const slots = [];
+  let at = text.indexOf(slot);
+  while (at !== -1) {
+    slots.push(at);
+    at = text.indexOf(slot, at + slot.length);
+  }
+  if (slots.length === 0) return null;
+  let strong = Infinity;
+  let weak = Infinity;
+  for (const needle of [`'${id}'`, `"${id}"`, '`' + id + '`']) {
+    let pos = text.indexOf(needle);
+    while (pos !== -1) {
+      let distance = Infinity;
+      for (const slotAt of slots) distance = Math.min(distance, Math.abs(pos - slotAt));
+      const before = text.slice(Math.max(0, pos - 48), pos);
+      if (/(?:^|[\s,{;])(?:id|key)\s*[:=]\s*$/.test(before)) strong = Math.min(strong, distance);
+      else weak = Math.min(weak, distance);
+      pos = text.indexOf(needle, pos + needle.length);
+    }
+  }
+  if (Number.isFinite(strong)) return { strong: true, distance: strong };
+  if (weak <= 400) return { strong: false, distance: weak };
+  return null;
+}
+
+async function readModuleText(modules, id, texts) {
+  if (texts.has(id)) return texts.get(id);
+  let text = null;
+  try {
+    const file = modules.clientPath(id);
+    if (file) {
+      const stat = await fs.stat(file);
+      if (stat.isFile() && stat.size <= PACKAGE_SCAN_LIMIT) text = await fs.readFile(file, 'utf8');
+    }
+  } catch {
+    text = null;
+  }
+  texts.set(id, text);
+  return text;
+}
+
+async function packageMap(scope, payload) {
+  const modules = clientModules || serviceOf(scope, 'clientModules');
+  if (!modules || typeof modules.graph !== 'function' || typeof modules.clientPath !== 'function') {
+    return refusal('packages-unavailable', 'The Host module graph does not expose client paths.');
+  }
+  const graph = modules.graph();
+  if (!graph || !Array.isArray(graph.entries)) {
+    return refusal('packages-unavailable', 'The Host module graph is not readable.');
+  }
+  const requested = [];
+  const seen = new Set();
+  for (const raw of Array.isArray(payload && payload.ids) ? payload.ids : []) {
+    if (!isRecord(raw)) continue;
+    const id = typeof raw.id === 'string' ? raw.id.trim() : '';
+    const slot = raw.slot === 'settings.section' ? 'settings.section' : 'sidebar.panellist';
+    if (!id || id.length > 120 || seen.has(slot + ':' + id)) continue;
+    seen.add(slot + ':' + id);
+    requested.push({ id, slot });
+  }
+  if (requested.length === 0) return { ok: true, value: { packages: {}, rev: graph.rev || null } };
+  // Stable order makes two calls for the same set share the cache entry.
+  requested.sort((left, right) => (left.slot + ':' + left.id).localeCompare(right.slot + ':' + right.id));
+  const key = String(graph.rev || '') + '|' + requested.map((row) => row.slot + ':' + row.id).join(',');
+  if (packageCache.has(key)) return { ok: true, value: packageCache.get(key) };
+
+  const packages = {};
+  const best = new Map();
+  const texts = new Map();
+  for (const entry of graph.entries) {
+    const moduleId = entry && typeof entry.id === 'string' ? entry.id : '';
+    if (!moduleId) continue;
+    const text = await readModuleText(modules, moduleId, texts);
+    if (!text) continue;
+    for (const want of requested) {
+      if (!text.includes(want.slot)) continue;
+      // A bundle may mention a generic id (the plugin manager's id is also a
+      // dictionary word). A real registration field wins over a mere mention,
+      // and within the same tier the closest match wins over graph order.
+      const match = slotMatch(text, want.slot, want.id);
+      if (!match) continue;
+      const previous = best.get(want.id);
+      if (previous) {
+        if (previous.strong && !match.strong) continue;
+        if (previous.strong === match.strong && previous.distance <= match.distance) continue;
+      }
+      best.set(want.id, { moduleId, strong: match.strong, distance: match.distance });
+    }
+  }
+  for (const [id, match] of best) packages[id] = match.moduleId;
+  const value = { packages, rev: typeof graph.rev === 'string' ? graph.rev : null };
+  packageCache.set(key, value);
+  while (packageCache.size > PACKAGE_CACHE_KEPT) packageCache.delete(packageCache.keys().next().value);
+  return { ok: true, value };
+}
+
 /**
  * Write one line per apply that answers the only question a cold start leaves
  * open: did this package even reach the Host's plugin graph?
@@ -649,8 +770,8 @@ function logBatchPlacement(scope) {
  * gets the bytes it needs; everything else passes straight through, and the
  * patch is undone on teardown.
  */
-// Off by default: rewriting the shared bundle service is a whole-page change that
-// other plugins pay for. It stays available as an explicit escape hatch only.
+// Off by default: rewriting the shared bundle service is a whole-page change that
+// other plugins pay for. It stays available as an explicit escape hatch only.
 const SERVE_CURRENT = String(process.env.DPC_SERVE_CURRENT || '').toLowerCase() === 'on';
 let servePatched = null;
 let serveLoggedAt = 0;

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "dsh-panel-control",
-  "version": "0.7.2",
+  "version": "0.9.1",
   "type": "module",
+  "engines": {
+    "dsh": ">=0.2.1-rc.3"
+  },
   "description": "Manage the global panel navigation at the top of the DSH sidebar: reorder, hide and group every entry, with the layout persisted per installation.",
   "keywords": [
     "dsh",
@@ -50,7 +53,7 @@
     "url": "https://github.com/QIUZAIYOU/dsh-panel-control/issues"
   },
   "scripts": {
-    "check": "node --check index.js && node --check client.js && node scripts/host-smoke.mjs && node scripts/layout-smoke.mjs",
+    "check": "node --check index.js && node --check client.js && node scripts/host-smoke.mjs && node scripts/layout-smoke.mjs && node scripts/bridge-smoke.mjs && node scripts/names-smoke.mjs",
     "smoke": "node scripts/host-smoke.mjs",
     "doctor": "node scripts/profile-doctor.mjs",
     "enable": "node scripts/enable-local.mjs"

package/scripts/bridge-smoke.mjs

@@ -0,0 +1,324 @@
+// Scratch harness: does the bridge discover settings-only plugins, register the
+// panellist+main pair, avoid plugins that already have a row, and honour the switch?
+import { readFileSync } from 'node:fs';
+import vm from 'node:vm';
+
+const SRC = readFileSync(new URL('../client.js', import.meta.url), 'utf8');
+
+const stubReact = {
+  createElement: (type, props, ...children) => ({ type, props: { ...(props || {}), children } }),
+  useState: (value) => [value, () => {}],
+  useEffect: () => {},
+  useRef: (value) => ({ current: value }),
+  useMemo: (fn) => fn(),
+  useCallback: (fn) => fn,
+};
+
+const element = () => ({
+  style: {},
+  dataset: {},
+  classList: { add() {}, remove() {}, toggle() {} },
+  setAttribute() {},
+  removeAttribute() {},
+  appendChild() {},
+  remove() {},
+  addEventListener() {},
+  removeEventListener() {},
+  contains() {
+    return false;
+  },
+  querySelector() {
+    return null;
+  },
+  querySelectorAll() {
+    return [];
+  },
+  textContent: '',
+  children: [],
+  childNodes: [],
+});
+
+const document = {
+  readyState: 'loading',
+  head: element(),
+  body: element(),
+  documentElement: element(),
+  title: '',
+  visibilityState: 'visible',
+  createElement: () => element(),
+  createTextNode: () => ({ textContent: '' }),
+  createDocumentFragment: () => element(),
+  querySelector: () => null,
+  querySelectorAll: () => [],
+  getElementById: () => null,
+  addEventListener() {},
+  removeEventListener() {},
+};
+
+function makeWindow(localPrefs) {
+  const memory = new Map();
+  if (localPrefs !== undefined) memory.set('dsh.panel-control.v1', JSON.stringify(localPrefs));
+  const localStorage = {
+    getItem: (key) => (memory.has(key) ? memory.get(key) : null),
+    setItem: (key, value) => memory.set(key, String(value)),
+    removeItem: (key) => memory.delete(key),
+    key: () => null,
+    length: 0,
+  };
+  return {
+    document,
+    localStorage,
+    navigator: { language: 'zh-CN' },
+    location: { reload() {} },
+    CSS: { escape: (value) => String(value) },
+    addEventListener() {},
+    removeEventListener() {},
+    __DSH_BOOT__: {
+      rev: 'test-rev',
+      entries: [],
+      ids: [
+        'plugins',
+        'dsh-market',
+        'panel-control',
+        'dsh-flash-presets',
+        'billion-context',
+        'dshmarket',
+        '@deepseek-ai/dsh-client-ui-settings-general',
+      ],
+    },
+    __ModuleLoader__: { def: null, load(def) { this.def = def; } },
+  };
+}
+
+function section(options, registrant) {
+  return { options, component: () => null, registrant };
+}
+function panelEntry(options, registrant) {
+  return { options, component: () => null, registrant };
+}
+
+function install(ctx, slots) {
+  globalThis.window = ctx;
+  globalThis.document = document;
+  globalThis.localStorage = ctx.localStorage;
+  window.__ModuleLoader__.def = null;
+  vm.runInThisContext(SRC, { filename: 'client.js' });
+  return window.__ModuleLoader__.def.factory((name) => {
+    if (name === 'react') return stubReact;
+    throw new Error('unexpected require: ' + name);
+  });
+}
+
+const calls = { selectPanel: [], renders: [] };
+const layout = {
+  panelInfo: { getSnapshot: () => ({ activePanelId: null }) },
+  selectPanel(id) {
+    calls.selectPanel.push(id);
+  },
+};
+const locale = {
+  getLocale: () => ({ active: 'zh-CN' }),
+  register: () => {},
+  subscribe: () => () => {},
+};
+
+function makeCtx(seedSections = true) {
+  const registries = new Map();
+  const list = (name) => {
+    if (!registries.has(name)) registries.set(name, []);
+    return registries.get(name);
+  };
+  const subscribers = new Map();
+  const notify = (name) => {
+    for (const callback of subscribers.get(name) || []) Promise.resolve().then(callback);
+  };
+  const slotService = {
+    register(options, component) {
+      const record = { options, component, registrant: options.registrant || 'dsh-panel-control' };
+      list(options.name).push(record);
+      notify(options.name);
+      return () => {
+        const all = list(options.name);
+        const at = all.indexOf(record);
+        if (at >= 0) all.splice(at, 1);
+        notify(options.name);
+      };
+    },
+    entriesOfSlot(name) {
+      return list(name).slice();
+    },
+    inject(name, callback) {
+      return callback();
+    },
+    subscribe(name, callback) {
+      if (!subscribers.has(name)) subscribers.set(name, []);
+      subscribers.get(name).push(callback);
+      return () => {};
+    },
+    renderSlot(name, props, opts) {
+      calls.renders.push({ name, props, opts });
+      return stubReact.createElement('div', { 'data-slot': name, 'data-only': opts && opts.only });
+    },
+  };
+  list('sidebar.panellist').push(
+    panelEntry({ name: 'sidebar.panellist', id: 'plugins', order: 0, label: '插件' }, 'tk'),
+  );
+  list('sidebar.panellist').push(
+    panelEntry({ name: 'sidebar.panellist', id: 'dsh-market', order: 1, label: '插件市场' }, 'dsh-market'),
+  );
+  list('sidebar.panellist').push(
+    panelEntry({ name: 'sidebar.panellist', id: 'workspace-control', order: 20, label: '工作区管理' }, 'tk'),
+  );
+  list('settings.section').push(
+    section({ name: 'settings.section', id: 'general', order: 0, label: '通用' }, 'tk'),
+  );
+  list('settings.section').push(
+    section({ name: 'settings.section', id: 'market', order: 40, label: '插件市场' }, 'dsh-market'),
+  );
+  if (seedSections) {
+    list('settings.section').push(
+      section({ name: 'settings.section', id: 'plan-mode', order: 5, label: '计划模式' }, 'tk'),
+    );
+    list('settings.section').push(
+      section({ name: 'settings.section', id: 'bili', order: 100, label: () => '上下文' }, 'tk'),
+    );
+    list('settings.section').push(
+      section({ name: 'settings.section', id: 'workspace-control-settings', order: 30, label: '工作区管理' }, 'tk'),
+    );
+    list('settings.section').push(
+      section({ name: 'settings.section', id: 'composer-rewind-settings', order: 50, label: '输入历史' }, 'tk'),
+    );
+    for (const [id, label] of [
+      ['account', '账户'],
+      ['models', '模型'],
+      ['agent-presets', '智能体预设'],
+    ]) {
+      list('settings.section').push(section({ name: 'settings.section', id, order: 1, label }, 'tk'));
+    }
+  }
+  return {
+    registries,
+    subscribers,
+    ctx: {
+      fiber: { name: 'dsh-panel-control' },
+      get(name) {
+        if (name === 'layout') return layout;
+        if (name === 'locale') return locale;
+        return undefined;
+      },
+      effect(fn) {
+        return fn();
+      },
+      slots: slotService,
+    },
+  };
+}
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function run(localPrefs) {
+  const app = makeCtx();
+  const mod = install(makeWindow(localPrefs), app.registries);
+  mod.apply(app.ctx);
+  await sleep(260);
+  const rows = app.registries.get('sidebar.panellist') || [];
+  const mains = app.registries.get('main') || [];
+  const labelOf = (options) => (typeof options.label === 'function' ? options.label() : options.label);
+  return {
+    ids: rows.map((row) => row.options.id),
+    labels: rows.map((row) => labelOf(row.options)),
+    mains: mains.map((row) => row.options.key),
+    mainRows: mains,
+    rows,
+    registries: app.registries,
+  };
+}
+
+const failures = [];
+const check = (ok, message) => {
+  if (!ok) failures.push(message);
+};
+
+// Boot order is not registration order: a plugin that applies after us adds its
+// settings section later. The subscription installed when the slot is declared
+// must pick that up without a reload.
+async function runLate() {
+  const app = makeCtx(false);
+  const mod = install(makeWindow(undefined), app.registries);
+  mod.apply(app.ctx);
+  await sleep(300);
+  const before = (app.registries.get('sidebar.panellist') || []).map((row) => row.options.id);
+  app.ctx.slots.register(
+    { name: 'settings.section', id: 'plan-mode', order: 5, label: '计划模式', registrant: 'tk' },
+    () => null,
+  );
+  app.ctx.slots.register(
+    { name: 'settings.section', id: 'bili', order: 100, label: () => '上下文', registrant: 'tk' },
+    () => null,
+  );
+  await sleep(420);
+  const after = (app.registries.get('sidebar.panellist') || []).map((row) => row.options.id);
+  return { before, after };
+}
+
+const late = await runLate();
+check(!late.before.some((id) => id.startsWith('dpc-bridge-')), 'bridged a section before it was registered');
+check(
+  late.after.includes('dpc-bridge-plan-mode') && late.after.includes('dpc-bridge-bili'),
+  'late-registered settings sections were not bridged',
+);
+
+const on = await run(undefined);
+check(on.ids.includes('dpc-bridge-plan-mode'), 'missing bridge row for dsh-flash-presets');
+check(on.ids.includes('dpc-bridge-bili'), 'missing bridge row for billion-context');
+check(on.ids.includes('dpc-bridge-composer-rewind-settings'), 'missing bridge row for dsh-composer-rewind');
+check(!on.ids.includes('dpc-bridge-market'), 'bridged dshmarket even though it has a panel');
+check(!on.ids.includes('dpc-bridge-general'), 'bridged a core settings section');
+check(!on.ids.includes('dpc-bridge-account'), 'bridged a core settings section');
+check(!on.ids.includes('dpc-bridge-models'), 'bridged a core settings section');
+check(!on.ids.includes('dpc-bridge-agent-presets'), 'bridged a core settings section');
+check(!on.ids.includes('dpc-bridge-workspace-control-settings'), 'bridged a plugin whose panel id is the section base');
+check(on.mains.includes('dpc-bridge-plan-mode') && on.mains.includes('dpc-bridge-bili'), 'a bridge row has no main entry');
+const planRow = on.rows.find((row) => row.options.id === 'dpc-bridge-plan-mode');
+check(planRow && planRow.options.order === 85, 'bridge rows lost their order');
+check(planRow && planRow.options.label() === '计划模式', 'bridge label is not the section label');
+
+const tree = on.rows.find((row) => row.options.id === 'dpc-bridge-bili').component({ size: 18, active: false });
+check(tree && tree.type === 'svg', 'bridge icon is not an svg');
+
+const off = await run({ version: 2, bridge: false, order: ['plugins', 'dsh-market', 'panel-control'] });
+check(!off.ids.some((id) => id.startsWith('dpc-bridge-')), 'the switch did not remove the bridge rows');
+
+// The settings shell owns `settings.section`, so the ctx-level renderSlot cannot
+// reach it. The bridge declares its own child slot, registers the section
+// component into it, and renders it through the props face the host binds.
+const biliMain = on.mainRows.find((row) => row.options.key === 'dpc-bridge-bili');
+check(Boolean(biliMain), 'no main key for the bridged row');
+const slotName = 'dpc-bridge-slot-bili';
+const declared = biliMain && biliMain.options.children;
+check(Boolean(declared && declared[slotName]), 'the bridge main entry declared no child slot');
+check(declared && declared[slotName] && declared[slotName].kind === 'single', 'the bridge child slot is not single');
+const face = (name, props, opts) => {
+  if (!declared || !declared[name]) throw new Error('slot ' + name + ' is not declared by this entry children');
+  calls.renders.push({ name, props, opts });
+  return stubReact.createElement('div', { 'data-slot': name });
+};
+const view = biliMain ? biliMain.component({ renderSlot: face }) : null;
+const slot = calls.renders.find((render) => render.name === slotName);
+check(Boolean(slot), 'the bridge page did not render its child slot');
+check(slot && typeof slot.props.close === 'function', 'the bridge page gave the section no close');
+check(Boolean(view) && view.type === 'div', 'the bridge page did not render its frame');
+const childEntries = on.registries.get(slotName) || [];
+check(childEntries.length === 1, 'the section component was not re-registered into the bridge slot');
+check(childEntries[0] && typeof childEntries[0].component === 'function', 'the bridge slot has no component');
+if (slot) slot.props.close();
+check(calls.selectPanel.includes(null), 'closing the bridge page did not select the Conversation');
+
+console.log(JSON.stringify({ on: on.ids, onLabels: on.labels, mains: on.mains, off: off.ids, renders: calls.renders.length }, null, 2));
+if (failures.length) {
+  console.error('bridge-smoke: ' + failures.length + ' problem(s)');
+  for (const failure of failures) console.error(' - ' + failure);
+  process.exit(1);
+}
+console.log('bridge-smoke: ok');
+process.exit(0);