@morlay/dsh-client-modules 0.0.0-stage → 0.2.6

package/dist/index.cjs

@@ -0,0 +1,1445 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_fs_promises = require("node:fs/promises");
+let node_module = require("node:module");
+let node_path = require("node:path");
+let node_url = require("node:url");
+let _morlay_dsh_cordis_assets_assets = require("@morlay/dsh-cordis-assets/assets");
+let node_crypto = require("node:crypto");
+let _morlay_dsh_cordis_assets_styles = require("@morlay/dsh-cordis-assets/styles");
+let rolldown = require("rolldown");
+let vite = require("vite");
+//#region src/trace.ts
+/**
+* 诊断细节（逐包预编译、逐请求那一类）的具名 logger。
+*
+* 名字交给 logger（`ctx.logger(name)`）；**值走参数**、不拼进文本——cordis 的 logger 没有"每次调用带
+* meta"这回事（`meta` 是 logger 实例级的），所以结构化的东西作为 `%o` 的参数传（exporter 拿到的
+* `args` 里是结构与值，而不是一段 `key=value` 文本）。键名若出现，用 `.` 分层、不带空格。
+*
+* **是否调用**由本开关决定：运行时的日志门槛不由我们定（loader 注册的 exporter 允许 DEBUG），而这类细节
+* 一次启动两千多行、每请求一行，默认不调，`DSH_TRACE=1` 时再调。出问题的几行走 `warn`。
+* @param ctx - 这条链的上下文。
+* @param name - 这个 logger 的名字（如 `federation` / `vite`）。
+* @returns `(format, ...args)` 形态的诊断出口；开关没开时什么都不做。
+*/
+function traceOf(ctx, name) {
+	if (process.env["DSH_TRACE"] !== "1") return () => {};
+	const logger = ctx.logger(name);
+	return (format, ...args) => {
+		logger.debug(format, ...args);
+	};
+}
+//#endregion
+//#region src/config.ts
+/**
+* dev 形态的分流配置：profile 的 `dsh.dev.exclude` 点名的包**不算开发模块**。
+*
+* 那些包（如 `@deepseek-ai/*`）在 dev 期间不打算改，于是不值得为它们付"逐文件请求"的代价——
+* 走按包聚合（一个包一份产物、共享 chunk），换掉模块级 HMR；没被点名的包是正在改的，保持逐文件走 vite。
+*/
+/** 一条 glob（只支持 `*`，够用）→ 正则。 */
+function globToRegExp(pattern) {
+	const escaped = pattern.replace(/[/\\^$+?.()|[\]{}]/gu, "\\$&").replaceAll("*", ".*");
+	return new RegExp(`^${escaped}$`);
+}
+/**
+* 读 profile 的 `dsh.dev.exclude`。
+*
+* profile 根按这个顺序找：启动器给的 `DSH_DESKTOP_DEV_PROFILE_DIR`（桌面形态）；`DSH_HOME` 的父目录
+* （它总是 `<profile>/.dsh-store`，web 形态也有）；当前目录。
+*
+* @returns 匹配"非开发模块"的正则表；**没配就是全部**（见函数末尾的说明）。
+*/
+/**
+* 桌面形态（含 bundle）：**全部按非开发模块**处理。
+*
+* 它的页面跑在自定义协议下（`dsh-…://app/`），请求经壳的字节管道进来——每个逐文件请求都要走一趟这条路，
+* 几百个源码模块叠起来就是"刷新一次卡几十秒"。桌面形态本来也不需要"改哪个包只看哪个包"的细粒度取舍：
+* 全部按包预编译，改包时那一份重建 + 通知页面刷新（见壳的 ws 端点）。
+*/
+/**
+* 是不是**开发形态**（`dshdev web` / `dshdev desktop`；打包产物不是）。
+*
+* `DSH_DEV_FORM` 由 `dshdev` 注入给宿主（壳起宿主时会过滤掉 `DSH_DESKTOP_*`，那些是 Electron 侧的元数据；
+* web 形态没有壳，所以这条由 CLI 直接给）——值只说哪种形态，**有没有值**才是判据。这一判据**一个 home**：
+* 预编译策略（本文件）与"这条链的根在哪"（`src/index.ts` 的 `repoRootOf`）都用它。
+*
+* @returns dev 形态为 true；bundle（打包产物）为 false。
+*/
+function isDevForm() {
+	return process.env["DSH_DEV_FORM"] !== void 0;
+}
+async function devExcluded(profileDir) {
+	if (!isDevForm()) return [/.*/u];
+	try {
+		const patterns = (JSON.parse(await (0, node_fs_promises.readFile)((0, node_path.join)(profileDir, "package.json"), "utf8")).dsh?.dev?.exclude ?? []).map(globToRegExp);
+		if (patterns.length > 0) return patterns;
+	} catch {}
+	return [/.*/u];
+}
+/**
+* 该包是否走**聚合**（即"非开发模块"）。
+*
+* @param name - 包名。
+* @param patterns - {@link devExcluded} 的结果。
+* @returns 命中任一 glob 即为真。
+*/
+function isAggregated(name, patterns) {
+	return patterns.some((pattern) => pattern.test(name));
+}
+//#endregion
+//#region src/resolve.ts
+/** 路由前缀（沿用上游的 `/plugins`，页面上不改 URL 形态）。 */
+const PLUGIN_ROUTE = "/plugins";
+/** `@deepseek-ai/dsh-x` → `@deepseek-ai+dsh-x`：包名里的 `/` 在 URL 段里要转义。 */
+/**
+* **出口名 ↔ 产物文件名**的约定：出口产物的文件名是 `<出口名>.js`。
+*
+* 这条规则**只有一处**（这里）：`urlOf` 生成地址、产物路由解析地址，两边都调它——各写一遍"补 `.js` / 剥
+* `.js`"就会漂（`remote` 与 `remote.js` 两种地址，明明产出过却查不到）。
+*/
+function entryFileNameOf(exportName) {
+	return `${exportName}.js`;
+}
+/**
+* 地址里的文件名 → 出口名（{@link entryFileNameOf} 的反向）。
+*
+* @param file - 地址里最后一段（`client.js`、`remote.js`、`chunks/…`）。
+* @returns 出口名；没有扩展名的按原样（`index` 是包级引用的缺省出口）。
+*/
+function exportNameOfFileName(file) {
+	return file.replace(/\.js$/u, "") || "index";
+}
+function encodePackageName(name) {
+	return name.replace("/", "+");
+}
+function decodePackageName(segment) {
+	return segment.replace("+", "/");
+}
+function parsePluginAddress(url) {
+	const path = url.split("?")[0] ?? "";
+	if (!path.startsWith(`/plugins/`)) return void 0;
+	const segments = path.slice(9).split("/").filter((segment) => segment !== "");
+	if (segments[0]?.startsWith("??") === true || segments[0]?.startsWith(".") === true) return void 0;
+	const [pkgSegment, version, ...exportSegments] = segments;
+	if (pkgSegment === void 0 || version === void 0) return void 0;
+	const exportSegment = exportSegments.join("/");
+	return {
+		name: decodePackageName(pkgSegment),
+		version,
+		exportName: exportSegment === "" || exportSegment === "_default" ? "." : `./${exportSegment}`
+	};
+}
+/**
+* 条件导出里挑**运行期**入口：`import` > `default` > `require` > `types`。
+*
+* 条件是**可嵌套**的（`zustand` 的 `./vanilla` 出口就是
+* `{ import: { types, default }, default: { types, default } }`），所以命中条件后要继续往里挑——
+* 只看顶层字符串会跳过 `import` 落到 `default`，拿到 CJS 那支（`vanilla.js` 而不是 `esm/vanilla.mjs`），
+* 产物里就只剩 `export default require_…`，消费方要的具名导出一个都没有。
+*/
+function pickCondition(entry) {
+	if (typeof entry === "string") return entry;
+	if (Array.isArray(entry)) {
+		for (const item of entry) {
+			const picked = pickCondition(item);
+			if (picked !== void 0) return picked;
+		}
+		return;
+	}
+	if (entry === null || typeof entry !== "object") return void 0;
+	const record = entry;
+	for (const key of [
+		"import",
+		"default",
+		"require",
+		"types"
+	]) {
+		if (!(key in record)) continue;
+		const picked = pickCondition(record[key]);
+		if (picked !== void 0) return picked;
+	}
+}
+/**
+* 工作区包索引：包名 → 包根。
+*
+* `pnpm` 的布局只保证"**能解析的**才在"——vendor 里的包、以及当前包没声明为依赖的工作区包，从 importer
+* 出发都解析不到。但它们是**仓库内的包**（有自己的 `exports`、自己的 `./client` 出口），不该被当成三方。
+* 所以扫一遍仓库内的清单，懒建一次索引。
+*/
+let workspaceIndex;
+/** 从某个文件向上找仓库根（`pnpm-workspace.yaml` 那一层）。 */
+async function workspaceRootOf(from) {
+	let directory = (0, node_path.dirname)(from);
+	for (;;) {
+		if (await (0, node_fs_promises.readFile)((0, node_path.join)(directory, "pnpm-workspace.yaml"), "utf8").then(() => true, () => false)) return directory;
+		const parent = (0, node_path.dirname)(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
+}
+async function workspaceIndexOf(from) {
+	workspaceIndex ??= (async () => {
+		const index = /* @__PURE__ */ new Map();
+		const root = await workspaceRootOf(from);
+		if (root === void 0) return index;
+		const { glob } = await import("node:fs/promises");
+		for (const pattern of [
+			"packages/*/*/package.json",
+			"vendor/*/packages/*/*/package.json",
+			"vendor/*/vendor/*/package.json"
+		]) for await (const file of glob(pattern, { cwd: root })) {
+			const path = (0, node_path.join)(root, file);
+			const manifest = JSON.parse(await (0, node_fs_promises.readFile)(path, "utf8").catch(() => "{}"));
+			if (manifest.name !== void 0) index.set(manifest.name, (0, node_path.dirname)(path));
+		}
+		return index;
+	})();
+	return await workspaceIndex;
+}
+/**
+* 包名 → 包根：走 node 的解析（pnpm 已经把依赖摆好了），**解析入口**再向上找最近的清单。
+*
+* 不能用 `resolve('<name>/package.json')`：现代包（`clsx` 这类）的 `exports` 通常不暴露
+* `./package.json`，那样明明装着也解析不出来。
+*/
+async function packageRootOf(from, name) {
+	const bare = name.split("/").slice(0, name.startsWith("@") ? 2 : 1).join("/");
+	const require$2 = from.startsWith("\0") ? void 0 : (0, node_module.createRequire)(from);
+	try {
+		if (require$2 === void 0) throw new Error("virtual id: 不走 node 解析");
+		const owned = await owningPackageOf(require$2.resolve(bare));
+		if (owned !== void 0) return owned;
+	} catch {}
+	for (const directory of require$2?.resolve.paths(bare) ?? []) {
+		const manifest = (0, node_path.join)(directory, bare, "package.json");
+		if (await (0, node_fs_promises.readFile)(manifest, "utf8").then(() => true, () => false)) {
+			const owned = await owningPackageOf(manifest);
+			if (owned !== void 0) return owned;
+		}
+	}
+	const root = (await workspaceIndexOf(from)).get(name);
+	return root === void 0 ? void 0 : await owningPackageOf((0, node_path.join)(root, "package.json"));
+}
+/**
+* 按包清单的 `exports` 解析子路径（`./client` → `./src/client/index.ts`）。
+*
+* 不能自己拼 `src/<subpath>`：出口名与文件名**不同构**（`./client` 指向 `src/client/index.ts`、
+* `./remote` 指向 `lib/typert.remote-client.ts` 这类都由清单说了算）。
+*/
+async function exportTargetOf(root, subpath) {
+	try {
+		const manifest = JSON.parse(await (0, node_fs_promises.readFile)((0, node_path.join)(root, "package.json"), "utf8"));
+		const key = subpath === void 0 ? "." : `./${subpath}`;
+		const table = manifest.exports;
+		const entry = (table !== void 0 && Object.keys(table).some((name) => name === "." || name.startsWith("./")) ? table?.[key] : key === "." ? table : void 0) ?? (key === "." ? manifest.module ?? manifest.main : void 0);
+		const target = typeof entry === "string" ? entry : entry === null || typeof entry !== "object" ? void 0 : pickCondition(entry);
+		if (typeof target !== "string") return void 0;
+		return resolveInPackage({
+			name: "",
+			version: "",
+			root
+		}, target.replace(/^\.\//u, ""));
+	} catch {
+		return;
+	}
+}
+/** 读包清单。 */
+async function manifestOf(root) {
+	try {
+		const manifest = JSON.parse(await (0, node_fs_promises.readFile)((0, node_path.join)(root, "package.json"), "utf8"));
+		if (manifest.name === void 0) return void 0;
+		return {
+			...manifest,
+			name: manifest.name,
+			version: manifest.version ?? "0"
+		};
+	} catch {
+		return;
+	}
+}
+/** 向上找最近的包（软链已由 node 解析解开）：返回清单与包根。 */
+async function owningPackageOf(file) {
+	let directory = (0, node_path.dirname)(file);
+	while (directory !== (0, node_path.dirname)(directory)) {
+		const manifest = await manifestOf(directory);
+		if (manifest !== void 0) return {
+			...manifest,
+			root: directory
+		};
+		directory = (0, node_path.dirname)(directory);
+	}
+}
+/** 包根 + 包内路径 → 绝对路径；越出包根一律拒绝（寻址来自 URL，不能穿透到仓库别处）。 */
+function resolveInPackage(pkg, filepath) {
+	const target = (0, node_path.resolve)(pkg.root, filepath);
+	const inside = (0, node_path.relative)(pkg.root, target);
+	return inside === "" || inside.startsWith("..") || inside.startsWith(node_path.sep) ? void 0 : target;
+}
+/**
+* 包内**物理路径**回退：清单的 `exports` 没覆盖这个子路径时，按约定位置找文件。
+*
+* 老包很常见：`picomatch` 没有 `exports`、只有 `main`，而 `picomatch/posix` 就是 `posix.js`；
+* 只声明了部分子路径的包同理。寻址按 URL 来（`<pkg>@<version>/<子路径>.js`），所以这里按子路径找文件。
+*/
+async function fileInPackage(root, subpath) {
+	const pkg = {
+		name: "",
+		version: "",
+		root
+	};
+	for (const candidate of [
+		subpath,
+		`${subpath}.js`,
+		`${subpath}.mjs`,
+		(0, node_path.join)(subpath, "index.js"),
+		(0, node_path.join)(subpath, "index.mjs"),
+		(0, node_path.join)(subpath, "index.ts")
+	]) {
+		const file = resolveInPackage(pkg, candidate);
+		if (file !== void 0 && await (0, node_fs_promises.readFile)(file, "utf8").then(() => true, () => false)) return file;
+	}
+}
+/**
+* 说明符里的包名：`@scope/name` 取两段、`name` 取一段。作用域包**没有子路径**时，
+* `indexOf("/", slash + 1)` 会返回 -1——直接 `slice` 会削掉最后一个字符，这里显式判掉。
+*/
+function packageNameOf(specifier) {
+	if (!specifier.startsWith("@")) return specifier.split("/")[0] ?? specifier;
+	const slash = specifier.indexOf("/");
+	if (slash < 0) return specifier;
+	const second = specifier.indexOf("/", slash + 1);
+	return second < 0 ? specifier : specifier.slice(0, second);
+}
+/**
+* 包根 → 它**浏览器面**的文件。
+*
+* @param root - 包根目录。
+* @param subpath - 出口名（不含包名，如 `client`、`brand-font.css`）；省略表示包的根出口。
+* @returns 该出口对应的文件；清单没这个出口、且约定路径也不存在时返回 undefined。
+*/
+async function clientHalfOf(root, subpath) {
+	const exists = async (file) => await (0, node_fs_promises.readFile)(file, "utf8").then(() => true, () => false);
+	if (subpath !== void 0) {
+		const byExports = await exportTargetOf(root, subpath);
+		if (byExports !== void 0) return byExports;
+		const pkg = {
+			name: "",
+			version: "",
+			root
+		};
+		for (const candidate of [
+			(0, node_path.join)("src", subpath, "index.ts"),
+			(0, node_path.join)(subpath, "index.ts"),
+			subpath
+		]) {
+			const file = resolveInPackage(pkg, candidate);
+			if (file !== void 0 && await exists(file)) return file;
+		}
+		return;
+	}
+	const byClient = await exportTargetOf(root, "client");
+	if (byClient !== void 0) return byClient;
+	const conventional = (0, node_path.join)(root, "src", "client", "index.ts");
+	return await exists(conventional) ? conventional : void 0;
+}
+//#endregion
+//#region src/bundle.ts
+/**
+* 客户端资源的**联邦式**产出：一个包一份产物，三方的与我们的**没有本质区别**。
+*
+* vite 8 底下就是 rolldown，转换规则、插件钩子、CSS 与资产的处理都在同一套配置里——所以这里复用
+* dev 那份配置（`cssInlinePlugins` / `clientAssetPlugin` / alias / define），只把它跑在 build 模式上：
+* **一次构建、产物按出口分开**（多 entry + 共享 chunk）、落盘缓存、按输入指纹失效。
+*
+* 差别只在"入口从哪儿来"：我们的包按 `exports` 找它的 client 半，三方按 node 的解析找它的入口。
+* 两者产出的地址同构（`@client-modules/<pkg>@<version>/<file>`），所以运行时按 URL 取即可。
+*/
+/** 裸包名 → `^名(/|$)`：既覆盖子路径引用，也不会把 `node:fs`、`./x` 误判成包。 */
+function barePackageRegExp(name) {
+	return new RegExp(`^${name.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}(?:/|$)`, "u");
+}
+/** 统一前缀：三方与我们的包共用同一个命名空间。 */
+const CLIENT_MODULES_PREFIX = "/@client-modules";
+/** 统一缓存目录（与 vite 的 `.vite` 并列，跨进程共用）。 */
+const CLIENT_MODULES_CACHE = (0, node_path.join)("node_modules", ".dsh-client-modules");
+/**
+* 客户端资源链的**解析约定**（dev 的 vite server 与联邦构建各持一份，规则相同）。
+*
+* - `@/…` = 仓库根的文件（源码里引用仓库内文件都用这个前缀，不写死绝对路径）；
+* - `node:*` = 求值安全的空替身文件。**整串匹配**：`find: /^node:/` 是前缀替换，会把 `node:fs/promises`
+*   拼成 `<替身路径>fs/promises`（构建期报 UNLOADABLE_DEPENDENCY）。
+*
+* 替身的**形态**两条链不同（dev 是 ESM、构建要 CJS，见 `app-boot/node-stub.*` 里各自的说明），
+* 所以由调用方给路径。
+*/
+function clientModulesAlias(options) {
+	return [{
+		find: /^@\//u,
+		replacement: `${options.repoRoot}/`
+	}, {
+		find: _morlay_dsh_cordis_assets_assets.NODE_BUILTIN,
+		replacement: options.nodeStub
+	}];
+}
+/**
+* 地址里的 `?v=`（与 vite 同一个写法）：构建器**规则指纹**（`BUNDLER_RULES` 的哈希，形如 vite 的 `?v=`）。
+*
+* 它只随"这条链的规则"变化——一次会话内所有地址一致（同一个包只有一个 URL，多一个 URL 就多一份模块
+* 实例）。内容变了**不换 URL**，靠 `cache-control: no-cache` + `ETag` 协商（vite dev 对它自己的模块
+* 也是这套）。
+*/
+const BUNDLER_REV = (0, node_crypto.createHash)("sha1").update(`client-modules:rules:22`).digest("hex").slice(0, 8);
+/** 包 → 它在浏览器里的地址（联邦式）。 */
+function depsUrlOf(specifier, version, file = "index.js") {
+	const name = packageNameOf(specifier) || specifier;
+	return `${CLIENT_MODULES_PREFIX}/${encodePackageName(name)}@${version}/${file}`;
+}
+/** 缓存目录名（也是产物目录的键）：`<pkg>@<version>`，scope 的 `/` 转义成 `+`。 */
+function cacheKeyOf(name, version) {
+	return `${encodePackageName(name)}@${version}`;
+}
+/**
+* 目录/文件的内容指纹（名字 + 内容）。
+*
+* 先按**元信息**（名字 + 大小 + mtime）攒一个快速戳：戳没变就直接复用上次的指纹——否则每次请求都要把
+* 每个包的源码**读一遍**（几百个包 × 每个包几十个文件），首屏全耗在算指纹上。
+*/
+const fingerprints = /* @__PURE__ */ new Map();
+async function fingerprint(paths) {
+	const key = paths.join("|");
+	const stampHash = (0, node_crypto.createHash)("sha1");
+	const collect = async (path) => {
+		const info = await (0, node_fs_promises.stat)(path).catch(() => void 0);
+		if (info === void 0) return;
+		if (!info.isDirectory()) {
+			stampHash.update(`${(0, node_path.relative)(paths[0] ?? path, path).split(node_path.sep).join("/")}:${String(info.size)}:${String(info.mtimeMs)}`);
+			return;
+		}
+		const entries = await (0, node_fs_promises.readdir)(path, { withFileTypes: true }).catch(() => []);
+		for (const entry of [...entries].sort((left, right) => left.name.localeCompare(right.name))) await collect((0, node_path.join)(path, entry.name));
+	};
+	for (const path of paths) await collect(path);
+	const stamp = stampHash.digest("hex");
+	const cached = fingerprints.get(key);
+	if (cached?.stamp === stamp) return cached.rev;
+	const hash = (0, node_crypto.createHash)("sha1");
+	const walk = async (path) => {
+		const info = await (0, node_fs_promises.stat)(path).catch(() => void 0);
+		if (info === void 0) return;
+		if (!info.isDirectory()) {
+			hash.update(`${(0, node_path.relative)(paths[0] ?? path, path).split(node_path.sep).join("/")}:${String(info.size)}`);
+			hash.update(await (0, node_fs_promises.readFile)(path));
+			return;
+		}
+		const entries = await (0, node_fs_promises.readdir)(path, { withFileTypes: true }).catch(() => []);
+		for (const entry of [...entries].sort((left, right) => left.name.localeCompare(right.name))) await walk((0, node_path.join)(path, entry.name));
+	};
+	for (const path of paths) await walk(path);
+	const rev = hash.digest("hex").slice(0, 16);
+	fingerprints.set(key, {
+		stamp,
+		rev
+	});
+	return rev;
+}
+/**
+* 说明符 → 联邦地址（同步：`paths` 回调与 vite 的 `resolveId` 都要求同步可答）。
+*
+* 两端共用这一份：产物里外置的 `import` / `require`，与 dev 侧源码里的裸说明符——同一条链、同一种地址。
+*
+* `?v=` 是**构建世代**（{@link BUNDLER_REV}，与 vite 同名的 query 参数）：所有地址一次会话内稳定一致——同一个包**只有一个 URL**
+* （多一个 URL 就多一份模块实例）。内容变了**不换 URL**，靠 `cache-control: no-cache` + `ETag` 协商
+* ——vite dev 对它自己的模块也是这套。
+*/
+/**
+* **本包视角**的可外置包与版本：从引它的那个包的清单出发，用 `findPackageJSON` 按 node 的解析找。
+*
+* 两点都要紧：
+* - **按包解析**：不同包的依赖树不同（peer 分叉时同一个名字可以是不同版本），全局一张表必然猜错；
+* - **不碰布局**：`node:module` 的解析对 hoisted / `.pnpm` / 实体目录一视同仁——我们不该知道 pnpm 把包放哪儿。
+*
+* 候选是"这个包声明的依赖"（`dependencies` + `peerDependencies`）：声明过、又能解析到，才谈得上外置；
+* 解析不到的（可选依赖、纯 host 包）不列，产物里内联或由上层如实报错。
+*
+* @param manifestPath - 本包清单的绝对路径。
+* @returns 包名 → 版本（供 {@link urlOf} 写地址）。
+*/
+/** 本包视角版本表的缓存：**键是"包 + 版本"**（与产物缓存目录 `cacheKeyOf` 同一形态）——同一个包的同一个版本只解析一次。 */
+const resolvableCache = /* @__PURE__ */ new Map();
+/**
+* 带缓存的前者：按"包 + 版本"复用解析结果。
+*
+* @param key - `cacheKeyOf(name, version)`（与产物目录名同一串）。
+* @param manifestPath - 本包清单的绝对路径。
+* @returns 包名 → 版本。
+*/
+async function resolvableVersionsFor(key, manifestPath) {
+	const cached = resolvableCache.get(key);
+	if (cached !== void 0) return await cached;
+	const computed = resolvableVersionsOf(manifestPath);
+	resolvableCache.set(key, computed);
+	return await computed;
+}
+async function resolvableVersionsOf(manifestPath) {
+	const versions = /* @__PURE__ */ new Map();
+	if (manifestPath === void 0) return versions;
+	const here = (0, node_url.pathToFileURL)(manifestPath).href;
+	const manifest = JSON.parse(await (0, node_fs_promises.readFile)(manifestPath, "utf8").catch(() => "{}"));
+	const names = /* @__PURE__ */ new Set([...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.peerDependencies ?? {}).filter((name) => manifest.peerDependenciesMeta?.[name]?.optional !== true)]);
+	for (const name of names) {
+		let found;
+		try {
+			found = (0, node_module.findPackageJSON)(name, here);
+		} catch {
+			continue;
+		}
+		if (found === void 0) continue;
+		const parsed = JSON.parse(await (0, node_fs_promises.readFile)(found, "utf8").catch(() => "{}"));
+		if (typeof parsed.version === "string") versions.set(name, parsed.version);
+	}
+	return versions;
+}
+function urlOf(specifier, tables) {
+	const bare = packageNameOf(specifier) || specifier;
+	const version = tables.versions?.get(bare) ?? "0.0.0";
+	const subpath = specifier === bare ? "" : specifier.slice(bare.length + 1);
+	return depsUrlOf(specifier, version, `${subpath !== "" ? /\.[a-z0-9]+$/iu.test(subpath) ? subpath : entryFileNameOf(subpath) : entryFileNameOf(tables.clientRows?.has(bare) === true ? "client" : "index")}?v=${BUNDLER_REV}`);
+}
+/**
+* 依赖里的 `process.env`。
+*
+* 顶层的 `define` 只作用于我们的源码面：`node_modules` 里的包直接进产物，而 `immer@10` 的
+* `dist/immer.mjs` 在模块顶层就读 `process.env.NODE_ENV`——浏览器里没有 `process`，一个
+* `process is not defined` 会把整份产物带下去。
+*
+* **只替换 `process.env` 系列**：裸的 `process` 不能碰——它可能只是个普通标识符（`zod` 里就有一个叫
+* `process` 的函数，替换掉直接把源码变成语法错误）。
+*/
+function browserProcessPlugin() {
+	const replace = (code) => code.replaceAll(/\bprocess\.env\.NODE_ENV\b/gu, JSON.stringify("development")).replaceAll(/\bprocess\.env\b/gu, "({ env: {} })");
+	return {
+		name: "dsh-browser-process",
+		enforce: "pre",
+		transform(code) {
+			if (!code.includes("process.env")) return null;
+			return {
+				code: replace(code),
+				map: null
+			};
+		}
+	};
+}
+/**
+* CJS 入口的**具名导出包装**（`react` 这类）。
+*
+* `react` 的入口是 `module.exports = require('./cjs/react.development.js')`，rolldown 静态分析不出具名
+* 导出，产物只剩 `export default …`——而浏览器侧要 `import { Fragment } from "react"`，于是**整个 import
+* 阶段就失败**（入口一行都执行不了）。ESM 的导出必须**静态可枚举**（不能 `export * from` 一个运行期对象），
+* 所以这里求值入口拿到它的键，生成一份把它们写成 `export const` 的包装文件，拿包装文件当入口。
+*
+* @returns 包装文件路径；入口不是 CJS、或求值拿不到键时 undefined（保持原样）。
+*/
+async function cjsShimOf(options) {
+	const source = await (0, node_fs_promises.readFile)(options.entry, "utf8").catch(() => "");
+	if (!(/\.(?:cjs|js)$/u.test(options.entry) && /(?:^|\n)\s*(?:module\.exports\s*=|exports\.[A-Za-z_$][A-Za-z0-9_$]*\s*=)/u.test(source))) return void 0;
+	let keys;
+	try {
+		const loaded = (0, node_module.createRequire)(options.entry)(options.entry);
+		keys = Object.keys(loaded ?? {});
+	} catch {
+		return;
+	}
+	const named = keys.filter((key) => key !== "default" && /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(key));
+	if (named.length === 0) return void 0;
+	const file = (0, node_path.join)(options.outDir, `${options.exportName.replaceAll("/", "+")}.cjs-shim.mjs`);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(file), { recursive: true });
+	await (0, node_fs_promises.writeFile)(file, [
+		`import mod from ${JSON.stringify(options.entry)};`,
+		"const __cjs = mod ?? {};",
+		"export default __cjs;",
+		...named.map((key) => `export const ${key} = __cjs[${JSON.stringify(key)}];`),
+		""
+	].join("\n"), "utf8");
+	options.log?.(`[bundle-cjs] ${options.name}/${options.exportName}: 补 ${String(named.length)} 个具名导出\n`);
+	return file;
+}
+/**
+* CSS 入口的包装：**样式文件不能直接当入口**——vite 的库模式固定 `cssCodeSplit: false`，遇到
+* `rolldownOptions.input` 里有 `.css` 直接报错。包一层 side-effect import，让样式插件按它一贯的方式
+* 把它编成"注入 `<style>`"的模块。
+*
+* @returns 包装文件路径；入口不是 CSS 时 undefined。
+*/
+async function cssShimOf(options) {
+	if (!options.entry.endsWith(".css")) return void 0;
+	const file = (0, node_path.join)(options.outDir, `${options.exportName.replaceAll("/", "+")}.css-shim.mjs`);
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(file), { recursive: true });
+	await (0, node_fs_promises.writeFile)(file, `import ${JSON.stringify(options.entry)};\n`, "utf8");
+	return file;
+}
+/**
+* 确保该包的产物在（指纹没变、且**这次要的出口**都在就直接用）。
+*
+* 缓存是**按包聚合**的（一个包一个目录、出口各有自己的产物文件），而构建**按请求触发单出口**——
+* 所以命中判据必须带上"这次要的出口在不在"：只比指纹会把"先请求 `zustand/middleware`、再请求
+* `zustand/vanilla`"判成命中，第二个出口就 404 了。指纹变了才丢掉旧目录重来，否则增量合并。
+*
+* **同一个包的构建排队串行**：产物目录是包级共享的（还会被重建时清理），并发跑会互相删掉对方的产物——
+* 首屏那几十个请求是同时在飞的，`zustand/vanilla` 与 `zustand/shallow` 撞在一起就丢产物、页面 404。
+*
+* @param options - 见 {@link BundleOptions}。
+* @returns 产物映射；`input` 为空时 undefined。
+*/
+/**
+* 摆正 **cwd** 之后再进构建。
+*
+* rolldown 的 oxc 转译是**按 cwd 往上找 tsconfig** 拿 `experimentalDecorators` 的，而这条链跑在宿主
+* 进程里——cwd 是宿主的（dev 是工作区、打包是 profile）。不摆正，上游用 cordis 装饰器的包就会在产物里
+* 留着 `@Remote(...)`，浏览器报 `SyntaxError`、入口整条不执行（这是"不同工作目录行为不一致"里最隐蔽的一处）。
+* 跑完恢复，别把进程的 cwd 改坏了。
+*/
+async function bundlePackage(options) {
+	const previousCwd = process.cwd();
+	if (previousCwd !== options.repoRoot) process.chdir(options.repoRoot);
+	try {
+		return await bundlePackageInRoot(options);
+	} finally {
+		if (process.cwd() !== previousCwd) process.chdir(previousCwd);
+	}
+}
+async function bundlePackageInRoot(options) {
+	const key = cacheKeyOf(options.name, options.version);
+	const task = (building.get(key) ?? Promise.resolve()).catch(() => void 0).then(() => withBuildSlot(() => bundlePackageOnce(options, key)));
+	building.set(key, task);
+	try {
+		return await withTimeout(task, BUILD_TIMEOUT_MS, `${options.name}@${options.version} 构建超时`);
+	} finally {
+		if (building.get(key) === task) building.delete(key);
+	}
+}
+/**
+* 同时在跑的构建数上限。
+*
+* 每次联邦构建都是一次完整的 vite build（自建实例、加载插件、跑 rolldown），首屏那两百多个包**一起上**
+* 只会互相拖慢、把内存吃满——排队反而更快。要调就设 `DSH_BUNDLE_CONCURRENCY`。
+*/
+const MAX_CONCURRENT_BUILDS = Math.max(1, Number(process.env["DSH_BUNDLE_CONCURRENCY"] ?? 8));
+let runningBuilds = 0;
+const buildQueue = [];
+/** 排队/构建的等待上限：等它做完，但不无限等（卡死的构建要如实报出来，而不是让请求挂在 pending）。 */
+const BUILD_TIMEOUT_MS = Math.max(1e3, Number(process.env["DSH_BUNDLE_TIMEOUT_MS"] ?? 18e4));
+/** 给一个 promise 加超时；超时如实抛，不返回兜底值。 */
+async function withTimeout(work, ms, subject) {
+	let timer;
+	try {
+		return await Promise.race([work, new Promise((_resolve, reject) => {
+			timer = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`${subject}（超过 ${String(ms)}ms）`));
+			}, ms);
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+async function withBuildSlot(work) {
+	if (runningBuilds >= MAX_CONCURRENT_BUILDS) await new Promise((resolve) => buildQueue.push(resolve));
+	runningBuilds += 1;
+	try {
+		return await work();
+	} finally {
+		runningBuilds -= 1;
+		buildQueue.shift()?.();
+	}
+}
+/** 排队中/在跑的包级构建（键是缓存目录名）。 */
+const building = /* @__PURE__ */ new Map();
+async function bundlePackageOnce(options, key) {
+	const wanted = Object.keys(options.input);
+	options.log?.(`[bundle-in] ${options.name}: input=${wanted.join(",")} cache=${options.cacheRoot}\n`);
+	if (wanted.length === 0) return void 0;
+	const outDir = (0, node_path.join)(options.cacheRoot, key);
+	const manifestPath = (0, node_path.join)(outDir, ".files.json");
+	options.log?.(`[bundle-rev] ${options.name}: hash-start watch=${options.watch.join(",")}\n`);
+	const rev = `${BUNDLER_REV}:${await fingerprint(options.watch)}`;
+	options.log?.(`[bundle-rev] ${options.name}: hash=${rev}\n`);
+	const cached = JSON.parse(await (0, node_fs_promises.readFile)(manifestPath, "utf8").catch(() => "{}"));
+	const fresh = cached.rev === rev;
+	const files = fresh ? { ...cached.files } : {};
+	if (fresh && wanted.every((name) => name in files)) return {
+		rev,
+		files: new Map(Object.entries(files))
+	};
+	const resolvable = await resolvableVersionsFor(key, options.manifestOf);
+	const plugins = [
+		{
+			name: "dsh-alias",
+			resolveId: (source) => {
+				for (const { find, replacement } of options.alias) if (typeof find === "string" ? source.startsWith(find) : find.test(source)) return source.replace(find, replacement);
+			}
+		},
+		browserProcessPlugin(),
+		(0, _morlay_dsh_cordis_assets_styles.cssInlinePlugins)({
+			name: key,
+			assets: "threshold",
+			assetUrl: (file) => `${CLIENT_MODULES_PREFIX}/${key}/${file}`
+		}),
+		(0, _morlay_dsh_cordis_assets_assets.clientAssetPlugin)({ assets: "threshold" }),
+		(0, vite.esmExternalRequirePlugin)({ external: [...resolvable.keys()].filter((name) => !_morlay_dsh_cordis_assets_assets.NODE_BUILTIN.test(name)).map((name) => barePackageRegExp(name)) })
+	];
+	const startedAt = Date.now();
+	options.log?.(`[bundle-build] ${options.name}: rolldown start\n`);
+	const input = {};
+	for (const [exportName, entry] of Object.entries(options.input)) input[exportName] = await cjsShimOf({
+		name: options.name,
+		exportName,
+		entry,
+		...options.log === void 0 ? {} : { log: options.log },
+		outDir
+	}) ?? await cssShimOf({
+		exportName,
+		entry,
+		outDir
+	}) ?? entry;
+	const bundle = await (0, rolldown.rolldown)({
+		input,
+		plugins,
+		...options.tsconfig === void 0 ? {} : { resolve: { tsconfigFilename: options.tsconfig } },
+		transform: {
+			target: [
+				"chrome111",
+				"edge111",
+				"firefox114",
+				"safari16.4"
+			],
+			decorator: { legacy: true },
+			define: {
+				"process.env": "{ env: {} }",
+				process: "{ env: {} }"
+			}
+		}
+	});
+	const { output: items } = await bundle.generate({
+		format: "es",
+		entryFileNames: "[name].js",
+		chunkFileNames: "chunks/[name]-[hash].js",
+		assetFileNames: "assets/[name]-[hash][extname]",
+		paths: (id) => urlOf(id, {
+			versions: resolvable,
+			...options.clientRows === void 0 ? {} : { clientRows: options.clientRows }
+		})
+	});
+	await bundle.close();
+	options.log?.(`[bundle-build] ${options.name}: rolldown done ms=${String(Date.now() - startedAt)}\n`);
+	if (!items.some((item) => item.type === "chunk")) {
+		options.log?.(`[bundle] ${options.name}: 输出为空（input=${wanted.join(",")} outputs=${String(items.length)}）\n`);
+		return;
+	}
+	await (0, node_fs_promises.mkdir)(outDir, { recursive: true });
+	for (const item of items) {
+		if (item.type !== "chunk") continue;
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)((0, node_path.join)(outDir, item.fileName)), { recursive: true });
+		await (0, node_fs_promises.writeFile)((0, node_path.join)(outDir, item.fileName), item.code, "utf8");
+		files[item.isEntry ? item.name : item.fileName] = `${key}/${item.fileName}`;
+	}
+	for (const asset of items) {
+		if (asset.type !== "asset") continue;
+		await (0, node_fs_promises.mkdir)((0, node_path.dirname)((0, node_path.join)(outDir, asset.fileName)), { recursive: true });
+		await (0, node_fs_promises.writeFile)((0, node_path.join)(outDir, asset.fileName), asset.source ?? "");
+		files[asset.fileName] = `${key}/${asset.fileName}`;
+	}
+	await (0, node_fs_promises.writeFile)(manifestPath, `${JSON.stringify({
+		rev,
+		files
+	}, null, 2)}\n`, "utf8");
+	return {
+		rev,
+		files: new Map(Object.entries(files))
+	};
+}
+/** 三方的入口：按 node 的解析找（pnpm 的软链由它解开）。 */
+async function dependencyEntry(from, name) {
+	const require$1 = (0, node_module.createRequire)(from);
+	let entry;
+	try {
+		entry = require$1.resolve(name);
+	} catch {
+		return;
+	}
+	const manifest = await packageJsonNear(entry);
+	const parsed = JSON.parse(await (0, node_fs_promises.readFile)(manifest, "utf8").catch(() => "{}"));
+	return {
+		entry,
+		version: parsed.version ?? "0.0.0"
+	};
+}
+/** 从入口文件向上找它所属包的 `package.json`。 */
+async function packageJsonNear(file) {
+	let directory = (0, node_path.dirname)(file);
+	for (;;) {
+		const candidate = (0, node_path.join)(directory, "package.json");
+		if (await (0, node_fs_promises.readFile)(candidate, "utf8").then(() => true, () => false)) return candidate;
+		const parent = (0, node_path.dirname)(directory);
+		if (parent === directory) return candidate;
+		directory = parent;
+	}
+}
+//#endregion
+//#region src/dirs.ts
+/** 本包自己的根（页面的骨架、`node-stub` 与依赖解析的兜底基准都从它推）。 */
+function packageRoot() {
+	return (0, node_path.dirname)((0, node_url.fileURLToPath)(new URL("../package.json", require("url").pathToFileURL(__filename).href)));
+}
+/** 页面与入口所在的目录（vite 的 root）：本包的 `app-boot`。 */
+function appBootDir() {
+	return (0, node_path.join)(packageRoot(), "app-boot");
+}
+/** 本包的清单（依赖解析的一个基准：这条链的运行期依赖声明在它里面）。 */
+function packageManifestPath() {
+	return (0, node_path.join)(packageRoot(), "package.json");
+}
+/**
+* 装配根（profileDir）：这份部署装配出来的那一格。
+*
+* dev 是工作区里的 app 目录（`dshdev` 给的 `DSH_DESKTOP_DEV_PROFILE_DIR`），bundle 是宿主进程的 cwd
+* （壳把宿主的 cwd 设成 `<dataDir>/profiles/<name>`）。
+*
+* @returns 第一个带 `package.json` 的候选取值；都没有时退回 cwd。
+*/
+async function profileDir() {
+	const candidates = [process.env["DSH_DESKTOP_DEV_PROFILE_DIR"], process.cwd()].filter((value) => value !== void 0 && value !== "");
+	for (const candidate of candidates) if (await (0, node_fs_promises.readFile)((0, node_path.join)(candidate, "package.json"), "utf8").then(() => true, () => false)) return candidate;
+	return process.cwd();
+}
+/** 装配根的清单：`<profileDir>/package.json`（pnpm 从这里解析到装配行与工作区的包）。 */
+async function profileManifestPath() {
+	return (0, node_path.join)(await profileDir(), "package.json");
+}
+/**
+* 解析根：依赖解析、watch、缓存的基准。
+*
+* dev 再向上找**工作区根**（`node_modules` 与 lockfile 在那儿）；bundle 的装配根本身就带自己的
+* `node_modules`，就是它。
+*/
+async function resolutionRoot() {
+	resolutionRootPromise ??= (async () => {
+		const profile = await profileDir();
+		return isDevForm() ? await workspaceRootOf(profile) ?? profile : profile;
+	})();
+	return await resolutionRootPromise;
+}
+let resolutionRootPromise;
+/**
+* 数据根（`$DSH_HOME`）：会话、设置、附件、日志。
+*
+* dev 缺省是 `<装配根>/.dsh-store`（`dshdev` 会显式给值），bundle 由壳按 app 的 `dsh.desktop.dataDir`
+* 解析后经环境传进来。
+*/
+async function dataDir() {
+	return process.env["DSH_HOME"] ?? (0, node_path.join)(await profileDir(), ".dsh-store");
+}
+/** 解析根的清单：`<解析根>/package.json`（依赖解析的另一个基准）。 */
+async function resolutionManifestPath() {
+	return (0, node_path.join)(await resolutionRoot(), "package.json");
+}
+/** 这条链自己的缓存目录（联邦产物与聚合结果，与 vite 的 `.vite` 并列）。 */
+async function cacheDir() {
+	return (0, node_path.join)(await resolutionRoot(), CLIENT_MODULES_CACHE);
+}
+const RESOLVED_ROWS = `\0dsh-client-rows`;
+/**
+* 依赖预打包的入口名。vite 的 `optimizeDeps.entries` 期望"文件路径"，而我们手上是包名与源码路径的
+* 映射，所以用一个小技巧：把入口写成**虚拟模块**再让 vite 把它当 discovery 的种子——见 `configResolved`
+* 里的 `optimizeDeps.include`。
+*/
+/** 从某个文件向上找包根（有 `package.json` 的那一层）。 */
+async function packageRootOfFile(file) {
+	let directory = (0, node_path.dirname)(file);
+	for (;;) {
+		if (await (0, node_fs_promises.readFile)((0, node_path.join)(directory, "package.json"), "utf8").then(() => true, () => false)) return directory;
+		const parent = (0, node_path.dirname)(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
+}
+/**
+* 「有 client 先用 client」：给定一条**从 client 图里发起**的相对引用，返回它的 client 变体（没有则 undefined）。
+*
+* 上游的包是同构的：`src/foo.ts` 与 `src/client/foo.ts` 成对，`src/client/index.ts` 会值导入 `../foo.ts`
+* 这类共享文件。若该共享文件在 client 侧有对应实现，就用它——这与 node 的 `browser` 字段、打包器的
+* `browser` 条件是同一件事，只是上游的 `exports` 没有为每个子路径声明 browser 条件。
+*
+* @param source - 引用说明符（相对路径）。
+* @param importer - 发起引用的文件（必在某个包的 `src/client/` 下）。
+* @returns client 变体的绝对路径，或 undefined（没有变体、或引用跨出了本包）。
+*/
+async function clientVariantOf(source, importer) {
+	const marker = `${node_path.sep}src${node_path.sep}client${node_path.sep}`;
+	const at = importer.indexOf(marker);
+	if (at < 0) return void 0;
+	const packageSrc = importer.slice(0, at + `${node_path.sep}src`.length);
+	const target = (0, node_path.resolve)((0, node_path.dirname)(importer), source);
+	if (target.includes(marker)) return void 0;
+	const relativeFromSrc = (0, node_path.relative)(packageSrc, target);
+	if (relativeFromSrc.startsWith("..")) return void 0;
+	const variant = (0, node_path.join)(packageSrc, "client", relativeFromSrc);
+	return await (0, node_fs_promises.readFile)(variant, "utf8").then(() => true, () => false) ? variant : void 0;
+}
+function dshClientRowsPlugin(options) {
+	let excludedCache;
+	const excludedOf = async () => {
+		if (excludedCache === void 0) excludedCache = await devExcluded(await profileDir());
+		return excludedCache;
+	};
+	(0, node_module.createRequire)((0, node_path.join)(options.repoRoot, "package.json"));
+	return {
+		name: "dsh-client-rows",
+		enforce: "pre",
+		config() {
+			return { resolve: { conditions: [
+				"browser",
+				"import",
+				"module",
+				"default"
+			] } };
+		},
+		async resolveId(source, importer) {
+			if (source === "dsh-client-rows") return RESOLVED_ROWS;
+			if (source.startsWith(`/@client-modules/`)) return {
+				id: source,
+				external: "absolute"
+			};
+			if (source.startsWith("@/")) return null;
+			if (source.startsWith("/") && options.resolvePluginUrl !== void 0) {
+				const file = await options.resolvePluginUrl(source.split("?")[0] ?? source);
+				if (file !== void 0) return file;
+			}
+			if (source.startsWith("\0")) return null;
+			if (importer !== void 0 && importer.includes(`${node_path.sep}src${node_path.sep}client${node_path.sep}`)) {
+				const variant = await clientVariantOf(source, importer);
+				if (variant !== void 0) return variant;
+			}
+			if (importer === void 0 || source.startsWith(".") || source.startsWith("/")) return null;
+			const fromFile = importer === void 0 || importer.startsWith("\0") ? void 0 : importer.startsWith("/") ? (0, node_path.join)(options.repoRoot, importer) : importer;
+			if (fromFile !== void 0) {
+				const bare = packageNameOf(source);
+				if (bare !== "") {
+					const pkg = await packageRootOf(fromFile, bare);
+					if (pkg !== void 0 && !pkg.root.includes("node_modules") && !isAggregated(bare, await excludedOf())) {
+						const subpath = source === bare ? void 0 : source.slice(bare.length + 1);
+						const half = await clientHalfOf(pkg.root, subpath);
+						if (half !== void 0) return half;
+					}
+				}
+			}
+			if (options.depsUrl !== void 0) {
+				const url = await options.depsUrl(source, importer);
+				if (url !== void 0) return {
+					id: url,
+					external: true
+				};
+			}
+			const rows = await options.rows();
+			const shared = await options.shared?.() ?? /* @__PURE__ */ new Map();
+			const known = rows.get(source) ?? shared.get(source);
+			if (known !== void 0 && known !== source) return known;
+			const slash = source.startsWith("@") ? source.indexOf("/", source.indexOf("/") + 1) : source.indexOf("/");
+			if (slash > 0) {
+				const pkgName = source.slice(0, slash);
+				const subpath = source.slice(slash + 1);
+				const rowPath = rows.get(pkgName) ?? shared.get(pkgName);
+				if (rowPath !== void 0) {
+					const rowRoot = await packageRootOfFile(rowPath);
+					const target = rowRoot === void 0 ? void 0 : await exportTargetOf(rowRoot, subpath);
+					if (target !== void 0) return target;
+				}
+			}
+			return null;
+		},
+		async load(id) {
+			if (id !== RESOLVED_ROWS) return null;
+			const rows = await options.rows();
+			const shared = await options.shared?.() ?? /* @__PURE__ */ new Map();
+			const imports = [];
+			const entries = [];
+			let index = 0;
+			for (const [pkg, file] of [...shared, ...rows]) {
+				const alias = `m${String(index)}`;
+				const specifier = file === pkg ? await options.depsUrl?.(pkg) ?? file : file;
+				imports.push(`import * as ${alias} from ${JSON.stringify(specifier)};`);
+				entries.push(`  { id: ${JSON.stringify(pkg)}, module: ${alias} },`);
+				index += 1;
+			}
+			return [
+				...imports,
+				"",
+				"export default [",
+				...entries,
+				"];",
+				""
+			].join("\n");
+		},
+		configureServer(devServer) {
+			options.onServer?.(devServer);
+		}
+	};
+}
+//#endregion
+//#region src/serve-vite.ts
+function rowsOf(source) {
+	return source.rows();
+}
+/** 起一个 vite dev server（middleware 模式），并把 `/plugins` 前缀下的请求交给它。 */
+/** vite 的 HMR WebSocket 路径：专有路径，避免与上游自身的 upgrade 路由抢。 */
+const HMR_PATH = "/__dsh_hmr";
+async function startViteDev(ctx, options) {
+	const trace = traceOf(ctx, "vite");
+	const { repoRoot, base } = options;
+	/**
+	* 页面与入口所在的真实目录（vite 的 root）。
+	*
+	* 按**本包自己的位置**推，不从 `repoRoot` 拼：打包形态下 `repoRoot` 是 profile 目录
+	* （`$DSH_HOME/profiles/desktop`），从它拼出的 `packages/client/…/app-boot` 并不存在——vite 的 root
+	* 一空，`/index.html` 404、入口也转译不了，页面就只剩一具空壳。这条事实与 `index.ts` 的 `appRoot`
+	* 同源（那里也从包根推）。
+	*/
+	const appRoot = (0, node_url.fileURLToPath)(new URL("../app-boot", require("url").pathToFileURL(__filename).href));
+	/** 页面所在的端口（HMR 的 WebSocket 必须与页面**同源同端口**，否则客户端连不上）。 */
+	const pagePort = (() => {
+		const address = options.httpServer?.address();
+		if (address !== null && address !== void 0 && typeof address === "object") return address.port;
+		const fromEnv = process.env["PORT"];
+		return fromEnv === void 0 ? void 0 : Number(fromEnv);
+	})();
+	let current;
+	const server = await (0, vite.createServer)({
+		root: appRoot,
+		base: "/",
+		define: {
+			"process.env.NODE_ENV": JSON.stringify(process.env["NODE_ENV"] ?? "development"),
+			"process.env": "{ env: {} }",
+			process: "{ env: {} }"
+		},
+		publicDir: false,
+		appType: "mpa",
+		configFile: false,
+		resolve: { alias: clientModulesAlias({
+			repoRoot,
+			nodeStub: (0, node_path.join)(appRoot, "node-stub.ts")
+		}) },
+		server: {
+			middlewareMode: true,
+			preTransformRequests: false,
+			...options.httpServer === void 0 ? {} : { hmr: {
+				server: options.httpServer,
+				path: HMR_PATH,
+				...pagePort === void 0 ? {} : { clientPort: pagePort }
+			} },
+			fs: {
+				strict: false,
+				allow: [repoRoot]
+			}
+		},
+		optimizeDeps: {
+			disabled: true,
+			noDiscovery: true,
+			include: []
+		},
+		plugins: [dshClientRowsPlugin({
+			repoRoot,
+			rows: () => rowsOf(options.rows),
+			resolvePluginUrl: options.resolvePluginUrl,
+			depsUrl: options.depsUrl,
+			onServer: (devServer) => {
+				current = devServer;
+			}
+		})]
+	});
+	current = server;
+	ctx.logger.info("client-modules: vite dev server 就绪（root=%s）", repoRoot);
+	/** 页面入口（root=app-boot，所以就是 `/index.html`）。 */
+	const pageEntry = "/index.html";
+	const serve = (req, res) => {
+		if ((req.url ?? "").split("?")[0] === "/" || (req.url ?? "").split("?")[0] === "/index.html") req.url = pageEntry;
+		if ((req.url ?? "").startsWith(`${base}/`)) return false;
+		try {
+			res.on("finish", () => {
+				if (res.statusCode < 400) return;
+				trace("%s %s → %s", req.method ?? "", req.url ?? "", res.statusCode);
+			});
+			(current ?? server).middlewares(req, res, () => {
+				trace("miss %s %s", req.method ?? "", req.url ?? "");
+				if (!res.headersSent) res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+				if (!res.writableEnded) res.end("client-modules: vite 没有这条路由\n");
+			});
+		} catch (error) {
+			ctx.logger.error(error);
+			if (!res.headersSent) res.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+			if (!res.writableEnded) res.end(`dev-client: vite 处理失败：${String(error)}\n`);
+		}
+		return true;
+	};
+	return {
+		serve,
+		transformHtml: async (html) => await server.transformIndexHtml(`${base}/`, html),
+		hmr: options.httpServer !== void 0
+	};
+}
+//#endregion
+//#region src/index.ts
+const name = "client-modules";
+const inject = ["loader", "webServer"];
+/**
+* 行清单：**cordis Loader 的 entries** 里声明了 `dsh.client` 的那些包——**上游 `client-modules` 的同一份
+* 来源**（"装配的真相"，任何项目/上游都通用），`disabled` 的行在这里被跳过（profile 的开关就此生效）。
+*
+* 每行给出**包名**与该包 **client 半的源文件**。包的位置用 **entry 自己的 `parent.tree.ctx.baseUrl`**
+* 解析（上游 `resolveSource`/`resolveMeta` 用的就是它）——从进程的 cwd 解析不到这些包：pnpm 的严格布局
+* 下它们只在各自消费者的 node_modules 里，profile 的运行时目录又另有一套。
+*
+* **判据是清单里的 `dsh.client` 声明**（与上游 `client-modules` 同源）：光有 `src/client/` 目录不算行——
+* 上游有若干包只是"宿主插件 + 一份 client 半"（`@deepseek-ai/dsh-session-title` 那种），它们由真正的行在
+* 自己的 client 半里 import，不该出现在装配清单里；混进来就会多装配一次（`apply` 里那些"同 namespace 的
+* locale 已注册"的报错就是这么来的），也会在入口打出一串 `skip (no apply/default)`。
+*/
+async function clientRowsOf(loader) {
+	const found = /* @__PURE__ */ new Map();
+	for (const entry of loader.entries()) {
+		if (entry.disabled === true || entry.fiber === void 0) continue;
+		const name = entry.options?.name;
+		if (typeof name !== "string" || name === "") continue;
+		if (name.includes(":")) continue;
+		if (found.has(name)) continue;
+		const baseUrl = entry.parent?.tree?.ctx?.baseUrl;
+		if (baseUrl === void 0) continue;
+		const resolved = await packageRootOf(baseUrl, name);
+		if (resolved === void 0) continue;
+		const manifest = await manifestOf(resolved.root);
+		const declared = manifest?.dsh?.client;
+		if (manifest === void 0 || declared === void 0) continue;
+		const clientPath = await clientHalfOf(resolved.root);
+		if (clientPath === void 0) continue;
+		found.set(name, {
+			id: name,
+			clientPath: `@/${(0, node_path.relative)(await resolutionRoot(), clientPath).split(node_path.sep).join("/")}`,
+			version: manifest.version
+		});
+	}
+	return [...found.values()];
+}
+/** 打包器指纹的输入集：**只与包有关、与出口无关**（缓存按包聚合，rev 跟着出口变就等于永不命中）。 */
+function watchOf(root, entry) {
+	if (root === void 0) return [entry];
+	return root.includes("node_modules") ? [(0, node_path.join)(root, "package.json")] : [(0, node_path.join)(root, "src")];
+}
+function apply(ctx) {
+	const trace = traceOf(ctx, "federation");
+	const webServer = ctx.get("webServer");
+	const appRoot = appBootDir();
+	const logFileOf = dataDir().then((dir) => (0, node_path.join)(dir, "logs", "dev-host.log"));
+	let resolvedLogFile;
+	logFileOf.then((file) => {
+		resolvedLogFile = file;
+	});
+	const appendLog = async (text) => {
+		try {
+			const logFile = await logFileOf;
+			await (0, node_fs_promises.mkdir)((0, node_path.dirname)(logFile), { recursive: true });
+			await (0, node_fs_promises.appendFile)(logFile, `${(/* @__PURE__ */ new Date()).toISOString()} ${text}\n`, "utf8");
+		} catch {}
+	};
+	ctx.effect(() => {
+		const onException = (error) => {
+			appendLog(`[uncaughtException] ${error.stack ?? error.message}`);
+		};
+		const onRejection = (reason) => {
+			appendLog(`[unhandledRejection] ${reason instanceof Error ? reason.stack ?? reason.message : String(reason)}`);
+		};
+		const onExit = (code) => {
+			const shown = resolvedLogFile ?? "(尚未就绪)";
+			ctx.logger.info(`dev 宿主退出：code=${String(code)}，异常日志见 ${shown}\n`);
+		};
+		process.on("uncaughtException", onException);
+		process.on("unhandledRejection", onRejection);
+		process.on("exit", onExit);
+		return () => {
+			process.off("uncaughtException", onException);
+			process.off("unhandledRejection", onRejection);
+			process.off("exit", onExit);
+		};
+	}, "client-modules: 宿主异常日志");
+	let rowsCache;
+	const loader = ctx.loader;
+	let excludedCache;
+	const excludedOf = async () => excludedCache ??= await devExcluded(await profileDir());
+	const sourceRowsOf = async () => {
+		rowsCache ??= loader === void 0 ? [] : await clientRowsOf(loader);
+		return rowsCache;
+	};
+	const rows = async () => await sourceRowsOf();
+	if (webServer === void 0) throw new Error("client-modules: webServer is a required service");
+	let fallbackBase;
+	const rootOf = async (name, from) => {
+		const bases = from === void 0 ? [] : [from];
+		fallbackBase ??= await profileManifestPath();
+		if (fallbackBase !== void 0) bases.push(fallbackBase);
+		bases.push(packageManifestPath());
+		for (const base of bases) {
+			const found = await packageRootOf(base, name);
+			if (found !== void 0) return found.root;
+		}
+	};
+	/** 兜底：vite 不认的路径直接 404（dev 形态下页面与资源全归它）。 */ const fallback = async (_req, res) => {
+		res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+		res.end("client-modules: 没有这条路由\n");
+	};
+	let viteHandoff;
+	let viteStarting;
+	/** 地址只印一次（vite 就绪那一刻，跟它自己的 ready 提示一个意思）。 */
+	let announced = false;
+	const ensureVite = async () => {
+		if (viteHandoff !== void 0) return;
+		viteStarting ??= (async () => {
+			viteHandoff = await startViteDev(ctx, {
+				repoRoot: await resolutionRoot(),
+				base: PLUGIN_ROUTE,
+				rows: { rows: async () => {
+					const patterns = await excludedOf();
+					const all = await rows();
+					return new Map(all.map((row) => [row.id, isAggregated(row.id, patterns) ? `${CLIENT_MODULES_PREFIX}/${encodePackageName(row.id)}@${row.version}/client` : row.clientPath]));
+				} },
+				resolvePluginUrl: (url) => resolvePluginUrl(url),
+				depsUrl: (specifier, importer) => depsUrlOfSpecifier(specifier, importer),
+				httpServer: webServer.server ?? webServer.desktopUpgradeServer
+			});
+		})();
+		await viteStarting;
+		if (!announced) {
+			announced = true;
+			const port = webServer.port;
+			if (port !== void 0) process.stdout.write(`\n  ➜  Local:   http://127.0.0.1:${String(port)}/\n\n`);
+		}
+	};
+	/** **行**的包名集合（loader 给的 `dsh.client` + client 半）：包级引用的出口按它分。 */
+	const clientRowIds = async () => new Set((await rows()).map((row) => row.id));
+	/** 解析根那份 tsconfig 的路径（不存在时返回 undefined，交给 rolldown 默认）。 */
+	const tsconfigOf = async () => {
+		const candidate = (0, node_path.join)(await resolutionRoot(), "tsconfig.json");
+		return await (0, node_fs_promises.readFile)(candidate, "utf8").then(() => true, () => false) ? candidate : void 0;
+	};
+	/**
+	* 对外 URL → **源文件**。`exports` 优先，**没有该键**时退回物理路径（上游多数包没有 `./client` 出口，
+	* 它们的 client 半就是 `src/client/index.ts`）——中间件的改写与插件的 `resolveId` 共用这一份。
+	*/
+	const resolvePluginUrl = async (url) => {
+		const address = parsePluginAddress(url);
+		if (address === void 0) return void 0;
+		const root = await rootOf(address.name);
+		if (root === void 0) return void 0;
+		const manifest = await manifestOf(root);
+		const subpath = address.exportName === "." ? void 0 : address.exportName.slice(2);
+		if (subpath !== void 0) {
+			const byExports = await exportTargetOf(root, subpath);
+			if (byExports !== void 0) return byExports;
+			const pkg = {
+				name: address.name,
+				version: manifest?.version ?? "",
+				root
+			};
+			return resolveInPackage(pkg, (0, node_path.join)("src", subpath, "index.ts")) ?? resolveInPackage(pkg, (0, node_path.join)(subpath, "index.ts")) ?? resolveInPackage(pkg, subpath);
+		}
+		return await exportTargetOf(root, void 0);
+	};
+	const serve = async (req, res) => {
+		if (req.method !== "GET" && req.method !== "HEAD") return fallback(req, res);
+		try {
+			await ensureVite();
+		} catch (error) {
+			ctx.logger.error(error);
+		}
+		if (viteHandoff?.serve(req, res) === true) return;
+		return fallback(req, res);
+	};
+	let cacheRootCache;
+	const cacheRootOf = async () => cacheRootCache ??= await cacheDir();
+	const federationAliasOf = async () => clientModulesAlias({
+		repoRoot: await resolutionRoot(),
+		nodeStub: (0, node_path.join)(appRoot, "node-stub.cjs")
+	});
+	/**
+	* dev 侧源码里的**裸说明符** → 联邦地址；`undefined` 表示"交给 vite 走源码"。
+	*
+	* 判据与产物侧一致：仓库内的**开发模块**（没被 `dsh.dev.exclude` 点名）逐文件走 vite（改它要 HMR）；
+	* 其余——三方与"非开发模块"——都由联邦链按包产出（同一条链、同一种地址）。放给 vite 的 `optimizeDeps`
+	* 会多出第二条链：浏览器里同时有 `.vite/deps/react.js` 与我们的 `@client-modules/react@…/index.js`，
+	* 两个 react 实例，hook 分发立刻报 `Invalid hook call`。
+	*/
+	const depsUrlOfSpecifier = async (specifier, importer) => {
+		if (specifier.startsWith("@/")) return void 0;
+		if (_morlay_dsh_cordis_assets_assets.NODE_BUILTIN.test(specifier)) return void 0;
+		const bare = packageNameOf(specifier) || specifier;
+		const root = await rootOf(bare);
+		if (root !== void 0 && !root.includes("node_modules") && !isAggregated(bare, await excludedOf())) return void 0;
+		const base = importer === void 0 || !(0, node_path.isAbsolute)(importer) ? await resolutionManifestPath() : (0, node_url.pathToFileURL)(importer).href;
+		const found = (0, node_module.findPackageJSON)(bare, base);
+		const version = found === void 0 ? void 0 : JSON.parse(await (0, node_fs_promises.readFile)(found, "utf8").catch(() => "{}")).version;
+		return urlOf(specifier, {
+			...version === void 0 ? {} : { versions: /* @__PURE__ */ new Map([[bare, version]]) },
+			clientRows: await clientRowIds()
+		});
+	};
+	/**
+	* `@client-modules/<pkg>@<version>/<file>`：**联邦式**的统一寻址。
+	*
+	* 三方（react）与我们的包在这件事上没有区别——都是"带版本、可独立寻址的一份产物"。落在哪个缓存里
+	* 由"包是不是我们这个工作区的"决定：是 → 按包聚合（整包一次 vite build、产物按出口分开）；
+	* 不是 → 三方的预打包。两条链用的是同一份配置。
+	*/
+	const serveFederation = async (url, req, res) => {
+		const cacheRoot = await cacheRootOf();
+		const federationAlias = await federationAliasOf();
+		const rest = url.slice(`/@client-modules/`.length).split("?")[0] ?? "";
+		const slash = rest.indexOf("/");
+		trace("rest %s slash %s", rest, slash);
+		if (slash <= 0) return false;
+		const pkgVersion = rest.slice(0, slash);
+		const file = rest.slice(slash + 1);
+		const at = pkgVersion.lastIndexOf("@");
+		if (at <= 0) return false;
+		const name = decodePackageName(pkgVersion.slice(0, at));
+		const urlVersion = pkgVersion.slice(at + 1);
+		const root = await rootOf(name);
+		const version = (root === void 0 ? void 0 : (await manifestOf(root))?.version) ?? urlVersion;
+		const key = `${name.replaceAll("/", "+")}@${version}`;
+		if (file.startsWith("assets/") || file.startsWith("chunks/")) {
+			const target = JSON.parse(await (0, node_fs_promises.readFile)((0, node_path.join)(cacheRoot, key, ".files.json"), "utf8").catch(() => "{}")).files?.[file];
+			if (target === void 0) return false;
+			const bytes = await (0, node_fs_promises.readFile)((0, node_path.join)(cacheRoot, target)).catch(() => void 0);
+			if (bytes === void 0) return false;
+			const extension = file.slice(file.lastIndexOf(".") + 1).toLowerCase();
+			res.writeHead(200, {
+				"content-type": extension === "js" ? "text/javascript; charset=utf-8" : _morlay_dsh_cordis_assets_assets.ASSET_MIME[extension] ?? "application/octet-stream",
+				"cache-control": "public, max-age=31536000, immutable"
+			});
+			res.end(req.method === "HEAD" ? void 0 : bytes);
+			return true;
+		}
+		const exportName = exportNameOfFileName(file);
+		const entry = root === void 0 ? (await dependencyEntry(await resolutionManifestPath(), name).catch(() => void 0))?.entry : await exportTargetOf(root, exportName === "index" ? void 0 : exportName) ?? await fileInPackage(root, exportName);
+		trace(`[fed] ${name}@${version}/${exportName} root=${String(root)} entry=${String(entry)}\n`);
+		if (entry === void 0) {
+			trace(`[federation] ${name}@${version}/${exportName}: unresolved-entry root=${String(root)}\n`);
+			res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+			res.end(req.method === "HEAD" ? void 0 : `unresolved entry: ${name}@${version}/${exportName}\n`);
+			return true;
+		}
+		const bundled = await bundlePackage({
+			cacheRoot,
+			repoRoot: await resolutionRoot(),
+			log: (message) => trace(message),
+			alias: federationAlias,
+			name,
+			version,
+			...root === void 0 ? {} : { manifestOf: (0, node_path.join)(root, "package.json") },
+			clientRows: await clientRowIds(),
+			input: { [exportName]: entry },
+			watch: watchOf(root ?? (await owningPackageOf(entry))?.root, entry),
+			...await tsconfigOf().then((path) => path === void 0 ? {} : { tsconfig: path })
+		}).catch((error) => {
+			ctx.logger.warn(`${name}: bundle-failed ${String(error)}\n`);
+		});
+		if (bundled === void 0) return false;
+		trace(`[fed-tail] ${name}: files=${[...bundled.files.keys()].join(",")} exportName=${exportName}\n`);
+		const target = bundled.files.get(`${exportName}.js`) ?? bundled.files.get(exportName) ?? bundled.files.get("client.js") ?? bundled.files.get("index.js");
+		trace(`${name}: target=${String(target)} 绝对=${String(target === void 0 ? void 0 : (0, node_path.join)(cacheRoot, target))}\n`);
+		if (target === void 0) {
+			ctx.logger.warn(`${name}: missing-export export=${exportName} have=${[...bundled.files.keys()].join(",")}\n`);
+			return false;
+		}
+		const code = await (0, node_fs_promises.readFile)((0, node_path.join)(cacheRoot, target), "utf8").catch((error) => {
+			ctx.logger.warn(`${name}: unreadable file=${(0, node_path.join)(cacheRoot, target)} ${String(error)}\n`);
+		});
+		if (code === void 0) return false;
+		const cacheControl = root !== void 0 && !root.includes("node_modules") ? "no-cache" : "public, max-age=31536000, immutable";
+		const etag = `"${bundled.rev}"`;
+		res.writeHead(200, {
+			"content-type": "text/javascript; charset=utf-8",
+			"cache-control": cacheControl,
+			etag
+		});
+		res.end(req.method === "HEAD" ? void 0 : code);
+		return true;
+	};
+	const serveAny = async (req, res) => {
+		if (/^[a-z][a-z0-9+.-]*:\/\//iu.test(req.url ?? "")) {
+			const absolute = new URL(req.url ?? "");
+			req.url = `${absolute.pathname}${absolute.search}`;
+		}
+		const requestPath = (req.url ?? "").split("?")[0] ?? "";
+		const path = requestPath;
+		const known = !/^\/(?:packages|vendor|apps|devpackages|node_modules)(?:\/|$)/u.test(path);
+		if (path.startsWith("/.well-known/")) {
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		if (!known) {
+			trace("%s referer %s", req.url ?? "", req.headers.referer ?? "-");
+			res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+			res.end("client-modules: 这是仓库里的路径，打包形态下不存在（页面资源在 app-boot 下、包走 exports）\n");
+			return;
+		}
+		trace(`[serveAny] ${req.url ?? ""}
+`);
+		if (requestPath === "/" || requestPath === "/index.html") {
+			const html = await (0, node_fs_promises.readFile)((0, node_path.join)(appRoot, "index.html"), "utf8").catch(() => void 0);
+			if (html === void 0) {
+				ctx.logger.warn(`[serveAny] 页面骨架读不到：${(0, node_path.join)(appRoot, "index.html")}\n`);
+				return fallback(req, res);
+			}
+			try {
+				await ensureVite();
+			} catch (error) {
+				ctx.logger.error(error);
+			}
+			const injected = viteHandoff?.hmr === true ? html.replace("</head>", `  <script type="module" src="/@vite/client"><\/script>\n  </head>`) : html;
+			res.writeHead(200, {
+				"content-type": "text/html; charset=utf-8",
+				"cache-control": "no-cache"
+			});
+			res.end(req.method === "HEAD" ? void 0 : injected);
+			return;
+		}
+		const requestUrl = req.url ?? "";
+		if (requestUrl.split("?")[0]?.startsWith(`/@client-modules/`) === true) {
+			const handled = await serveFederation(requestUrl, req, res);
+			trace("%s handled %s status %s", requestUrl, handled, res.statusCode);
+			if (handled) return;
+		}
+		try {
+			await ensureVite();
+		} catch (error) {
+			ctx.logger.error(error);
+		}
+		if (viteHandoff !== void 0 && viteHandoff.serve(req, res)) {
+			trace("%s status %s", path, res.statusCode);
+			return;
+		}
+		if (path.startsWith("/@")) ctx.logger.warn(`${req.url ?? ""} referer=${req.headers.referer ?? "-"}\n`);
+		return fallback(req, res);
+	};
+	ctx.effect(() => webServer.registerFallback(serveAny), "client-modules: vite 兜底");
+	ctx.effect(() => webServer.registerUpgrade({
+		path: HMR_PATH,
+		handler: () => {}
+	}), "client-modules: vite hmr upgrade");
+	ctx.effect(() => webServer.register({
+		kind: "prefix",
+		path: PLUGIN_ROUTE,
+		handler: serve
+	}), "client-modules: /plugins route");
+}
+//#endregion
+exports.apply = apply;
+exports.inject = inject;
+exports.name = name;