dsh-code-server-app 0.3.47 → 0.3.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-code-server-app",
-  "version": "0.3.47",
+  "version": "0.3.49",
   "description": "VS Code (from a code-server release) inside DSH: a right-sidebar tab driven by the plugin's own launcher over the in-process VS Code server (lib/launcher.mjs). Since 0.3.0 the bundle also ships an editor bridge (assets/extensions/dshcs-editor-bridge): a read-only channel between the in-tree VS Code extension host and DSH, giving the agent what only the editor knows (unsaved buffers, language-server diagnostics, the active selection) and letting editor gestures drive the session. Since 0.3.22 the ask panel renders that session's new content with DSH's own Markdown renderer (pinned to the deployed DSH UI version); since 0.3.23 it is a full-width dialog with collapsible thinking rows and can answer approval requests in place — the bridge's only non-read-only route (POST /approve, constrained to pending in-process requests and the outcomes allowed-once/rejected; panel-first for 5 minutes, handed back to the official card the moment the panel closes). The tab claims DSH file addresses (dsh-resource://file/**) by file type (setting claimExtensions), so the product's own produced-file chips, delivered-file previews and inline prose mentions open in the workbench. The IDE is a resident surface moved with Element.moveBefore instead of being remounted, so switching sidebar tabs no longer reloads it. Opening the tab switches the right sidebar to fullscreen by default (setting fullscreenOnOpen). Following a workspace switch is lightweight: the workbench re-navigates with the new ?folder= and the IDE process is not restarted (since 0.2.12). Requires a DSH with the right-sidebar services (sidebarRightTabs/sidebarRight, >= 0.1.5-alpha.1); older DSH versions get a single upgrade notice on the settings page and no other UI. Two serving modes: loopback port (default) or same-origin mount on DSH's own webServer (/code-server, protected by ctx.connection.requestRejection). No code-server Node layer, no argon2, no C++ toolchain.",
   "homepage": "https://github.com/jinsiyu/dsh-code-server-app",
   "repository": {
@@ -142,14 +142,24 @@
     "zod": "4.4.3"
   },
   "optionalDependencies": {
+    "@jinsiyu/dshcs-kerberos-linux-arm64": "2.1.1-dshcs.1",
+    "@jinsiyu/dshcs-kerberos-linux-x64": "2.1.1-dshcs.1",
     "@jinsiyu/dshcs-kerberos-win32-arm64": "2.1.1-dshcs.1",
     "@jinsiyu/dshcs-kerberos-win32-x64": "2.1.1-dshcs.1",
+    "@jinsiyu/dshcs-vscode-deviceid-linux-arm64": "0.1.5",
+    "@jinsiyu/dshcs-vscode-deviceid-linux-x64": "0.1.5",
     "@jinsiyu/dshcs-vscode-deviceid-win32-arm64": "0.1.5",
     "@jinsiyu/dshcs-vscode-deviceid-win32-x64": "0.1.5",
+    "@jinsiyu/dshcs-vscode-native-watchdog-linux-arm64": "1.4.6",
+    "@jinsiyu/dshcs-vscode-native-watchdog-linux-x64": "1.4.6",
     "@jinsiyu/dshcs-vscode-native-watchdog-win32-arm64": "1.4.6",
     "@jinsiyu/dshcs-vscode-native-watchdog-win32-x64": "1.4.6",
+    "@jinsiyu/dshcs-vscode-spdlog-linux-arm64": "0.15.8",
+    "@jinsiyu/dshcs-vscode-spdlog-linux-x64": "0.15.8",
     "@jinsiyu/dshcs-vscode-spdlog-win32-arm64": "0.15.8",
     "@jinsiyu/dshcs-vscode-spdlog-win32-x64": "0.15.8",
+    "@jinsiyu/dshcs-vscode-sqlite3-linux-arm64": "5.1.12-vscode",
+    "@jinsiyu/dshcs-vscode-sqlite3-linux-x64": "5.1.12-vscode",
     "@jinsiyu/dshcs-vscode-sqlite3-win32-arm64": "5.1.12-vscode",
     "@jinsiyu/dshcs-vscode-sqlite3-win32-x64": "5.1.12-vscode",
     "@jinsiyu/dshcs-vscode-windows-ca-certs-win32-arm64": "0.3.4",
@@ -178,6 +188,9 @@
     "test:fullscreen": "node scripts/test-sidebar-fullscreen.mjs",
     "test:claim-types": "node scripts/test-claim-types.mjs",
     "test:workspace-switch": "node scripts/test-workspace-switch.mjs",
+    "test:workspace-cwd": "node scripts/test-workspace-cwd.mjs",
+    "test:client-cwd": "node scripts/test-client-bundle-cwd.mjs",
+    "test:dsh-resolve": "node scripts/test-dsh-resolve.mjs",
     "test:bridge-routes": "node scripts/test-bridge-routes.mjs",
     "test:bridge-extension": "node scripts/test-bridge-extension.mjs",
     "test:webview": "node scripts/test-webview-bundle.mjs",

package/scripts/vendor-repacks.mjs

@@ -19,7 +19,7 @@
 //   不给 --from 时自动准备源树(按 vendor/VENDOR.json 的版本 npm install --ignore-scripts,再在
 //   lib/vscode 里解包 + rebuild;耗时且需要工具链,维护者换版本时用)。--pack 生成 repack/tgz/*.tgz。
 import { existsSync, readFileSync, readdirSync, mkdirSync, rmSync, writeFileSync, cpSync } from 'node:fs';
-import { dirname, join, relative, resolve } from 'node:path';
+import { basename, dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawnSync } from 'node:child_process';
 
@@ -47,6 +47,17 @@ const DO_PACK = process.argv.includes('--pack');
 //          VS Code 树包、平台聚合包与插件 package.json。
 //          适用于「原生包没变、只调整打包结构」的场景(本机已无可分析的完整源树时也用它)。
 const REUSE = process.argv.includes('--reuse');
+// --skip-independent:不重建「平台无关」的重打包包。平台无关的包由**单独一条腿**产出并发布
+// (四个目标内容一致,不能四边都发同一个版本号),平台专属腿重建它们纯属浪费,而且会把一份"在别的宿主上
+// 打出来的同名包"塞进 artifact —— 谁要是从 artifact 手工发布,发出去的就是错的内容。
+const SKIP_INDEPENDENT = process.argv.includes('--skip-independent');
+// --only-independent:只产「平台无关」的重打包包 + VS Code 树包,**完全不碰平台专属包**。
+//   独立那条腿用的就是它:平台无关层是所有平台共用的同一份产物,先于平台专属腿执行、只发一次;
+//   平台专属腿各自带 --skip-independent。两者互为反面,同时给直接报错。
+const ONLY_INDEPENDENT = process.argv.includes('--only-independent');
+if (SKIP_INDEPENDENT && ONLY_INDEPENDENT) {
+  throw new Error('--skip-independent 与 --only-independent 不能同时给(一个是不产平台无关包,一个是只产它)');
+}
 const TARGETS = argValues('--target');
 // Copilot 整树排除:620MB、依赖链里还有带脚本的包,且 code-server 里用不到。
 const EXCLUDE = [/^@github\//, /^@vscode\/copilot-api$/];
@@ -306,10 +317,35 @@ function prepareSourceTree() {
   for (const dir of innerDirs) {
     if (!existsSync(join(dir, 'node_modules'))) continue;
     console.log(`[repack] 编译内部依赖原生包: ${relative(pkgRoot, dir)}`);
+    // ① 整树 rebuild 一次:覆盖声明里没登记的新包。失败不算错 —— 因为 npm 会在**第一个失败**处中断,
+    //    一个包编不出来(例如 Windows 上缺 v145 工具集,或 Linux 上缺某个头文件)就会让它后面的包
+    //    再也没轮到自己,于是"一个包失败"级联成"一批包没编出来"。
     try {
       npm(['rebuild'], dir);
     } catch (e) {
-      console.warn(`[repack] ${relative(pkgRoot, dir)} rebuild 失败(${e.message});后续按缺失处理`);
+      console.warn(`[repack] 整树 rebuild 未全部成功(${e.message})⇒ 改为逐个包重试`);
+    }
+    // ② 逐个「声明为平台专属、且本平台需要」的模块 rebuild:幂等,失败只影响它自己,并逐条报出来。
+    //    这样后面 analyze() 的「有没有 .node」判断才是可靠的,而不是随整树中断位置漂移。
+    const policy = readRepackPlatforms();
+    const hostKey = `${process.platform}-${process.arch}`;
+    const failedRebuild = [];
+    for (const [alias, decl] of policy.perModule) {
+      if (decl.platform !== true) continue; // 平台无关的包靠 prebuilds,不需要现编
+      const wanted = decl.targets ?? policy.allTargets ?? null;
+      if (Array.isArray(wanted) && !wanted.includes(hostKey)) continue; // 本平台不需要它
+      const pkgDir = join(dir, 'node_modules', ...alias.split('/'));
+      if (!existsSync(join(pkgDir, 'package.json'))) continue;
+      try {
+        npm(['rebuild', alias], dir);
+      } catch (e) {
+        failedRebuild.push(alias);
+        console.warn(`  ⚠ ${hostKey}: ${alias} rebuild 失败(${e.message})`);
+      }
+    }
+    if (failedRebuild.length > 0) {
+      console.warn(`  ⚠ ${relative(pkgRoot, dir)}:${failedRebuild.length} 个原生包 rebuild 失败`
+        + `(${failedRebuild.join(', ')})—— 若它们在白名单里却没有 .node,最后的硬闸门会直接判失败`);
     }
   }
   return tree;
@@ -326,11 +362,26 @@ function peMachine(file) {
   } catch { return null; }
 }
 
-/** ① VS Code 树(平台无关):vendor/vscode → repack/build/vscode/vscode/。
+/** ELF e_machine(0x3e=x86-64 / 0xb7=AArch64),用于 Linux 目标的静态校验。 */
+function elfMachine(file) {
+  try {
+    const b = readFileSync(file);
+    if (b[0] !== 0x7f || b[1] !== 0x45 || b[2] !== 0x4c || b[3] !== 0x46) return null;
+    return `0x${b.readUInt16LE(0x12).toString(16)}`;
+  } catch { return null; }
+}
+
+/** ① VS Code 树(**必须平台无关**):vendor/vscode → repack/build/vscode/vscode/。
  *  排除 VS Code 的「内部依赖目录」(lib/vscode/node_modules、lib/vscode/extensions/node_modules)
- *  —— 它们由包管理器安装 + 平台聚合包按架构提供,树里只留 lib/vscode 本体与静态资源。
- *  不含 code-server 的 out/node 与服务层依赖(已由 lib/launcher.mjs 取代)。 */
-function buildVscodeServerPackage() {
+ *  —— 核心原生模块(node-pty / @vscode/sqlite3 / spdlog / kerberos / deviceid / native-watchdog /
+ *  windows-* / @parcel/watcher …)全在那两个目录里,一律由 `@jinsiyu/dshcs-*-<目标>` 按平台供给;
+ *  树里只留 lib/vscode 本体与静态资源(browser 资源、语法/主题、字体、.wasm ⇒ 都跨平台)。
+ *  为什么树包不按 OS 区分(与上游 VS Code 相反):上游每个平台发一份 server 包,是因为它把
+ *  **node 运行时 + 原生模块**塞在里面;本产品把这两件事分别交给宿主 DSH 的 node 与平台专属子包
+ *  (0.1.37 的 `dshcs-code-server-<平台>-<架构>` 全量树就是这么被取代的,见 docs/desktop-first-install-root-cause.md)。
+ *  体积与下载账:一份 52MB / 解包 197MB 供所有平台复用,而不是 4 × 52MB。
+ *  @param moduleNames - 本次重打包模块的原始名(用于校验核心原生模块没有泄漏进树里) */
+function buildVscodeServerPackage(moduleNames = []) {
   const vendorTree = join(pkgRoot, 'vendor', 'vscode');
   if (!existsSync(join(vendorTree, 'lib', 'vscode', 'out', 'server-main.js'))) {
     throw new Error('缺少 vendor/vscode;先运行 `node scripts/vendor-vscode-server.mjs`');
@@ -356,6 +407,38 @@ function buildVscodeServerPackage() {
     },
   });
   const name = `${SCOPE}/dshcs-vscode-server`;
+  // 不变式校验:核心原生模块**不许**出现在树里 —— 一旦泄漏,树就变成平台相关(在 win32 腿上打出来的
+  // tgz 会被 Linux 用户装上),而它只发布一次、不按 OS 区分 ⇒ 这种错必须在打包期就炸,不能悄悄发出去。
+  // 顺带把树里**其它**平台二进制列出来留痕:那些是可选扩展自带的(js-debug 的 win32 预编译、
+  // microsoft-authentication 的 msal 运行时、终端 PSReadLine 的 dll),不参与核心运行。
+  const leaked = [];
+  const others = [];
+  const aliasHints = moduleNames.map((n) => String(n).split('/').pop()).filter(Boolean);
+  const scan = (cur) => {
+    let entries; try { entries = readdirSync(cur, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const full = join(cur, e.name);
+      if (e.isDirectory()) {
+        if (e.name === 'node_modules') continue; // 已被排除,不该出现在这里
+        scan(full);
+        continue;
+      }
+      if (!/\.(node|so|dll|dylib|exe)$/i.test(e.name)) continue;
+      const rel = relative(dir, full).replaceAll('\\', '/');
+      if (aliasHints.some((h) => e.name.includes(h))) leaked.push(rel);
+      else others.push(rel);
+    }
+  };
+  scan(join(dir, 'vscode'));
+  if (leaked.length > 0) {
+    throw new Error(`${name}: 树里出现了核心原生模块的二进制,树包就不再平台无关了:${leaked.join(', ')}`
+      + ' —— 它们必须留在「内部依赖目录」(lib/vscode/node_modules 或 extensions/node_modules)里,'
+      + '由平台专属子包按目标供给;请检查 vendor/vscode 的结构变化与 buildVscodeServerPackage 的排除规则');
+  }
+  if (others.length > 0) {
+    console.log(`[repack] 树里另有 ${others.length} 个可选扩展自带的平台二进制(不参与核心运行,不影响"一份树包供所有平台"):`);
+    for (const o of others) console.log(`  · ${o}`);
+  }
   writeFileSync(join(dir, 'package.json'), JSON.stringify({
     name,
     version,
@@ -499,9 +582,177 @@ function readModules(targets) {
   return modules;
 }
 
+/** 重打包模块的平台政策(scripts/repack-platforms.json,**人工评审**;本脚本只读不写)。
+ *  @returns {{allTargets:string[]|null, publishedTargets:string[]|null,
+ *             perModule:Map<string,{platform:boolean|null, targets:string[]|null}>}} */
+function readRepackPlatforms() {
+  const doc = readJson(join(here, 'repack-platforms.json'));
+  const list = (v) => (Array.isArray(v) ? v.filter((t) => typeof t === 'string' && t !== '') : null);
+  const allTargets = list(doc?.targets);
+  if (allTargets === null || allTargets.length === 0) {
+    console.warn('  ⚠ 读不到 scripts/repack-platforms.json 的 targets ⇒ 平台政策退化为「构建目标即全部目标」,'
+      + '每模块白名单与跨平台保留都会失效');
+  }
+  const perModule = new Map();
+  for (const [alias, spec] of Object.entries(doc?.modules ?? {})) {
+    if (spec === null || typeof spec !== 'object') continue;
+    perModule.set(alias, {
+      platform: typeof spec.platform === 'boolean' ? spec.platform : null,
+      targets: list(spec.targets),
+      // 可选:我们自己定义的版本(重打包内容变了、而上游版本没变时用它,例如 2.1.1-dshcs.2)。
+      version: typeof spec.version === 'string' && spec.version !== '' ? spec.version : null,
+    });
+  }
+  return { allTargets, publishedTargets: list(doc?.publishedTargets), perModule };
+}
+
+/** 平台政策落到分析结果上:
+ *   ① 分类(是不是平台专属)以声明为准 —— analyze() 的结论随宿主漂移(Linux 上 windows-registry
+ *      没有 .node 会被判成平台无关,一旦写进 dependencies,Windows 运行时反而找不到 -win32-* 子包);
+ *   ② 平台专属模块补上目标白名单(缺席 = 全部目标);
+ *   ③ **保留本次分析看不到的条目**:用 --target 只构建本机目标时,表里其它平台的模块必须原样留下;
+ *   ④ 未在声明里登记的模块给出提醒(新模块).
+ *  @param modules - 就地修改的重打包条目(来自 analyze 或 --reuse) */
+function applyPlatformPolicy(modules, platforms, allTargets) {
+  const declared = (alias) => platforms.perModule.get(alias);
+  const existing = readJson(join(pkgRoot, 'lib', 'vendored.json'));
+  const previous = new Map((Array.isArray(existing?.modules) ? existing.modules : [])
+    .filter((e) => e !== null && typeof e === 'object' && typeof e.alias === 'string')
+    .map((e) => [e.alias, e]));
+
+  for (const m of modules) {
+    const decl = declared(m.alias);
+    if (decl === undefined) {
+      console.warn(`  ⚠ ${m.alias} 不在 scripts/repack-platforms.json 的模块表里 ⇒ 沿用分析结论`
+        + `(platform=${m.platform});建议登记它,否则换宿主平台时分类会漂移`);
+    } else if (decl.platform !== null && decl.platform !== m.platform) {
+      console.warn(`  ⚠ ${m.alias}:分析结论 platform=${m.platform},声明写的是 platform=${decl.platform} ⇒ 以声明为准`);
+      m.platform = decl.platform;
+    }
+    // 版本政策(**必须宿主与时点都无关**):① 声明里钉的 `version` 优先;② 否则沿用表里**已发布**的
+    // 版本;③ 只有表里没有这个模块(新模块)时才采用源树版本。
+    // 为什么不能照源树写:表里的版本就是 registry 上我们发布的那个号,而源树的版本会漂 ——
+    //   · kerberos:源树上游 2.1.1,我们发布的是 2.1.1-dshcs.1(聚合包时代的后缀);
+    //   · @vscode/proxy-agent:同一个 code-server 版本,维护者当时装到 0.44.0,今天全新装到 0.45.0
+    //     —— 依赖范围允许漂移,而 0.45.0 这个子包我们根本没发过。
+    // 照源树写 ⇒ 换个宿主平台或换一天重跑,插件依赖就会指向不存在的版本,装上直接解析失败。
+    // 要让插件升到新上游版本:在 scripts/repack-platforms.json 里给该模块钉 `version`,重跑本脚本
+    // 并把新子包发出去(下面这行会说明清楚)。
+    const prevVersion = typeof previous.get(m.alias)?.version === 'string' ? previous.get(m.alias).version : null;
+    if (decl?.version !== null && decl?.version !== undefined) {
+      if (decl.version !== m.version) console.log(`  · ${m.alias}:按声明钉版本 ${decl.version}(源树里是 ${m.version})`);
+      m.version = decl.version;
+    } else if (prevVersion !== null) {
+      if (prevVersion !== m.version) {
+        console.log(`  · ${m.alias}:沿用表里已发布的版本 ${prevVersion}(源树里是 ${m.version});`
+          + `要让插件改用它,请在 scripts/repack-platforms.json 里钉 version=${m.version} 并先发布对应的子包`);
+      }
+      m.version = prevVersion;
+    } else {
+      console.log(`  · ${m.alias}:新模块 ⇒ 采用源树版本 ${m.version}(记得先发布子包再把它写进依赖表)`);
+    }
+  }
+
+  const seen = new Set(modules.map((m) => m.alias));
+  const kept = [];
+  for (const e of [...previous.values()]) {
+    if (e === null || typeof e !== 'object' || typeof e.alias !== 'string' || seen.has(e.alias)) continue;
+    const decl = declared(e.alias);
+    kept.push({
+      alias: e.alias,
+      package: typeof e.package === 'string' && e.package !== '' ? e.package : `${SCOPE}/dshcs-${flat(e.alias)}`,
+      version: typeof e.version === 'string' ? e.version : null,
+      platform: decl?.platform ?? e.platform === true,
+      targets: decl?.targets ?? (Array.isArray(e.targets) ? e.targets : null),
+      carried: true,
+    });
+    seen.add(e.alias);
+  }
+  if (kept.length > 0) {
+    console.log(`[repack] 保留 ${kept.length} 个本次分析看不到的条目(其它平台的模块):${kept.map((k) => k.alias).join(', ')}`);
+    modules.push(...kept);
+    modules.sort((a, b) => a.alias.localeCompare(b.alias));
+  }
+
+  for (const m of modules) {
+    if (!m.platform) continue;
+    const wanted = m.targets ?? declared(m.alias)?.targets ?? null;
+    m.targets = wanted === null ? [...allTargets] : allTargets.filter((t) => wanted.includes(t));
+    if (m.targets.length === 0) {
+      console.warn(`  ⚠ ${m.alias}(平台专属)在白名单里没有任何目标 ⇒ 不会产出任何子包`);
+    }
+  }
+  for (const [alias, decl] of platforms.perModule) {
+    if (seen.has(alias) || decl.platform !== true) continue;
+    console.warn(`  ⚠ 声明里的 ${alias} 既不在本次分析结果、也不在 lib/vendored.json 里 ⇒ 无法为它产出子包`);
+  }
+  return modules;
+}
+
+/** 平台专属重打包包(写在插件 `optionalDependencies`)自带的**注册表依赖** —— 必须同时提成插件
+ *  自己的直接依赖。原因(0.3.46 实测,复现与证据见 docs/desktop-first-install-root-cause.md 第 5 节):
+ *  pnpm 的增量 hoisted 安装会把「optional 子树里 depth≥2」的依赖整支丢进 `node_modules/.modules.yaml`
+ *  的 `skipped`(`bindings` / `fs-extra` / `uuid` / `mkdirp` 全在内),而 dsh-desktop 在 `pnpm add`
+ *  之后**立刻**用 `require.resolve.paths()` 校验依赖图 ⇒ 首次安装报
+ *  `@jinsiyu/dshcs-kerberos-win32-arm64 requires missing bindings@^1.5.0`;
+ *  更糟的是 `pnpm install --frozen-lockfile` 会认为 «Already up to date»(锁文件本身也缺这些条目),
+ *  于是 profile 永远修不好,只能靠删 node_modules 重装。提到插件根依赖后它们落在 profile 根
+ *  `node_modules`,校验器与运行时都能解析到。这些都是纯 JS、无 ABI 约束,版本在此钉死;
+ *  将来平台专属包新增注册表依赖时 verifyOptionalSubtreeDeps() 会在构建期直接报错。 */
+const OPTIONAL_SUBTREE_DEPS = {
+  bindings: '1.5.0',
+  mkdirp: '1.0.4',
+  'fs-extra': '11.4.0',
+  uuid: '14.0.2',
+};
+
+/** 构建期闸门:平台专属重打包清单里的每个非别名依赖都必须落在**插件根依赖**里,
+ *  否则 pnpm 会把它丢进 skipped。两条来源都算数:
+ *    · OPTIONAL_SUBTREE_DEPS(仅这些包才需要、由本表钉版本的,例如 bindings);
+ *    · 树自己的直装集 `declare`(例如 node-addon-api —— VS Code 树本来就把它列为直接依赖,
+ *      生成器会按树里的版本写进插件 dependencies,同样落在 profile 根 node_modules)。
+ *  @param dirs - 已生成的平台专属重打包目录。
+ *  @param directDeps - 本次将写进插件 dependencies 的名字集合。 */
+function verifyOptionalSubtreeDeps(dirs, directDeps) {
+  const seen = new Set();
+  for (const dir of dirs) {
+    const m = readJson(join(dir, 'package.json'));
+    if (m === null) continue;
+    for (const fld of ['dependencies', 'optionalDependencies']) {
+      for (const [name, spec] of Object.entries(m[fld] ?? {})) {
+        if (String(spec).startsWith('npm:')) continue; // 已重打包(真名子包),不走注册表
+        seen.add(name);
+        if (!Object.hasOwn(OPTIONAL_SUBTREE_DEPS, name) && !directDeps.has(name)) {
+          throw new Error(`${m.name}: 注册表依赖 ${name}@${spec} 既不在 OPTIONAL_SUBTREE_DEPS、也不在插件的`
+            + ' 直装依赖里 —— 它位于 optional 子树(depth≥2),pnpm 的增量 hoisted 安装会丢包,'
+            + ' dsh-desktop 安装后立刻校验必报 requires missing;请把它提为插件直接依赖'
+            + '(见 docs/desktop-first-install-root-cause.md 第 5 节)');
+        }
+      }
+    }
+  }
+  const unused = Object.keys(OPTIONAL_SUBTREE_DEPS).filter((name) => !seen.has(name));
+  if (unused.length > 0) {
+    console.warn(`  ⚠ OPTIONAL_SUBTREE_DEPS 里的 ${unused.join(', ')} 已不再被任何平台专属包需要,可以删掉`);
+  }
+}
+
 function main() {
   const hostKey = `${process.platform}-${process.arch}`;
-  const targets = TARGETS.length > 0 ? TARGETS : [hostKey];
+  // 「构建哪些目标」(--target,缺省本机)与「产品覆盖哪些目标」是两件事:前者只影响本次构建,
+  // 后者来自 scripts/repack-platforms.json,决定 lib/vendored.json 的 targets、每模块白名单与插件
+  // optionalDependencies —— 否则在 Windows 上构建会把 Linux 的条目从依赖表里挤掉(反之亦然)。
+  const platforms = readRepackPlatforms();
+  const buildTargets = TARGETS.length > 0 ? TARGETS : [hostKey];
+  const allTargets = platforms.allTargets ?? buildTargets;
+  const publishedTargets = (platforms.publishedTargets ?? buildTargets).filter((t) => allTargets.includes(t));
+  for (const t of buildTargets) {
+    if (!allTargets.includes(t)) console.warn(`  ⚠ --target ${t} 不在 repack-platforms.json 的 targets 里(仍按请求构建)`);
+  }
+  if (publishedTargets.length === 0) {
+    throw new Error('repack-platforms.json 的 publishedTargets 与 targets 没有交集 ⇒ 生成不出插件依赖表');
+  }
+  console.log(`[repack] 平台政策:产品目标 ${allTargets.join(', ')};已发布(可写进插件依赖)${publishedTargets.join(', ')}`);
 
   let repack = null;
   let modules;
@@ -509,7 +760,7 @@ function main() {
   let reusedItems = [];
   let autoSourceTree = null;
   if (REUSE) {
-    ({ modules, declare, reusedItems } = reuseExisting(targets));
+    ({ modules, declare, reusedItems } = reuseExisting(buildTargets));
   } else {
     const autoSource = FROM === null;
     const sourceTree = autoSource ? prepareSourceTree() : FROM;
@@ -525,9 +776,20 @@ function main() {
       .sort((a, b) => a.alias.localeCompare(b.alias));
     rmSync(OUT, { recursive: true, force: true });
   }
+  applyPlatformPolicy(modules, platforms, allTargets);
   console.log(`\n重打包集(${modules.length}):`);
   for (const m of modules) {
-    console.log(`  ${m.alias}@${m.version} → ${m.package}${m.platform ? `-<平台>` : ''} ${m.platform ? '[平台专属]' : '[全平台]'}`);
+    const tag = m.platform ? `[平台专属 ${m.targets.join('|')}]` : '[全平台]';
+    console.log(`  ${m.alias}@${m.version} → ${m.package}${m.platform ? '-<平台>' : ''}${m.carried ? ' (保留)' : ''} ${tag}`);
+  }
+  const rootPkgFile = join(pkgRoot, 'package.json');
+  const previousDeps = readJson(rootPkgFile)?.dependencies ?? {};
+  for (const d of declare) {
+    const prev = previousDeps[d.name];
+    if (typeof prev === 'string' && prev !== d.version) {
+      console.log(`  · ${d.name}:源树版本 ${d.version}(仓库依赖表里是 ${prev})—— 上游纯 JS 包,跟着树走安全`
+        + '(树里的版本一定来自 npm;这类差异是**时间**相关而非宿主相关)');
+    }
   }
   console.log(`\n直装集(${declare.length}): ${declare.map((d) => d.name).join(', ')}\n`);
 
@@ -535,7 +797,7 @@ function main() {
 
   // 每个目标的包名映射:平台专属的按目标拼后缀,平台无关的到处同名
   const byTarget = new Map();
-  for (const target of targets) {
+  for (const target of buildTargets) {
     const map = new Map(); // 原包名 -> { pkgName, version, platformSpecific }
     for (const m of modules) {
       map.set(m.alias, {
@@ -588,6 +850,20 @@ function main() {
         if (wrong.length > 0) {
           console.warn(`  ⚠ ${pkg.pkgName}: ${wrong.length} 个 .node 架构不符(期望 ${want})`);
         }
+      } else if (platform === 'linux') {
+        // 同上,ELF 版:e_machine 必须是目标架构(0x3e=x86-64 / 0xb7=AArch64)
+        const want = arch === 'x64' ? '0x3e' : '0xb7';
+        const files = nodeFilesOf(dir);
+        const wrong = files
+          .map((file) => [file, elfMachine(file)])
+          .filter(([, machine]) => machine !== null && machine !== want);
+        if (files.length > 0 && wrong.length === files.length) {
+          throw new Error(`${pkg.pkgName}: 所有 .node 架构都不是 ${want}`
+            + `(${wrong.map(([file, machine]) => `${relative(dir, file)}=${machine}`).join(', ')})`);
+        }
+        if (wrong.length > 0) {
+          console.warn(`  ⚠ ${pkg.pkgName}: ${wrong.length} 个 .node 架构不符(期望 ${want})`);
+        }
       }
     }
     for (const fld of ['dependencies', 'optionalDependencies']) {
@@ -605,44 +881,173 @@ function main() {
   // 0) 已打包的原生包(--reuse 模式)
   for (const item of reusedItems) plan.push(item);
   // 1) VS Code 树(平台无关,1 个包)
-  const vscodePkg = buildVscodeServerPackage();
+  const vscodePkg = buildVscodeServerPackage(modules.map((m) => m.alias));
   plan.push({ dir: vscodePkg.dir, file: vscodePkg.file });
   // 2) 全平台重打包包(从 host 树;--reuse 时用已打包目录)
+  //    「要不要按平台分包」一律以**声明**为准(applyPlatformPolicy 已把结论钉到 modules 上),
+  //    源树分析只提供源目录与上游版本。照分析结论走的话,本机工具链编不出 .node 时这些模块会被
+  //    静默当成平台无关、打成不带目标后缀的包,而依赖表里照旧写着「每目标一份」。
   if (!REUSE) {
-    for (const [name, r] of repack) {
-      if (r.platformSpecific) continue; // 平台专属的按目标处理
-      const dir = writeRepack(r.dir, hostMap.get(name), flat(name));
-      plan.push({ dir, file: tgzName(hostMap.get(name).pkgName, r.pkg.version) });
+    const independentModules = modules.filter((m) => !m.platform);
+    if (SKIP_INDEPENDENT) {
+      console.log(`[repack] --skip-independent:跳过 ${independentModules.length} 个平台无关包`
+        + '(它们由 win32-x64 腿产出并发布,本腿只产自己的平台专属包)');
+    } else for (const m of independentModules) {
+      const r = repack.get(m.alias);
+      if (r === undefined) continue; // 「保留」条目(本宿主看不到它的包)⇒ 没有源目录可打包
+      const dir = writeRepack(r.dir, hostMap.get(m.alias), flat(m.alias));
+      plan.push({ dir, file: tgzName(hostMap.get(m.alias).pkgName, m.version) });
     }
   }
-  // 3) 平台专属包:host 用现成树,其它目标用交叉安装树(--reuse 时用已打包目录)
-  if (!REUSE) for (const target of targets) {
+  // 3) 平台专属包:host 用现成树,其它目标用交叉安装树(--reuse 时用已打包目录)。
+  //    · 白名单不含该目标 ⇒ 不构建(Windows-only 模块不产 -linux-*,反之亦然);
+  //    · 该目标上没编出 .node / 源树里没这个模块 ⇒ 也跳过,但**是否致命交给下面的硬闸门**。
+  const platformDirs = [];
+  const builtByTarget = new Map(buildTargets.map((t) => [t, []]));
+  const gradedSpecific = new Map(buildTargets.map((t) => [t, []]));
+  const skipped = { policy: [], noBinary: [], missing: [] };
+  if (!REUSE && !ONLY_INDEPENDENT) for (const target of buildTargets) {
     const map = byTarget.get(target);
-    const specs = [...repack].filter(([, r]) => r.platformSpecific).map(([name, r]) => ({ name, version: r.pkg.version }));
+    const eligible = modules.filter((m) => m.platform === true
+      && (m.targets ?? allTargets).includes(target) && repack.has(m.alias));
+    for (const m of modules) {
+      if (m.platform === true && repack.has(m.alias) && !(m.targets ?? allTargets).includes(target)) {
+        skipped.policy.push(`${m.alias}@${target}`);
+      }
+    }
+    gradedSpecific.set(target, eligible.map((m) => m.alias));
+    const specs = eligible.map((m) => ({ name: m.alias, version: repack.get(m.alias).pkg.version }));
     let crossTree = null;
     if (target !== hostKey && specs.length > 0) crossTree = prepareCrossTree(specs, target);
-    for (const [name, r] of repack) {
-      if (!r.platformSpecific) continue;
-      const info = map.get(name);
-      const srcDir = target === hostKey ? r.dir : join(crossTree, 'node_modules', name);
+    for (const m of eligible) {
+      const r = repack.get(m.alias);
+      const info = map.get(m.alias);
+      const srcDir = target === hostKey ? r.dir : join(crossTree, 'node_modules', m.alias);
       if (!existsSync(join(srcDir, 'package.json'))) {
-        console.warn(`  ⚠ ${target}: 缺少 ${name},跳过`);
+        console.warn(`  ⚠ ${target}: 缺少 ${m.alias},跳过(硬闸门会判定是否致命)`);
+        skipped.missing.push(`${m.alias}@${target}`);
         continue;
       }
-      const dir = writeRepack(srcDir, info, `${flat(name)}-${target}`);
-      plan.push({ dir, file: tgzName(info.pkgName, r.pkg.version) });
+      if (nodeFilesOf(srcDir).length === 0) {
+        console.warn(`  ⚠ ${target}: ${m.alias} 没有产出 .node 二进制 ⇒ 跳过(硬闸门会判定是否致命)`);
+        skipped.noBinary.push(`${m.alias}@${target}`);
+        continue;
+      }
+      const dir = writeRepack(srcDir, info, `${flat(m.alias)}-${target}`);
+      platformDirs.push(dir);
+      builtByTarget.get(target).push(m.alias);
+      plan.push({ dir, file: tgzName(info.pkgName, m.version) });
     }
     if (crossTree !== null) rmSync(crossTree, { recursive: true, force: true });
   }
+  // 3b) --reuse 时平台专属目录已存在(不重新构建),就地复查闸门
+  if (REUSE) for (const item of reusedItems) {
+    if (PLATFORM_SUFFIX.test(String(readJson(join(item.dir, 'package.json'))?.name ?? ''))) platformDirs.push(item.dir);
+  }
+  // 产物 → (目标, 模块) 反查:目录名就是「flat(别名)-目标」。记账(`builtByTarget`)与实际产出的
+  // 集合必须**逐个模块**一致 —— 只比个数会漏掉「各 2 个但不是同一批」这种错位
+  // (2026-09-16 实测:原生包没编出来时,kerberos 被判成平台无关、目录不带后缀,而 tgz 名却按声明带了
+  //  -linux-x64 后缀,个数还刚好相等)。
+  const packedByTarget = new Map(buildTargets.map((t) => [t, new Set()]));
+  for (const dir of platformDirs) {
+    const base = basename(dir);
+    for (const target of buildTargets) {
+      for (const m of modules) {
+        if (m.platform === true && base === `${flat(m.alias)}-${target}`) packedByTarget.get(target).add(m.alias);
+      }
+    }
+  }
+  // 每个构建目标一行结论(CI 里同时发 annotation:Actions 原始日志要鉴权读不回,
+  // annotation 匿名可读,且 ≤20 条上限 —— 所以这里**只发汇总行**,不逐个模块发)。
+  if (REUSE) {
+    const line = `[repack] --reuse:复用 ${platformDirs.length} 个平台专属目录(不重新构建,故不做白名单/二进制过滤)`;
+    console.log(line);
+    if (process.env.GITHUB_ACTIONS === 'true') console.log(`::notice::${line}`);
+  } else if (ONLY_INDEPENDENT) {
+    const indep = modules.filter((m) => !m.platform);
+    const line = `[repack] --only-independent:产出 ${indep.length} 个平台无关包(${indep.map((m) => m.alias).join(', ')})`
+      + ` + VS Code 树包;平台专属包一律不产(那条腿不跑平台专属循环)`;
+    console.log(line);
+    if (process.env.GITHUB_ACTIONS === 'true') console.log(`::notice::${line}`);
+  } else for (const target of buildTargets) {
+    const built = builtByTarget.get(target) ?? [];
+    const graded = gradedSpecific.get(target) ?? [];
+    const packed = packedByTarget.get(target) ?? new Set();
+    const n = (list) => list.filter((s) => s.endsWith(`@${target}`)).length;
+    const line = `[repack] ${target}: 源树判定平台专属 ${graded.length} 个(${graded.join(', ') || '无'})`
+      + ` ⇒ 打包 ${packed.size} 个(${[...packed].join(', ') || '无'});白名单排除 ${n(skipped.policy)}`
+      + `;无二进制跳过 ${n(skipped.noBinary)}`
+      + `${n(skipped.missing) > 0 ? `;目录缺失跳过 ${n(skipped.missing)}` : ''}`
+      + `;平台无关 ${modules.filter((m) => !m.platform).length} 个`;
+    console.log(line);
+    if (process.env.GITHUB_ACTIONS === 'true') console.log(`::notice::${line}`);
+    const onlyBuilt = built.filter((a) => !packed.has(a));
+    const onlyPacked = [...packed].filter((a) => !built.includes(a));
+    if (onlyBuilt.length > 0 || onlyPacked.length > 0) {
+      const detail = `记账与产物不一致:只记账 ${onlyBuilt.join(', ') || '(无)'};只有产物 ${onlyPacked.join(', ') || '(无)'}`;
+      console.warn(`  ⚠ ${target}: ${detail}`);
+      if (process.env.GITHUB_ACTIONS === 'true') console.log(`::warning::${target}: ${detail}`);
+    }
+  }
+  if (skipped.noBinary.length > 0) {
+    console.warn(`  ⚠ 以下「模块×目标」在白名单里但没编出二进制:${skipped.noBinary.join(', ')};`
+      + '若该平台确实需要它,查编译日志;若不需要,请从 scripts/repack-platforms.json 里删掉该目标');
+  }
+  // ── 硬闸门:声明里承诺「某模块在某目标上有子包」,就必须真的产出 ──────────────────────────
+  // 为什么必须有它:`npm rebuild` 的失败是被 try/catch 吞掉的(单个原生包编不出来不该卡住整条链),
+  // 于是「本机工具链编不出 .node」会静默退化成「这个模块被当成平台无关、打成不带目标后缀的包」,
+  // 而依赖表里照旧写着「每目标一份」—— 发出去的就是一套装不起来的东西,而 CI 仍然是绿的。
+  // 2026-09-16 维护者问「为什么 CI 输出里有 npm error 仍然通过了」时暴露:Linux 腿上
+  // @vscode/spdlog / sqlite3 / kerberos 都 npm error,5 个承诺的包只产出 2 个,run 却是绿的。
+  if (ONLY_INDEPENDENT) {
+    // 这条腿只产平台无关层 ⇒ 闸门也只管这一层:声明里(或源树里)的平台无关模块必须都产出。
+    const missing = modules
+      .filter((m) => !m.platform && repack.has(m.alias))
+      .filter((m) => !plan.some((item) => basename(String(item.dir ?? '')) === flat(m.alias)));
+    if (missing.length > 0) {
+      const detail = `--only-independent:这些平台无关重打包包没产出:${missing.map((m) => m.alias).join(', ')}`;
+      console.error(`[repack] ✗ ${detail}`);
+      if (process.env.GITHUB_ACTIONS === 'true') console.log(`::error::${detail}`);
+      throw new Error(`${detail} —— 检查源树是否完整(npm install 失败?)和日志里的 npm error`);
+    }
+  } else {
+    const missing = [];
+    for (const target of buildTargets) {
+      const produced = packedByTarget.get(target) ?? new Set();
+      for (const m of modules) {
+        if (m.platform !== true || !(m.targets ?? allTargets).includes(target)) continue;
+        if (!produced.has(m.alias)) missing.push(`${m.alias}@${target}`);
+      }
+    }
+    if (missing.length > 0) {
+      const detail = `声明(scripts/repack-platforms.json)里承诺却没产出子包的「模块×目标」:${missing.join(', ')}`;
+      const hint = '常见原因:① 本机工具链编不出该原生包 —— 日志里的 npm error / MSB8020 就是它'
+        + '(Windows 上注意 MSVC 工具集版本;装对应工具集,或改在 CI 腿上构建);'
+        + '② 源树里没有这个模块(npm install 失败,或上游把它去掉了);'
+        + '③ 该目标本来就不该有这个模块 ⇒ 从该模块的 targets 里删掉这个目标。';
+      console.error(`[repack] ✗ ${detail}`);
+      if (process.env.GITHUB_ACTIONS === 'true') console.log(`::error::${detail} —— ${hint}`);
+      throw new Error(`${detail} —— ${hint}`);
+    }
+  }
+  verifyOptionalSubtreeDeps(platformDirs, new Set([
+    ...declare.map((d) => d.name),
+    ...Object.keys(OPTIONAL_SUBTREE_DEPS),
+  ]));
   // 3) 重打包表(lib/vendored.json,随插件发布):运行时用它把真名子包补成原始名字
   const vendoredDoc = {
     schemaVersion: 1,
     generatedBy: 'scripts/vendor-repacks.mjs',
     scope: SCOPE,
-    targets,
+    targets: allTargets,
     modules: modules.map((m) => {
       const entry = { alias: m.alias, package: m.package, version: m.version };
-      if (m.platform) entry.platform = true;
+      if (m.platform) {
+        entry.platform = true;
+        // 每模块目标白名单:运行时(lib/native.js)据此跳过本平台不适用的模块 ——
+        // 否则 Linux 上会去找 @jinsiyu/dshcs-vscode-windows-registry-linux-x64,把缺包报成故障。
+        entry.targets = [...(Array.isArray(m.targets) ? m.targets : allTargets)];
+      }
       return entry;
     }),
   };
@@ -655,7 +1060,8 @@ function main() {
   console.log(`[repack] 生成 ${plan.length} 个待打包目录 → repack/ (计划:repack/pack-plan.json)`);
 
   // 4) 改写插件 package.json 的依赖:树 + 纯 JS 直装集 + **全平台**重打包包写 dependencies(真名);
-  //    平台专属的重打包包按目标写 optionalDependencies(真名 + 包自带 os/cpu,包管理器按架构自动选)。
+  //    平台专属的重打包包按目标写 optionalDependencies(真名 + 包自带 os/cpu,包管理器按架构自动选),
+  //    它们自己的注册表依赖再由 OPTIONAL_SUBTREE_DEPS 提到 dependencies(否则 pnpm 丢包,见该表注释)。
   //    这样每个包在依赖图里都是「根项目的直接依赖」,不依赖 pnpm 对可选子树别名的处理
   //    (见 docs/desktop-first-install-root-cause.md)。
   const pkgFile = join(pkgRoot, 'package.json');
@@ -664,15 +1070,23 @@ function main() {
     [vscodePkg.name, vscodePkg.version],
     ...declare.map((d) => [d.name, d.version]),
     ...independent.map((m) => [m.package, m.version]),
+    ...Object.entries(OPTIONAL_SUBTREE_DEPS),
   ].sort(([a], [b]) => a.localeCompare(b)));
-  pluginPkg.optionalDependencies = Object.fromEntries(targets
-    .flatMap((t) => specific.map((m) => [`${m.package}-${t}`, m.version]))
+  pluginPkg.optionalDependencies = Object.fromEntries(publishedTargets
+    .flatMap((t) => specific.filter((m) => m.targets.includes(t)).map((m) => [`${m.package}-${t}`, m.version]))
     .sort(([a], [b]) => a.localeCompare(b)));
   writeFileSync(pkgFile, JSON.stringify(pluginPkg, null, 2) + '\n', 'utf8');
   console.log(`[repack] 已写入 package.json:dependencies ${Object.keys(pluginPkg.dependencies).length} 个`
-    + `(VS Code 树 + 纯 JS + ${independent.length} 个全平台重打包包),`
+    + `(VS Code 树 + 纯 JS + ${independent.length} 个全平台重打包包`
+    + ` + ${Object.keys(OPTIONAL_SUBTREE_DEPS).length} 个 optional 子树兜底依赖),`
     + `optionalDependencies ${Object.keys(pluginPkg.optionalDependencies).length} 个`
-    + `(${specific.length} 个平台专属重打包包 × ${targets.length} 个目标)`);
+    + `(${specific.length} 个平台专属重打包包 × 已发布目标 ${publishedTargets.join('|')},按每模块白名单取交集)`);
+  const pendingTargets = allTargets.filter((t) => !publishedTargets.includes(t));
+  if (pendingTargets.length > 0) {
+    console.log(`[repack] 注意:${pendingTargets.join(', ')} 的子包**还没发布到 npm** ⇒ 暂不写进插件依赖`
+      + '(写进去会让 pnpm install 解析一个不存在的包)。发布后把 scripts/repack-platforms.json 的'
+      + ' publishedTargets 补齐、再跑一次本脚本,并刷新 pnpm-lock.yaml');
+  }
 
   // 5) 可选:直接打包
   if (DO_PACK) {