@fulgurjs/federation 6.14.2 → 6.14.4

package/dist/cli.js

@@ -1380,17 +1380,17 @@ function validateHostPages(value) {
   }
   return hp;
 }
-function validatePathsInsideApp(options, appRoot, fs12, path12) {
+function validatePathsInsideApp(options, appRoot, fs12, path13) {
   const checkModule = (field, value) => {
     if (typeof value !== "string" || value.trim() === "") return;
-    if (/^(https?:)?\/\//.test(value) || path12.isAbsolute(value)) {
+    if (/^(https?:)?\/\//.test(value) || path13.isAbsolute(value)) {
       appConfigError(
         `${field} "${value}" \u4E0D\u662F\u672C\u9879\u76EE\u5185\u7684\u6A21\u5757\u8DEF\u5F84`,
         "exposes/setup \u7684\u503C\u662F\u76F8\u5BF9\u672C\u5E94\u7528\u6839\u76EE\u5F55\u7684\u6E90\u6587\u4EF6\u8DEF\u5F84\uFF08URL/\u7EDD\u5BF9\u8DEF\u5F84\u65E0\u6CD5\u5728\u72EC\u7ACB\u4ED3\u5E93\u95F4\u79FB\u690D\uFF09",
         `\u6539\u4E3A\u76F8\u5BF9\u8DEF\u5F84\uFF0C\u5982 './src/views/Home.vue'\uFF08\u914D\u7F6E\u6587\u4EF6\u76EE\u5F55 = \u5E94\u7528\u6839 ${appRoot}\uFF09`
       );
     }
-    const abs = path12.resolve(appRoot, value);
+    const abs = path13.resolve(appRoot, value);
     if (!fs12.existsSync(abs)) {
       appConfigError(
         `${field} \u6307\u5411\u7684\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${value}`,
@@ -1462,8 +1462,8 @@ function resolveEsbuild(configPath) {
 async function loadAppConfig(configPath) {
   const fs12 = await import("node:fs");
   const os = await import("node:os");
-  const path12 = await import("node:path");
-  const abs = path12.resolve(configPath);
+  const path13 = await import("node:path");
+  const abs = path13.resolve(configPath);
   if (!fs12.existsSync(abs)) {
     appConfigError(
       `\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${abs}`,
@@ -1474,7 +1474,7 @@ async function loadAppConfig(configPath) {
   if (abs.endsWith(".json")) {
     const parsed = JSON.parse(fs12.readFileSync(abs, "utf8"));
     if (isAggregateShape(parsed)) aggregateMigrationError();
-    return finishAppShape(parsed, {}, abs, path12.dirname(abs), fs12, path12);
+    return finishAppShape(parsed, {}, abs, path13.dirname(abs), fs12, path13);
   }
   const rawSource = fs12.readFileSync(abs, "utf8");
   if (/@fulgurjs\/federation\/config/.test(rawSource)) {
@@ -1507,21 +1507,21 @@ async function loadAppConfig(configPath) {
     plugins: [selfRedirect],
     logLevel: "silent"
   });
-  const tmpDir = fs12.mkdtempSync(path12.join(os.tmpdir(), "fulgurjs-appcfg-"));
+  const tmpDir = fs12.mkdtempSync(path13.join(os.tmpdir(), "fulgurjs-appcfg-"));
   try {
-    const bundleFile = path12.join(tmpDir, "fulgurjs.config.bundle.mjs");
+    const bundleFile = path13.join(tmpDir, "fulgurjs.config.bundle.mjs");
     fs12.writeFileSync(bundleFile, out.outputFiles[0].text);
     const mod = await import(
       /* @vite-ignore */
       `${pathToFileURL(bundleFile).href}?t=${Date.now()}`
     );
     if (isAggregateShape(mod.default)) aggregateMigrationError();
-    return finishAppShape(mod.default, { hostPages: mod.hostPages }, abs, path12.dirname(abs), fs12, path12);
+    return finishAppShape(mod.default, { hostPages: mod.hostPages }, abs, path13.dirname(abs), fs12, path13);
   } finally {
     fs12.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
-function finishAppShape(def, named, configPath, appRoot, fs12, path12) {
+function finishAppShape(def, named, configPath, appRoot, fs12, path13) {
   if (def === void 0 || def === null) {
     appConfigError(
       "fulgurjs.config.ts \u6CA1\u6709\u53EF\u7528\u7684\u9ED8\u8BA4\u5BFC\u51FA",
@@ -1534,7 +1534,7 @@ function finishAppShape(def, named, configPath, appRoot, fs12, path12) {
   }
   const options = def;
   validateAppOptions(options);
-  validatePathsInsideApp(options, appRoot, fs12, path12);
+  validatePathsInsideApp(options, appRoot, fs12, path13);
   const hostPages = named.hostPages !== void 0 ? validateHostPages(named.hostPages) : void 0;
   return {
     kind: "app",
@@ -3187,7 +3187,7 @@ var RUNTIME_VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    RUNTIME_VERSION = "6.14.2";
+    RUNTIME_VERSION = "6.14.4";
   }
 });
 
@@ -3892,14 +3892,171 @@ var init_dts_vue_display = __esm({
   }
 });
 
+// src/dts-type-display.ts
+import path6 from "node:path";
+function displayPublicDataTypes(ts, files, entries, root, compilerOptions = {}) {
+  const base = path6.join(root, ".fulgurjs-types-display");
+  const paths = new Map([...files].map(([rel, text]) => [path6.resolve(base, rel), text]));
+  const entryPaths = [...new Set(entries)].map((rel) => path6.resolve(base, rel));
+  const needsDisplay = entryPaths.filter((file) => {
+    const source = ts.createSourceFile(file, paths.get(file), ts.ScriptTarget.Latest, true);
+    return source.statements.some((s) => ts.isExportDeclaration(s) && (!s.exportClause || ts.isNamedExports(s.exportClause) && s.exportClause.elements.length > 0) || (ts.isInterfaceDeclaration(s) || ts.isTypeAliasDeclaration(s)) && s.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword));
+  });
+  if (needsDisplay.length === 0) return;
+  const options = {
+    ...compilerOptions,
+    noEmit: true,
+    target: compilerOptions.target ?? ts.ScriptTarget.ESNext,
+    module: compilerOptions.module ?? ts.ModuleKind.ESNext,
+    moduleResolution: compilerOptions.moduleResolution ?? ts.ModuleResolutionKind.Bundler ?? ts.ModuleResolutionKind.NodeJs,
+    skipLibCheck: true,
+    types: [],
+    allowArbitraryExtensions: true
+  };
+  const directories = /* @__PURE__ */ new Set();
+  for (const file of paths.keys()) {
+    for (let dir = path6.dirname(file); dir.startsWith(base); dir = path6.dirname(dir)) directories.add(dir);
+  }
+  const host = ts.createCompilerHost(options, true);
+  const readFile = (file) => paths.get(path6.resolve(file)) ?? ts.sys.readFile(file);
+  host.readFile = readFile;
+  host.fileExists = (file) => paths.has(path6.resolve(file)) || ts.sys.fileExists(file);
+  host.directoryExists = (dir) => directories.has(path6.resolve(dir)) || (ts.sys.directoryExists?.(dir) ?? false);
+  host.realpath = (file) => paths.has(path6.resolve(file)) ? file : ts.sys.realpath?.(file) ?? file;
+  host.getCurrentDirectory = () => root;
+  host.getSourceFile = (file, languageVersion) => {
+    const text = readFile(file);
+    return text === void 0 ? void 0 : ts.createSourceFile(file, text, languageVersion, true);
+  };
+  const program = ts.createProgram(needsDisplay, options, host);
+  const checker = program.getTypeChecker();
+  const plainData = (symbol) => {
+    if (!(symbol.flags & (ts.SymbolFlags.Interface | ts.SymbolFlags.TypeAlias)) || symbol.flags & (ts.SymbolFlags.Value | ts.SymbolFlags.Namespace)) return false;
+    if (symbol.declarations?.some((d) => (ts.isInterfaceDeclaration(d) || ts.isTypeAliasDeclaration(d)) && d.typeParameters?.length)) return false;
+    const type = checker.getDeclaredTypeOfSymbol(symbol);
+    if (!(type.flags & ts.TypeFlags.Object) || type.getCallSignatures().length || type.getConstructSignatures().length || checker.isArrayType(type) || checker.isTupleType(type)) return false;
+    const hasThis = (node) => ts.isThisTypeNode(node) || (ts.forEachChild(node, hasThis) ?? false);
+    const visited = /* @__PURE__ */ new Set();
+    const specialBase = (value) => {
+      if (visited.has(value)) return false;
+      visited.add(value);
+      if (!(value.flags & ts.TypeFlags.Object)) return true;
+      const object = value;
+      const target = object.target ?? object;
+      if ((object.objectFlags | target.objectFlags) & ts.ObjectFlags.Class) return true;
+      if (value.symbol?.declarations?.some(hasThis)) return true;
+      if (value.symbol?.declarations?.some((d) => ts.isInterfaceDeclaration(d) && d.heritageClauses?.some((clause) => clause.types.some((base2) => checker.getTypeAtLocation(base2).flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter))))) return true;
+      return !!(object.objectFlags & ts.ObjectFlags.Interface && checker.getBaseTypes(object)?.some(specialBase));
+    };
+    if (specialBase(type)) return false;
+    const properties = type.getProperties();
+    if (properties.length === 0) return false;
+    return properties.every((property) => !property.name.startsWith("__@") && property.declarations?.every((d) => !hasThis(d) && !ts.isMethodSignature(d) && !ts.isMethodDeclaration(d) && !ts.isGetAccessorDeclaration(d) && !ts.isSetAccessorDeclaration(d) && !(ts.getCombinedModifierFlags(d) & (ts.ModifierFlags.Private | ts.ModifierFlags.Protected)) && !("name" in d && d.name && ts.isPrivateIdentifier(d.name))));
+  };
+  for (const file of needsDisplay) {
+    const source = program.getSourceFile(file);
+    const moduleSymbol = source && checker.getSymbolAtLocation(source);
+    if (!source || !moduleSymbol) continue;
+    const original = paths.get(file);
+    const identifiers = /* @__PURE__ */ new Set();
+    const collect = (node) => {
+      if (ts.isIdentifier(node)) identifiers.add(node.text);
+      ts.forEachChild(node, collect);
+    };
+    collect(source);
+    const unique = (stem) => {
+      let name = stem;
+      for (let n2 = 2; identifiers.has(name); n2++) name = `${stem}${n2}`;
+      identifiers.add(name);
+      return name;
+    };
+    const views = [];
+    for (const exported of checker.getExportsOfModule(moduleSymbol)) {
+      const name = exported.name;
+      if (name === "default" || !/^[$_\p{ID_Start}][$_\p{ID_Continue}]*$/u.test(name)) continue;
+      const target = exported.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported;
+      if (!plainData(target)) continue;
+      let expression;
+      for (const statement of source.statements) {
+        if ((ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) && statement.name.text === name && checker.getSymbolAtLocation(statement.name) === target) {
+          expression = name;
+          break;
+        }
+        if (!ts.isExportDeclaration(statement)) continue;
+        if (statement.attributes || statement.assertClause) continue;
+        if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+          const member = statement.exportClause.elements.find((e) => e.name.text === name);
+          if (member) {
+            const local = member.propertyName ?? member.name;
+            if (!ts.isIdentifier(local)) break;
+            expression = statement.moduleSpecifier ? `import(${statement.moduleSpecifier.getText(source)}).${local.text}` : local.text;
+            break;
+          }
+        } else if (!statement.exportClause && statement.moduleSpecifier) {
+          const from = checker.getSymbolAtLocation(statement.moduleSpecifier);
+          if (from && checker.getExportsOfModule(from).some((e) => e.name === name)) {
+            expression = `import(${statement.moduleSpecifier.getText(source)}).${name}`;
+            break;
+          }
+        }
+      }
+      if (!expression) continue;
+      const docs = exported.getDocumentationComment(checker);
+      const description = ts.displayPartsToString(docs.length ? docs : target.getDocumentationComment(checker));
+      const tags = target.getJsDocTags(checker).map((tag) => `@${tag.name}${tag.text ? ` ${ts.displayPartsToString(tag.text)}` : ""}`);
+      views.push({ name, expression, doc: [description, ...tags].filter(Boolean).join("\n").replace(/\*\//g, "* /") });
+    }
+    if (views.length === 0) continue;
+    const names = new Set(views.map((view) => view.name));
+    const edits = [];
+    for (const statement of source.statements) {
+      if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+        const remaining = statement.exportClause.elements.filter((e) => !names.has(e.name.text));
+        if (remaining.length === statement.exportClause.elements.length) continue;
+        edits.push(remaining.length ? {
+          start: statement.exportClause.getStart(source),
+          end: statement.exportClause.end,
+          text: `{ ${remaining.map((e) => e.getText(source)).join(", ")} }`
+        } : { start: statement.getStart(source), end: statement.end, text: "" });
+      } else if ((ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)) && names.has(statement.name.text) && !statement.modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)) {
+        const modifier = statement.modifiers?.find((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+        if (modifier) edits.push({ start: modifier.getStart(source), end: modifier.end, text: "" });
+      }
+    }
+    let output = original;
+    for (const edit of edits.sort((a, b) => b.start - a.start)) output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+    const display = unique("__FgDataView");
+    output += `
+// \u81EA\u52A8\u751F\u6210\u7684\u5B57\u6BB5\u89C6\u56FE\uFF1B\u539F\u5408\u540C\u53CA\u7EC4\u4EF6\u7B7E\u540D\u4FDD\u7559\uFF0C\u6D88\u8D39\u65B9\u65E0\u9700\u81EA\u884C\u6620\u5C04\u3002
+type ${display}<T> = { [K in keyof T]: T[K] } & {};
+`;
+    for (const view of views.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
+      const alias = unique(`__FgData_${view.name}`);
+      if (view.doc) output += `/**
+${view.doc.split("\n").map((line) => ` * ${line}`).join("\n")}
+ */
+`;
+      output += `type ${alias} = ${display}<${view.expression}>;
+export type { ${alias} as ${view.name} };
+`;
+    }
+    files.set(path6.relative(base, file).split(path6.sep).join("/"), output);
+  }
+}
+var init_dts_type_display = __esm({
+  "src/dts-type-display.ts"() {
+    "use strict";
+  }
+});
+
 // src/dts-generate.ts
 import fs6 from "node:fs";
-import path6 from "node:path";
+import path7 from "node:path";
 import crypto from "node:crypto";
 import { createRequire as createRequire4 } from "node:module";
 import { execFile } from "node:child_process";
 function resolveFromRoot(root, pkg) {
-  const req = createRequire4(path6.join(root, "package.json"));
+  const req = createRequire4(path7.join(root, "package.json"));
   let resolved = null;
   for (const spec of [`${pkg}/package.json`, pkg]) {
     try {
@@ -3909,18 +4066,18 @@ function resolveFromRoot(root, pkg) {
     }
   }
   if (!resolved) return null;
-  let dir = path6.dirname(resolved);
-  for (let i = 0; i < 5 && !fs6.existsSync(path6.join(dir, "package.json")); i++) {
-    const parent = path6.dirname(dir);
+  let dir = path7.dirname(resolved);
+  for (let i = 0; i < 5 && !fs6.existsSync(path7.join(dir, "package.json")); i++) {
+    const parent = path7.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
-  return fs6.existsSync(path6.join(dir, "package.json")) ? dir : null;
+  return fs6.existsSync(path7.join(dir, "package.json")) ? dir : null;
 }
 function installHint(root, pkg) {
   const pkgManager = (() => {
-    if (fs6.existsSync(path6.join(root, "pnpm-lock.yaml"))) return "pnpm";
-    if (fs6.existsSync(path6.join(root, "yarn.lock"))) return "yarn";
+    if (fs6.existsSync(path7.join(root, "pnpm-lock.yaml"))) return "pnpm";
+    if (fs6.existsSync(path7.join(root, "yarn.lock"))) return "yarn";
     return "npm";
   })();
   const devFlag = pkgManager === "pnpm" ? "-D" : "--save-dev";
@@ -3950,7 +4107,7 @@ function computeStaticClosure(ts, entryFiles, resolver, root) {
       continue;
     }
     if (file.endsWith(".vue")) {
-      const req = createRequire4(path6.join(root, "package.json"));
+      const req = createRequire4(path7.join(root, "package.json"));
       const { parse: parse2 } = req("vue/compiler-sfc");
       const { descriptor } = parse2(text);
       text = [descriptor.script?.content, descriptor.scriptSetup?.content].filter(Boolean).join("\n");
@@ -3972,16 +4129,16 @@ import ${JSON.stringify(descriptor.script.src)}`;
       const r = resolver(spec, file);
       let resolved = r && !r.fromNodeModules ? r.resolved : null;
       if (!resolved) {
-        const base = path6.resolve(path6.dirname(file), spec);
-        for (const c of [base, `${base}.vue`, `${base}.ts`, `${base}.tsx`, path6.join(base, "index.ts")]) {
+        const base = path7.resolve(path7.dirname(file), spec);
+        for (const c of [base, `${base}.vue`, `${base}.ts`, `${base}.tsx`, path7.join(base, "index.ts")]) {
           if (fs6.existsSync(c)) {
             resolved = c;
             break;
           }
         }
       }
-      if (resolved && !resolved.includes(`${path6.sep}node_modules${path6.sep}`)) {
-        queue.push(path6.resolve(resolved));
+      if (resolved && !resolved.includes(`${path7.sep}node_modules${path7.sep}`)) {
+        queue.push(path7.resolve(resolved));
       }
     }
   }
@@ -3992,7 +4149,7 @@ function parseErrorFiles(stdout, root) {
   const out = /* @__PURE__ */ new Set();
   for (const line of stdout.split("\n")) {
     const m = line.match(/^([^)(]+)\((\d+),(\d+)\): error TS/);
-    if (m) out.add(path6.resolve(root, m[1].trim()));
+    if (m) out.add(path7.resolve(root, m[1].trim()));
   }
   return out;
 }
@@ -4001,13 +4158,13 @@ function resolveTypesEntries(root, baseCo, diagnostics) {
   if (raw === void 0) return [];
   baseCo.types = [];
   if (!Array.isArray(raw)) return [];
-  const req = createRequire4(path6.join(root, "package.json"));
+  const req = createRequire4(path7.join(root, "package.json"));
   const out = [];
   for (const entry of raw) {
     if (typeof entry !== "string" || entry.length === 0) continue;
-    const direct = [path6.resolve(root, `${entry}.d.ts`), path6.resolve(root, entry, "index.d.ts"), path6.resolve(root, "node_modules", `${entry}.d.ts`), path6.resolve(root, "node_modules", entry, "index.d.ts"), path6.resolve(root, "node_modules/@types", entry, "index.d.ts")];
+    const direct = [path7.resolve(root, `${entry}.d.ts`), path7.resolve(root, entry, "index.d.ts"), path7.resolve(root, "node_modules", `${entry}.d.ts`), path7.resolve(root, "node_modules", entry, "index.d.ts"), path7.resolve(root, "node_modules/@types", entry, "index.d.ts")];
     let hit = direct.find((c) => fs6.existsSync(c));
-    if (!hit && !entry.startsWith(".") && !path6.isAbsolute(entry)) {
+    if (!hit && !entry.startsWith(".") && !path7.isAbsolute(entry)) {
       try {
         const r = req.resolve(entry);
         for (const c of [r.replace(/\.js$/, ".d.ts"), `${r}.d.ts`, r]) {
@@ -4035,27 +4192,27 @@ function hasVueFilesUnderSources(root) {
     }
     for (const e of entries) {
       if (e.name === "node_modules" || e.name === ".git" || e.name === "dist") continue;
-      const p = path6.join(dir, e.name);
+      const p = path7.join(dir, e.name);
       budget.left -= 1;
       if (e.isFile() && e.name.endsWith(".vue")) return true;
       if (e.isDirectory() && scan(p, budget)) return true;
     }
     return false;
   };
-  const srcDir = path6.join(root, "src");
+  const srcDir = path7.join(root, "src");
   return scan(fs6.existsSync(srcDir) ? srcDir : root, { left: 2e3 });
 }
 function commonDirOf(files) {
   if (files.length === 0) return "";
-  let dir = path6.dirname(files[0]);
+  let dir = path7.dirname(files[0]);
   for (const f of files) {
-    const rel = path6.relative(dir, f);
+    const rel = path7.relative(dir, f);
     if (rel.startsWith("..")) {
-      const parts = path6.dirname(f).split(path6.sep);
-      const cur = dir.split(path6.sep);
+      const parts = path7.dirname(f).split(path7.sep);
+      const cur = dir.split(path7.sep);
       let i = 0;
       while (i < parts.length && i < cur.length && parts[i] === cur[i]) i++;
-      dir = parts.slice(0, i).join(path6.sep) || path6.sep;
+      dir = parts.slice(0, i).join(path7.sep) || path7.sep;
     }
   }
   return dir;
@@ -4096,12 +4253,12 @@ function loadTsContext(root, ts, diagnostics) {
     diagnostics.push(`tsconfig \u89E3\u6790\u5931\u8D25\uFF08${tsconfigFile}\uFF09\uFF1A${ts.flattenDiagnosticMessageText(raw.error.messageText, " ")}`);
     return null;
   }
-  const parsed = ts.parseJsonConfigFileContent(raw.config, ts.sys, path6.dirname(tsconfigFile), void 0, void 0, void 0, [
+  const parsed = ts.parseJsonConfigFileContent(raw.config, ts.sys, path7.dirname(tsconfigFile), void 0, void 0, void 0, [
     { extension: ".vue", isMixedContent: true, scriptKind: ts.ScriptKind.Deferred }
   ]);
   const co = { ...parsed.options };
-  if (typeof co.baseUrl === "string" && !path6.isAbsolute(co.baseUrl)) {
-    co.baseUrl = path6.resolve(path6.dirname(tsconfigFile), co.baseUrl);
+  if (typeof co.baseUrl === "string" && !path7.isAbsolute(co.baseUrl)) {
+    co.baseUrl = path7.resolve(path7.dirname(tsconfigFile), co.baseUrl);
   }
   if (parsed.errors.length > 0) {
     const fatal = parsed.errors.filter((e) => e.category === ts.DiagnosticCategory.Error);
@@ -4117,7 +4274,7 @@ function loadTsContext(root, ts, diagnostics) {
     compilerOptions: co,
     rawOptions: raw.config.compilerOptions ?? {},
     projectFiles: parsed.fileNames.filter((f) => !f.endsWith(".d.ts")),
-    ambientInputs: parsed.fileNames.filter((f) => f.endsWith(".d.ts") && !f.includes(`${path6.sep}node_modules${path6.sep}`)),
+    ambientInputs: parsed.fileNames.filter((f) => f.endsWith(".d.ts") && !f.includes(`${path7.sep}node_modules${path7.sep}`)),
     tsconfigFile
   };
 }
@@ -4128,7 +4285,7 @@ function makeResolver(ts, co) {
     let resolved = r.resolvedModule?.resolvedFileName;
     if (resolved?.endsWith(".vue.ts") && ts.sys.fileExists(resolved.slice(0, -3))) resolved = resolved.slice(0, -3);
     if (!resolved) return null;
-    return { resolved, fromNodeModules: resolved.includes(`${path6.sep}node_modules${path6.sep}`) };
+    return { resolved, fromNodeModules: resolved.includes(`${path7.sep}node_modules${path7.sep}`) };
   };
 }
 async function generateTypesBundle(input) {
@@ -4141,7 +4298,7 @@ async function generateTypesBundle(input) {
   if (!tsPkgDir) {
     return { ok: false, diagnostics: [`\u63D0\u4F9B\u65B9\u5DE5\u7A0B\u672A\u5B89\u88C5 typescript\uFF08\u58F0\u660E\u751F\u6210\u5FC5\u9700\uFF09\u3002${installHint(root, "typescript")}`] };
   }
-  const tsReq = createRequire4(path6.join(tsPkgDir, "package.json"));
+  const tsReq = createRequire4(path7.join(tsPkgDir, "package.json"));
   const ts = tsReq("typescript");
   const ctx = loadTsContext(root, ts, diagnostics);
   if (!ctx) return { ok: false, diagnostics };
@@ -4149,9 +4306,9 @@ async function generateTypesBundle(input) {
   const entryMap = /* @__PURE__ */ new Map();
   for (const expose of exposes) {
     const raw = expose.import.replace(/^\.?\//, "");
-    let abs = path6.resolve(root, raw);
+    let abs = path7.resolve(root, raw);
     if (!fs6.existsSync(abs)) {
-      const viaResolver = resolver(expose.import, path6.join(root, "package.json"));
+      const viaResolver = resolver(expose.import, path7.join(root, "package.json"));
       if (viaResolver && !viaResolver.fromNodeModules) abs = viaResolver.resolved;
     }
     abs = abs.replace(/\.js$/, ".ts");
@@ -4183,17 +4340,17 @@ async function generateTypesBundle(input) {
       };
     }
     tool = "vue-tsc";
-    const vueTscPkg = JSON.parse(fs6.readFileSync(path6.join(vueTscDir, "package.json"), "utf8"));
+    const vueTscPkg = JSON.parse(fs6.readFileSync(path7.join(vueTscDir, "package.json"), "utf8"));
     const binRel = vueTscPkg.bin?.["vue-tsc"] ?? vueTscPkg.bin?.["vue-tsc.js"] ?? "bin/vue-tsc.js";
-    const binPath = path6.resolve(vueTscDir, binRel);
+    const binPath = path7.resolve(vueTscDir, binRel);
     const scopedVueProgram = /^1\./.test(vueTscPkg.version);
     if (!fs6.existsSync(binPath)) {
       return { ok: false, diagnostics: [`vue-tsc \u5165\u53E3\u4E0D\u5B58\u5728\uFF08${binPath}\uFF09\u3002\u8BF7\u91CD\u65B0\u5B89\u88C5 vue-tsc\u3002`] };
     }
     const cacheDir = input.incrementalDir;
     if (cacheDir) fs6.mkdirSync(cacheDir, { recursive: true });
-    const tmpCfg = path6.join(root, `.fulgurjs-types-tsconfig-${cacheDir ? path6.basename(cacheDir) : `${process.pid}-${crypto.randomUUID()}`}.json`);
-    const outDir = cacheDir ? path6.join(cacheDir, "emit") : fs6.mkdtempSync(path6.join(root, "node_modules", ".fulgurjs-types-emit-"));
+    const tmpCfg = path7.join(root, `.fulgurjs-types-tsconfig-${cacheDir ? path7.basename(cacheDir) : `${process.pid}-${crypto.randomUUID()}`}.json`);
+    const outDir = cacheDir ? path7.join(cacheDir, "emit") : fs6.mkdtempSync(path7.join(root, "node_modules", ".fulgurjs-types-emit-"));
     const clearOutput = () => {
       if (!cacheDir) fs6.rmSync(outDir, { recursive: true, force: true });
     };
@@ -4220,14 +4377,14 @@ async function generateTypesBundle(input) {
         sourceMap: false,
         outDir,
         rootDir,
-        ...cacheDir && !scopedVueProgram ? { incremental: true, tsBuildInfoFile: path6.join(cacheDir, "state.tsbuildinfo") } : {}
+        ...cacheDir && !scopedVueProgram ? { incremental: true, tsBuildInfoFile: path7.join(cacheDir, "state.tsbuildinfo") } : {}
       },
       // 显式 types 是声明程序的根文件，不能再受工程 exclude: ["node_modules"] 过滤。
       // include 仍受继承的 exclude 约束；files 保留 vite/client 等已解析的全局声明。
-      files: resolvedTypeFiles.map((f) => path6.relative(root, f)),
+      files: resolvedTypeFiles.map((f) => path7.relative(root, f)),
       include: [
-        ...entryFiles.map((f) => path6.relative(root, f)),
-        ...ctx.ambientInputs.map((f) => path6.relative(root, f))
+        ...entryFiles.map((f) => path7.relative(root, f)),
+        ...ctx.ambientInputs.map((f) => path7.relative(root, f))
       ]
     }));
     if (process.env.FG_DUMP_TSCFG) fs6.writeFileSync(process.env.FG_DUMP_TSCFG, fs6.readFileSync(tmpCfg, "utf8"));
@@ -4260,7 +4417,7 @@ async function generateTypesBundle(input) {
         signal?.addEventListener("abort", abort, { once: true });
         if (signal?.aborted) abort();
       });
-      const heapMarker = cacheDir ? path6.join(cacheDir, "raised-heap") : void 0;
+      const heapMarker = cacheDir ? path7.join(cacheDir, "raised-heap") : void 0;
       const raisedArgs = [`--max-old-space-size=${process.env.FG_DTS_MAX_OLD_SPACE ?? "8192"}`];
       const initialArgs = heapMarker && fs6.existsSync(heapMarker) ? raisedArgs : [];
       let { err, stdout, stderr } = await attempt(initialArgs);
@@ -4337,7 +4494,7 @@ ${tail}`);
     collectEmitted(ts, outDir, rootDir, emitted, closure);
     clearOutput();
   } else {
-    const outDir = fs6.mkdtempSync(path6.join(root, "node_modules", ".fulgurjs-types-emit-"));
+    const outDir = fs6.mkdtempSync(path7.join(root, "node_modules", ".fulgurjs-types-emit-"));
     const program = ts.createProgram([...entryFiles, ...ctx.ambientInputs, ...resolveTypesEntries(root, ctx.rawOptions, [])], {
       ...ctx.compilerOptions,
       noEmit: false,
@@ -4355,13 +4512,13 @@ ${tail}`);
       ...program.getOptionsDiagnostics(),
       ...program.getSemanticDiagnostics(),
       ...program.getDeclarationDiagnostics()
-    ].filter((d) => d.category === ts.DiagnosticCategory.Error).filter((d) => !d.file || closure.has(path6.resolve(d.file.fileName)));
+    ].filter((d) => d.category === ts.DiagnosticCategory.Error).filter((d) => !d.file || closure.has(path7.resolve(d.file.fileName)));
     if (errs.length > 0) {
       fs6.rmSync(outDir, { recursive: true, force: true });
       diagnostics.push(
         `\u58F0\u660E\u751F\u6210\u5931\u8D25\uFF1A\u66B4\u9732\u95ED\u5305\u5185\u5B58\u5728 ${errs.length} \u4E2A\u7F16\u8BD1\u9519\u8BEF\u2014\u2014\u7C7B\u578B\u8D44\u6E90\u672A\u4EA7\u51FA\uFF08\u4FEE\u590D\u540E\u91CD\u65B0\u6784\u5EFA/\u91CD\u542F dev\uFF09\u3002\u524D\u82E5\u5E72\u6761\uFF1A`,
         ...errs.slice(0, 20).map((d) => {
-          const f = d.file ? path6.relative(root, d.file.fileName) : "?";
+          const f = d.file ? path7.relative(root, d.file.fileName) : "?";
           const pos = d.file ? d.file.getLineAndCharacterOfPosition(d.start ?? 0) : { line: 0 };
           return `  ${f}:${pos.line + 1} TS${d.code}: ${ts.flattenDiagnosticMessageText(d.messageText, " ")}`;
         })
@@ -4369,11 +4526,11 @@ ${tail}`);
       return { ok: false, diagnostics };
     }
     for (const source of program.getSourceFiles()) {
-      if (source.isDeclarationFile || source.fileName.endsWith(".json") || !closure.has(path6.resolve(source.fileName))) continue;
+      if (source.isDeclarationFile || source.fileName.endsWith(".json") || !closure.has(path7.resolve(source.fileName))) continue;
       const emitResult = program.emit(source, void 0, void 0, true);
       if (emitResult.emitSkipped) {
         fs6.rmSync(outDir, { recursive: true, force: true });
-        return { ok: false, diagnostics: [`TypeScript \u58F0\u660E emit \u5931\u8D25\uFF08emitSkipped\uFF09\uFF1A${path6.relative(root, source.fileName)}\u3002\u8BF7\u68C0\u67E5 tsconfig \u7F16\u8BD1\u9009\u9879\u3002`] };
+        return { ok: false, diagnostics: [`TypeScript \u58F0\u660E emit \u5931\u8D25\uFF08emitSkipped\uFF09\uFF1A${path7.relative(root, source.fileName)}\u3002\u8BF7\u68C0\u67E5 tsconfig \u7F16\u8BD1\u9009\u9879\u3002`] };
       }
     }
     collectEmitted(ts, outDir, rootDir, emitted, closure);
@@ -4419,7 +4576,7 @@ export default value;
   const externals = /* @__PURE__ */ new Set();
   const srcToRel = /* @__PURE__ */ new Map();
   for (const srcAbs of emitted.keys()) {
-    const rel = path6.relative(rootDir, srcAbs).split(path6.sep).join("/");
+    const rel = path7.relative(rootDir, srcAbs).split(path7.sep).join("/");
     const declRel = rel.endsWith(".d.ts") ? `files/${rel}` : rel.endsWith(".vue") ? `files/${rel}.d.ts` : `files/${rel.replace(/\.(mts|cts|ts|tsx|jsx|js)$/, "")}.d.ts`;
     srcToRel.set(srcAbs, declRel);
   }
@@ -4431,7 +4588,7 @@ export default value;
     if (reachable.has(srcAbs)) continue;
     const text = emitted.get(srcAbs);
     if (text === void 0) {
-      diagnostics.push(`\u516C\u5F00\u58F0\u660E\u4F9D\u8D56\u672A\u4EA7\u51FA\uFF1A${path6.relative(root, srcAbs)}\u3002`);
+      diagnostics.push(`\u516C\u5F00\u58F0\u660E\u4F9D\u8D56\u672A\u4EA7\u51FA\uFF1A${path7.relative(root, srcAbs)}\u3002`);
       return { ok: false, diagnostics };
     }
     const rewritten = rewriteSpecifiers(
@@ -4456,11 +4613,10 @@ export default value;
   for (const [srcAbs, text] of reachable) {
     const rel = srcToRel.get(srcAbs);
     if (text.includes(root)) {
-      diagnostics.push(`\u58F0\u660E\u6587\u4EF6\u5305\u542B\u672C\u673A\u7EDD\u5BF9\u8DEF\u5F84\uFF08${path6.relative(root, srcAbs)}\uFF09\uFF0C\u5DF2\u62D2\u7EDD\u4EA7\u51FA\u3002\u8BF7\u68C0\u67E5\u8BE5\u6587\u4EF6\u7684\u7C7B\u578B\u662F\u5426\u5F15\u7528\u4E86\u5B57\u9762\u8DEF\u5F84\u3002`);
+      diagnostics.push(`\u58F0\u660E\u6587\u4EF6\u5305\u542B\u672C\u673A\u7EDD\u5BF9\u8DEF\u5F84\uFF08${path7.relative(root, srcAbs)}\uFF09\uFF0C\u5DF2\u62D2\u7EDD\u4EA7\u51FA\u3002\u8BF7\u68C0\u67E5\u8BE5\u6587\u4EF6\u7684\u7C7B\u578B\u662F\u5426\u5F15\u7528\u4E86\u5B57\u9762\u8DEF\u5F84\u3002`);
       leaked = true;
     }
     files.set(rel, text);
-    filesDigest[rel] = crypto.createHash("sha256").update(text, "utf8").digest("hex");
   }
   if (leaked) return { ok: false, diagnostics };
   const exposesMap = {};
@@ -4472,6 +4628,13 @@ export default value;
     }
     exposesMap[name] = { declaration: declRel };
   }
+  displayPublicDataTypes(ts, files, Object.values(exposesMap).map((entry) => entry.declaration), root, ctx.compilerOptions);
+  for (const [rel, text] of files) {
+    if (text.includes(root)) {
+      return { ok: false, diagnostics: [...diagnostics, `\u58F0\u660E\u6587\u4EF6\u5305\u542B\u672C\u673A\u7EDD\u5BF9\u8DEF\u5F84\uFF08${rel}\uFF09\uFF0C\u5DF2\u62D2\u7EDD\u4EA7\u51FA\u3002`] };
+    }
+    filesDigest[rel] = crypto.createHash("sha256").update(text, "utf8").digest("hex");
+  }
   const index = {
     schemaVersion: TYPES_SCHEMA_VERSION,
     generator: "@fulgurjs/federation",
@@ -4488,18 +4651,18 @@ export default value;
 }
 function collectEmitted(ts, outDir, rootDir, out, closure) {
   const walk = (dir) => fs6.readdirSync(dir, { withFileTypes: true }).flatMap((d) => {
-    const p = path6.join(dir, d.name);
+    const p = path7.join(dir, d.name);
     return d.isDirectory() ? walk(p) : [p];
   });
   if (!fs6.existsSync(outDir)) return;
   for (const file of walk(outDir)) {
     if (!file.endsWith(".d.ts")) continue;
-    const rel = path6.relative(outDir, file);
+    const rel = path7.relative(outDir, file);
     const srcRel = rel.endsWith(".vue.d.ts") ? rel.replace(/\.d\.ts$/, "") : rel.replace(/\.d\.ts$/, ".ts");
-    let srcAbs = path6.join(rootDir, srcRel);
+    let srcAbs = path7.join(rootDir, srcRel);
     if (!out.has(srcAbs) && !fs6.existsSync(srcAbs)) {
       for (const ext of [".tsx", ".jsx", ".mts", ".cts", ".js"]) {
-        const candidate = path6.join(rootDir, rel.replace(/\.d\.ts$/, ext));
+        const candidate = path7.join(rootDir, rel.replace(/\.d\.ts$/, ext));
         if (fs6.existsSync(candidate)) {
           srcAbs = candidate;
           break;
@@ -4517,7 +4680,7 @@ function rewriteSpecifiers(ts, text, srcAbs, srcToRel, resolver, externals, root
   const fail = (spec) => {
     failed = true;
     diagnostics.push(
-      `\u58F0\u660E\u4F9D\u8D56\u4E0D\u5B8C\u6574\uFF1A${path6.relative(root, srcAbs)} \u7684\u5BFC\u5165 "${spec}" \u65E0\u6CD5\u89E3\u6790\u5230\u5DE5\u7A0B\u5185\u6587\u4EF6\u3002\u8BF7\u68C0\u67E5 tsconfig paths/include \u662F\u5426\u8986\u76D6\u8BE5\u4F9D\u8D56\u3002`
+      `\u58F0\u660E\u4F9D\u8D56\u4E0D\u5B8C\u6574\uFF1A${path7.relative(root, srcAbs)} \u7684\u5BFC\u5165 "${spec}" \u65E0\u6CD5\u89E3\u6790\u5230\u5DE5\u7A0B\u5185\u6587\u4EF6\u3002\u8BF7\u68C0\u67E5 tsconfig paths/include \u662F\u5426\u8986\u76D6\u8BE5\u4F9D\u8D56\u3002`
     );
     return null;
   };
@@ -4548,9 +4711,9 @@ function rewriteSpecifiers(ts, text, srcAbs, srcToRel, resolver, externals, root
     return target;
   };
   const rewriteTo = (targetRel) => {
-    const fromDir = path6.posix.dirname(declRel);
+    const fromDir = path7.posix.dirname(declRel);
     const toNoExt = targetRel.replace(/\.d\.ts$/, "");
-    let rel = path6.posix.relative(fromDir, toNoExt);
+    let rel = path7.posix.relative(fromDir, toNoExt);
     if (!rel.startsWith(".")) rel = `./${rel}`;
     return rel;
   };
@@ -4641,6 +4804,7 @@ var init_dts_generate = __esm({
     init_dts_vue_program();
     init_dts_shared();
     init_dts_vue_display();
+    init_dts_type_display();
     INHERITABLE_KEYS = [
       "paths",
       "baseUrl",
@@ -4832,7 +4996,7 @@ var init_dts_ambient = __esm({
 
 // src/dts-discovery.ts
 import fs7 from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 function stripJsoncForConfig(text) {
   let out = "";
   let i = 0;
@@ -4896,24 +5060,24 @@ function effectiveCfg(cfg, depth = 0) {
     const parentFile = resolveConfigFile(parent, cfg.file);
     if (!parentFile) continue;
     const parentCfg = effectiveCfg(readCfg(parentFile) ?? { file: parentFile }, depth + 1);
-    const dirOf = (f, base) => path7.resolve(path7.dirname(base), f);
+    const dirOf = (f, base) => path8.resolve(path8.dirname(base), f);
     if (parentCfg.include && !cfg.include) {
-      merged.include = parentCfg.include.map((p) => path7.relative(path7.dirname(cfg.file), dirOf(p, parentFile)) || ".");
+      merged.include = parentCfg.include.map((p) => path8.relative(path8.dirname(cfg.file), dirOf(p, parentFile)) || ".");
     }
     if (parentCfg.files && !cfg.files) {
-      merged.files = parentCfg.files.map((p) => path7.relative(path7.dirname(cfg.file), dirOf(p, parentFile)));
+      merged.files = parentCfg.files.map((p) => path8.relative(path8.dirname(cfg.file), dirOf(p, parentFile)));
     }
     if (parentCfg.exclude && !cfg.exclude) {
-      merged.exclude = parentCfg.exclude.map((p) => path7.relative(path7.dirname(cfg.file), dirOf(p, parentFile)));
+      merged.exclude = parentCfg.exclude.map((p) => path8.relative(path8.dirname(cfg.file), dirOf(p, parentFile)));
     }
   }
   return merged;
 }
 function resolveConfigFile(value, declaringFile) {
-  let candidate = path7.resolve(path7.dirname(declaringFile), value);
+  let candidate = path8.resolve(path8.dirname(declaringFile), value);
   if (!candidate.endsWith(".json")) candidate += ".json";
   if (fs7.existsSync(candidate)) return candidate;
-  const asDir = path7.join(candidate, "tsconfig.json");
+  const asDir = path8.join(candidate, "tsconfig.json");
   return fs7.existsSync(asDir) ? asDir : null;
 }
 function patternCoversDir(pattern, target, cfgDir) {
@@ -4924,15 +5088,15 @@ function patternCoversDir(pattern, target, cfgDir) {
   if (norm.includes("**")) base = norm.slice(0, norm.indexOf("**")).replace(/\/+$/, "");
   else if (norm.endsWith("/*")) base = norm.slice(0, -2);
   else base = norm.replace(/\/+$/, "");
-  const abs = base === "" || base === "." ? cfgDir : path7.resolve(cfgDir, base);
-  return target === abs || target.startsWith(abs + path7.sep);
+  const abs = base === "" || base === "." ? cfgDir : path8.resolve(cfgDir, base);
+  return target === abs || target.startsWith(abs + path8.sep);
 }
 function checkTypesDiscovery(root, typesRoot) {
-  const relTypes = path7.relative(root, typesRoot) || ".";
+  const relTypes = path8.relative(root, typesRoot) || ".";
   const configs = [];
-  let primary = path7.join(root, "tsconfig.json");
+  let primary = path8.join(root, "tsconfig.json");
   if (!fs7.existsSync(primary)) {
-    const candidates = fs7.existsSync(root) ? fs7.readdirSync(root).filter((f) => /^tsconfig[\w.-]*\.json$/i.test(f)).map((f) => path7.join(root, f)) : [];
+    const candidates = fs7.existsSync(root) ? fs7.readdirSync(root).filter((f) => /^tsconfig[\w.-]*\.json$/i.test(f)).map((f) => path8.join(root, f)) : [];
     if (candidates.length === 0) {
       return {
         covered: false,
@@ -4944,7 +5108,7 @@ function checkTypesDiscovery(root, typesRoot) {
     if (candidates.length > 1) {
       let covered = false;
       for (const file of candidates) {
-        configs.push(path7.relative(root, file));
+        configs.push(path8.relative(root, file));
         if (configCovers(file, typesRoot)) covered = true;
       }
       if (covered) return { covered: true, configs, fixHint: null };
@@ -4955,34 +5119,34 @@ function checkTypesDiscovery(root, typesRoot) {
       };
     }
   }
-  configs.push(path7.relative(root, primary));
+  configs.push(path8.relative(root, primary));
   if (configCovers(primary, typesRoot)) return { covered: true, configs, fixHint: null };
   return {
     covered: false,
     configs,
-    fixHint: `TYP-006 \u7C7B\u578B\u76EE\u5F55 ${relTypes} \u672A\u88AB ${path7.relative(root, primary)} \u7684 include/files \u8986\u76D6\uFF08exclude \u6216\u4E25\u683C files \u767D\u540D\u5355\u90FD\u4F1A\u8BA9\u751F\u6210\u58F0\u660E\u5BF9 IDE/tsc \u4E0D\u53EF\u89C1\uFF09\u3002\u6700\u5C0F\u4FEE\u6CD5\uFF1Ainclude \u52A0\u5165 "${relTypes}/**/*.d.ts"\uFF0C\u6216\u79FB\u9664\u5BF9\u5B83\u7684 exclude/files \u9650\u5236\u3002`
+    fixHint: `TYP-006 \u7C7B\u578B\u76EE\u5F55 ${relTypes} \u672A\u88AB ${path8.relative(root, primary)} \u7684 include/files \u8986\u76D6\uFF08exclude \u6216\u4E25\u683C files \u767D\u540D\u5355\u90FD\u4F1A\u8BA9\u751F\u6210\u58F0\u660E\u5BF9 IDE/tsc \u4E0D\u53EF\u89C1\uFF09\u3002\u6700\u5C0F\u4FEE\u6CD5\uFF1Ainclude \u52A0\u5165 "${relTypes}/**/*.d.ts"\uFF0C\u6216\u79FB\u9664\u5BF9\u5B83\u7684 exclude/files \u9650\u5236\u3002`
   };
 }
 function configCovers(cfgFile, typesRoot) {
   const raw = readCfg(cfgFile);
   if (!raw) return false;
   const cfg = effectiveCfg(raw);
-  const cfgDir = path7.dirname(cfgFile);
+  const cfgDir = path8.dirname(cfgFile);
   const isSolution = Array.isArray(cfg.files) && cfg.files.length === 0 && !cfg.include;
   if (isSolution && cfg.references && cfg.references.length > 0) {
     return cfg.references.some((ref) => {
-      const refFile = resolveConfigFile(ref.startsWith(".") || path7.isAbsolute(ref) ? ref : `./${ref}`, cfgFile);
+      const refFile = resolveConfigFile(ref.startsWith(".") || path8.isAbsolute(ref) ? ref : `./${ref}`, cfgFile);
       return refFile !== null && configCovers(refFile, typesRoot);
     });
   }
   if (Array.isArray(cfg.files) && cfg.files.length > 0) {
     return cfg.files.some((f) => {
-      const abs = path7.resolve(cfgDir, f);
-      return abs === typesRoot || abs.startsWith(typesRoot + path7.sep);
+      const abs = path8.resolve(cfgDir, f);
+      return abs === typesRoot || abs.startsWith(typesRoot + path8.sep);
     });
   }
   const includes = cfg.include;
-  if (!includes) return typesRoot === cfgDir || typesRoot.startsWith(cfgDir + path7.sep);
+  if (!includes) return typesRoot === cfgDir || typesRoot.startsWith(cfgDir + path8.sep);
   const included = includes.some((p) => patternCoversDir(p, typesRoot, cfgDir));
   if (!included) return false;
   if (cfg.exclude && cfg.exclude.some((p) => patternCoversDir(p, typesRoot, cfgDir))) return false;
@@ -4996,7 +5160,7 @@ var init_dts_discovery = __esm({
 
 // src/dts-sync.ts
 import fs8 from "node:fs";
-import path8 from "node:path";
+import path9 from "node:path";
 import crypto2 from "node:crypto";
 function readManifestTypes(m) {
   const t = m.types;
@@ -5032,7 +5196,7 @@ async function fetchText(url, timeoutMs) {
 }
 function readMetadata(dir) {
   try {
-    const raw = JSON.parse(fs8.readFileSync(path8.join(dir, METADATA_FILE), "utf8"));
+    const raw = JSON.parse(fs8.readFileSync(path9.join(dir, METADATA_FILE), "utf8"));
     if (raw.generator !== "@fulgurjs/federation" || typeof raw.revision !== "string" || !Array.isArray(raw.files)) return null;
     return raw;
   } catch {
@@ -5042,9 +5206,9 @@ function readMetadata(dir) {
 function cleanupOwnFiles(dir, meta) {
   for (const f of meta.files) {
     if (!isSafeBundlePath(f)) continue;
-    fs8.rmSync(path8.join(dir, f), { force: true });
+    fs8.rmSync(path9.join(dir, f), { force: true });
   }
-  fs8.rmSync(path8.join(dir, METADATA_FILE), { force: true });
+  fs8.rmSync(path9.join(dir, METADATA_FILE), { force: true });
   try {
     if (fs8.readdirSync(dir).length === 0) fs8.rmdirSync(dir);
   } catch {
@@ -5054,7 +5218,7 @@ function sweepStaleStaging(typesRoot, alias) {
   if (!fs8.existsSync(typesRoot)) return;
   for (const name of fs8.readdirSync(typesRoot)) {
     if (name.startsWith(`.fg-staging-${alias}-`) || name.startsWith(`.fg-trash-${alias}-`)) {
-      fs8.rmSync(path8.join(typesRoot, name), { recursive: true, force: true });
+      fs8.rmSync(path9.join(typesRoot, name), { recursive: true, force: true });
     }
   }
 }
@@ -5063,7 +5227,7 @@ async function syncRemoteTypes(input) {
   const fetchJsonFn = input.fetchJsonImpl ?? fetchJson;
   const fetchTextFn = input.fetchTextImpl ?? fetchText;
   const timeoutMs = input.timeoutMs ?? 15e3;
-  const dir = path8.join(typesRoot, alias);
+  const dir = path9.join(typesRoot, alias);
   let manifest;
   try {
     const parsed = parseManifest(await fetchJsonFn(manifestUrl, timeoutMs));
@@ -5164,14 +5328,14 @@ async function syncRemoteTypes(input) {
   }
   const ambient = buildAmbientDeclarations({ alias, index, readFile: (rel) => indexRaw[rel] ?? "", source });
   sweepStaleStaging(typesRoot, alias);
-  const staging = path8.join(typesRoot, `.fg-staging-${alias}-${process.pid}-${Date.now()}`);
+  const staging = path9.join(typesRoot, `.fg-staging-${alias}-${process.pid}-${Date.now()}`);
   fs8.rmSync(staging, { recursive: true, force: true });
   fs8.mkdirSync(staging, { recursive: true });
   const written = [];
   try {
     for (const [name, content] of ambient.files) {
-      const dest = path8.join(staging, name);
-      fs8.mkdirSync(path8.dirname(dest), { recursive: true });
+      const dest = path9.join(staging, name);
+      fs8.mkdirSync(path9.dirname(dest), { recursive: true });
       fs8.writeFileSync(dest, content);
       written.push(name);
     }
@@ -5185,8 +5349,8 @@ async function syncRemoteTypes(input) {
       externals: index.externals,
       syncedAt: Date.now()
     };
-    fs8.writeFileSync(path8.join(staging, METADATA_FILE), JSON.stringify(meta, null, 2));
-    const trash = path8.join(typesRoot, `.fg-trash-${alias}-${Date.now()}`);
+    fs8.writeFileSync(path9.join(staging, METADATA_FILE), JSON.stringify(meta, null, 2));
+    const trash = path9.join(typesRoot, `.fg-trash-${alias}-${Date.now()}`);
     let swapped = false;
     if (fs8.existsSync(dir)) {
       fs8.renameSync(dir, trash);
@@ -5231,15 +5395,15 @@ __export(dts_cli_exports, {
   runTypesCommand: () => runTypesCommand
 });
 import fs9 from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 import { createRequire as createRequire5 } from "node:module";
 function hostTypesRoot(root, dtsDirOverride) {
-  if (dtsDirOverride) return path9.resolve(root, dtsDirOverride);
-  return path9.join(root, fs9.existsSync(path9.join(root, "src")) ? "src/fulgurjs/types" : ".fulgurjs/types");
+  if (dtsDirOverride) return path10.resolve(root, dtsDirOverride);
+  return path10.join(root, fs9.existsSync(path10.join(root, "src")) ? "src/fulgurjs/types" : ".fulgurjs/types");
 }
 async function runTypesCommand(opts) {
   const cwd = opts.cwd ?? process.cwd();
-  const configPath = path9.resolve(cwd, opts.configPath ?? "fulgurjs.config.ts");
+  const configPath = path10.resolve(cwd, opts.configPath ?? "fulgurjs.config.ts");
   const lines = [];
   let failed = false;
   let cfg;
@@ -5248,7 +5412,7 @@ async function runTypesCommand(opts) {
   } catch (e) {
     return { exitCode: 2, lines: [String(e.message ?? e)] };
   }
-  const root = path9.dirname(configPath);
+  const root = path10.dirname(configPath);
   const mode = opts.mode ?? "dev";
   const n2 = normalizeOptions(cfg.options, root, mode === "dev" ? "serve" : "build");
   const dtsEnabled = n2.dts !== false;
@@ -5277,7 +5441,7 @@ async function runTypesCommand(opts) {
   const syncable = n2.remotes.filter((r) => !r.promise && (mode === "dev" ? r.devEntry : r.prodEntry));
   if (opts.check) {
     for (const remote of n2.remotes) {
-      const meta = readMetadata(path9.join(typesRoot, remote.key));
+      const meta = readMetadata(path10.join(typesRoot, remote.key));
       if (!meta) {
         failed = true;
         lines.push(`[check] \u8FDC\u7A0B ${remote.key}\uFF1A\u672C\u5730\u65E0\u5DF2\u540C\u6B65\u7C7B\u578B\uFF08\u5148\u8FD0\u884C fulgurjs types\uFF09\u3002`);
@@ -5288,7 +5452,7 @@ async function runTypesCommand(opts) {
     return { exitCode: failed ? 1 : 0, lines };
   }
   if (syncable.length > 0) {
-    lines.push(`[consumer] \u5F00\u59CB\u540C\u6B65 ${syncable.length} \u4E2A\u8FDC\u7A0B\u7684\u7C7B\u578B\uFF08--mode ${mode}\uFF0C\u76EE\u5F55 ${path9.relative(root, typesRoot) || typesRoot}\uFF09\u2026\u2026`);
+    lines.push(`[consumer] \u5F00\u59CB\u540C\u6B65 ${syncable.length} \u4E2A\u8FDC\u7A0B\u7684\u7C7B\u578B\uFF08--mode ${mode}\uFF0C\u76EE\u5F55 ${path10.relative(root, typesRoot) || typesRoot}\uFF09\u2026\u2026`);
     const externalsMissing = /* @__PURE__ */ new Map();
     let virtualTypes;
     for (const remote of syncable) {
@@ -5312,7 +5476,7 @@ async function runTypesCommand(opts) {
       if (result.status === "absent") {
         failed = true;
       }
-      const meta = readMetadata(path9.join(typesRoot, remote.key));
+      const meta = readMetadata(path10.join(typesRoot, remote.key));
       if (meta) {
         for (const ext of meta.externals) {
           if (ext === "*.vue") continue;
@@ -5360,14 +5524,14 @@ async function runTypesCommand(opts) {
 function resolveVirtualTypes(root) {
   const modules = /* @__PURE__ */ new Set();
   try {
-    const ts = createRequire5(path9.join(root, "package.json"))("typescript");
+    const ts = createRequire5(path10.join(root, "package.json"))("typescript");
     const visited = /* @__PURE__ */ new Set();
     const visit = (configPath2) => {
       if (visited.has(configPath2)) return;
       visited.add(configPath2);
       const config = ts.readConfigFile(configPath2, ts.sys.readFile);
       if (config.error) return;
-      const parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, path9.dirname(configPath2), void 0, configPath2);
+      const parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, path10.dirname(configPath2), void 0, configPath2);
       const roots = parsed.fileNames.filter((file) => /\.d\.[cm]?ts$/.test(file));
       const program = ts.createProgram({ rootNames: roots, options: { ...parsed.options, noEmit: true } });
       for (const symbol of program.getTypeChecker().getAmbientModules()) {
@@ -5384,11 +5548,11 @@ function resolveVirtualTypes(root) {
 }
 function resolvePackage(root, pkg) {
   try {
-    createRequire5(path9.join(root, "package.json")).resolve(`${pkg}/package.json`);
+    createRequire5(path10.join(root, "package.json")).resolve(`${pkg}/package.json`);
     return true;
   } catch {
     try {
-      createRequire5(path9.join(root, "package.json")).resolve(pkg);
+      createRequire5(path10.join(root, "package.json")).resolve(pkg);
       return true;
     } catch {
       return false;
@@ -5415,9 +5579,9 @@ __export(port_exports, {
   planPortChange: () => planPortChange
 });
 import fs10 from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 function readDevConfig2(root) {
-  const file = path10.join(root, "scripts", "dev.config.json");
+  const file = path11.join(root, "scripts", "dev.config.json");
   if (!fs10.existsSync(file)) {
     throw new Error(
       "[fulgurjs:port] \u672A\u627E\u5230 scripts/dev.config.json\u2014\u2014\u672C\u547D\u4EE4\u7528\u4E8E\u6A21\u677F\u5DE5\u7A0B\uFF08create \u751F\u6210\uFF09\u3002\n  \u4FEE\u6CD5\uFF1A\u5728\u6A21\u677F\u5DE5\u7A0B\u6839\u76EE\u5F55\u8FD0\u884C\uFF1B\u81EA\u5EFA\u5DE5\u7A0B\u8BF7\u6309\u6587\u6863\u56DB\u5904\u6E05\u5355\u624B\u5DE5\u6539\u7AEF\u53E3"
@@ -5448,14 +5612,14 @@ function planPortChange(root, app, to) {
   }
   const notes = [];
   const candidates = [
-    { file: path10.join(root, target.dir, "package.json"), required: true },
-    { file: path10.join(root, "scripts", "dev.config.json"), required: true },
-    { file: path10.join(root, "fulgurjs.config.ts"), required: false },
-    { file: path10.join(root, "README.md"), required: false }
+    { file: path11.join(root, target.dir, "package.json"), required: true },
+    { file: path11.join(root, "scripts", "dev.config.json"), required: true },
+    { file: path11.join(root, "fulgurjs.config.ts"), required: false },
+    { file: path11.join(root, "README.md"), required: false }
   ];
   for (const a of cfg.apps) {
     if (a.host && a.dir !== target.dir) {
-      candidates.push({ file: path10.join(root, a.dir, "fulgurjs.config.ts"), required: false });
+      candidates.push({ file: path11.join(root, a.dir, "fulgurjs.config.ts"), required: false });
     }
   }
   const plans = [];
@@ -5475,7 +5639,7 @@ function planPortChange(root, app, to) {
   }
   const notFound = plans.filter((p) => p.status === "not-found" || p.status === "missing-file");
   if (notFound.length) {
-    notes.push(`\u4EE5\u4E0B\u6587\u4EF6\u672A\u53D1\u73B0\u65E7\u7AEF\u53E3 ${from}\uFF08\u53EF\u80FD\u5DF2\u6539\u6216\u5F62\u6001\u4E0D\u540C\uFF0C\u8BF7\u4EBA\u5DE5\u786E\u8BA4\uFF09\uFF1A${notFound.map((p) => path10.relative(root, p.file)).join("\u3001")}`);
+    notes.push(`\u4EE5\u4E0B\u6587\u4EF6\u672A\u53D1\u73B0\u65E7\u7AEF\u53E3 ${from}\uFF08\u53EF\u80FD\u5DF2\u6539\u6216\u5F62\u6001\u4E0D\u540C\uFF0C\u8BF7\u4EBA\u5DE5\u786E\u8BA4\uFF09\uFF1A${notFound.map((p) => path11.relative(root, p.file)).join("\u3001")}`);
   }
   return { app: target.name, dir: target.dir, from, to, plans, notes };
 }
@@ -5496,7 +5660,7 @@ function formatPortPlan(root, plan) {
   const lines = [];
   lines.push(`[fulgurjs:port] \u8BA1\u5212\uFF1A${plan.app}\uFF08\u76EE\u5F55 ${plan.dir}\uFF09\u7AEF\u53E3 ${plan.from} \u2192 ${plan.to}`);
   for (const p of plan.plans) {
-    const rel = path10.relative(root, p.file);
+    const rel = path11.relative(root, p.file);
     if (p.status === "planned") lines.push(`  \u6539\u5199 ${rel}\uFF08${p.hits} \u5904\uFF09`);
     else if (p.status === "not-found") lines.push(`  \u8DF3\u8FC7 ${rel}\uFF08\u672A\u53D1\u73B0\u65E7\u7AEF\u53E3 ${plan.from}\uFF09`);
     else lines.push(`  \u8DF3\u8FC7 ${rel}\uFF08\u6587\u4EF6\u4E0D\u5B58\u5728\uFF09`);
@@ -5517,7 +5681,7 @@ __export(doctor_source_exports, {
   runSourceDoctor: () => runSourceDoctor
 });
 import fs11 from "node:fs";
-import path11 from "node:path";
+import path12 from "node:path";
 import { createRequire as createRequire6 } from "node:module";
 async function runSourceDoctor(configPath) {
   let loaded;
@@ -5551,14 +5715,14 @@ async function runSourceDoctor(configPath) {
   const imports = /* @__PURE__ */ new Set();
   const sources = /* @__PURE__ */ new Map();
   let complete = true;
-  const relative = (file) => path11.relative(root, file).split(path11.sep).join("/");
-  const within = (file) => file === root || file.startsWith(root + path11.sep);
+  const relative = (file) => path12.relative(root, file).split(path12.sep).join("/");
+  const within = (file) => file === root || file.startsWith(root + path12.sep);
   const add = (item, level, symptom, cause, fix) => {
     checks.push({ app, item, level, symptom, cause, fix });
   };
   const resolveSource = (value, parent = root) => {
     const clean = value.split(/[?#]/)[0];
-    const file = /^(?:\/?@\/|~\/)/.test(clean) ? path11.join(root, "src", clean.replace(/^(?:\/?@\/|~\/)/, "")) : path11.resolve(parent, clean);
+    const file = /^(?:\/?@\/|~\/)/.test(clean) ? path12.join(root, "src", clean.replace(/^(?:\/?@\/|~\/)/, "")) : path12.resolve(parent, clean);
     for (const ext of extensions) {
       const candidate = file + ext;
       if (!fs11.existsSync(candidate) || !fs11.statSync(candidate).isFile()) continue;
@@ -5568,10 +5732,10 @@ async function runSourceDoctor(configPath) {
     return void 0;
   };
   const required = [relative(loaded.configPath)];
-  const viteFiles = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"].filter((file) => fs11.existsSync(path11.join(root, file)));
+  const viteFiles = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"].filter((file) => fs11.existsSync(path12.join(root, file)));
   if (viteFiles.length !== 1) add("Vite \u63D2\u4EF6\u63A5\u7EBF", "WARN", "\u672A\u627E\u5230\u552F\u4E00\u5E38\u89C4 Vite \u914D\u7F6E\uFF0C\u65E0\u6CD5\u786E\u8BA4\u63D2\u4EF6\u6CE8\u518C\u3002", "\u53EF\u80FD\u4F7F\u7528\u81EA\u5B9A\u4E49 --config \u6216\u591A\u4EFD\u73AF\u5883\u914D\u7F6E\u3002", "\u5728\u5B9E\u9645 Vite plugins \u4E2D\u6CE8\u518C federation(fulgurjsConfig)\uFF1Binit --plan \u53EF\u9884\u89C8\u53D7\u652F\u6301\u914D\u7F6E\u7684\u63A5\u7EBF\u3002");
   else {
-    const code = fs11.readFileSync(path11.join(root, viteFiles[0]), "utf8");
+    const code = fs11.readFileSync(path12.join(root, viteFiles[0]), "utf8");
     add(
       viteFiles[0],
       "WARN",
@@ -5580,7 +5744,7 @@ async function runSourceDoctor(configPath) {
       code.includes("@fulgurjs/federation") ? "\u8FD0\u884C\u771F\u5B9E dev/build\uFF1B\u786E\u8BA4\u5F53\u524D\u914D\u7F6E\u8C03\u7528 federation\uFF0C\u751F\u4EA7 base/\u8FDC\u7A0B prod \u524D\u7F00\u4E0E\u670D\u52A1\u5668\u6620\u5C04\u4E00\u81F4\u3002" : "\u68C0\u67E5\u63D2\u4EF6\u662F\u5426\u7531\u8F85\u52A9\u51FD\u6570\u6CE8\u518C\uFF1B\u5426\u5219\u7528 init --plan \u9884\u89C8\u63A5\u7EBF\uFF0C\u4E0D\u8981\u4EC5\u521B\u5EFA fulgurjs.config.ts\u3002"
     );
   }
-  if (fs11.existsSync(path11.join(root, ".fulgurjs-init-pending.json"))) add("\u63A5\u5165\u5199\u5165\u6062\u590D", "FAIL", "\u5B58\u5728\u88AB\u4E2D\u65AD\u7684 init \u5199\u5165\u8BB0\u5F55\u3002", "\u6B64\u524D\u5199\u5165\u5C1A\u672A\u5B8C\u6210\u6216\u56DE\u9000\u9047\u5230\u624B\u5DE5\u7F16\u8F91\u3002", "\u8FD0\u884C fulgurjs init --rollback\uFF1B\u82E5\u63D0\u793A\u6587\u4EF6\u88AB\u7F16\u8F91\uFF0C\u6309\u6062\u590D\u8BB0\u5F55\u4EBA\u5DE5\u5408\u5E76\u540E\u518D\u6267\u884C\u3002");
+  if (fs11.existsSync(path12.join(root, ".fulgurjs-init-pending.json"))) add("\u63A5\u5165\u5199\u5165\u6062\u590D", "FAIL", "\u5B58\u5728\u88AB\u4E2D\u65AD\u7684 init \u5199\u5165\u8BB0\u5F55\u3002", "\u6B64\u524D\u5199\u5165\u5C1A\u672A\u5B8C\u6210\u6216\u56DE\u9000\u9047\u5230\u624B\u5DE5\u7F16\u8F91\u3002", "\u8FD0\u884C fulgurjs init --rollback\uFF1B\u82E5\u63D0\u793A\u6587\u4EF6\u88AB\u7F16\u8F91\uFF0C\u6309\u6062\u590D\u8BB0\u5F55\u4EBA\u5DE5\u5408\u5E76\u540E\u518D\u6267\u884C\u3002");
   for (const [key, expose] of Object.entries(options.exposes ?? {})) {
     const file = resolveSource(typeof expose === "string" ? expose : expose.import);
     if (file) {
@@ -5606,7 +5770,7 @@ async function runSourceDoctor(configPath) {
       add("setup", "FAIL", "setup \u6E90\u6587\u4EF6\u4E0D\u5B58\u5728\u6216\u65E0\u6CD5\u89E3\u6790\u3002", "\u521D\u59CB\u5316\u5165\u53E3\u4E0D\u80FD\u5728\u52A0\u8F7D\u65F6\u624D\u53D1\u73B0\u7F3A\u5931\u3002", "\u4FEE\u6B63 setup \u8DEF\u5F84\uFF1B\u6CA1\u6709\u521D\u59CB\u5316\u9700\u6C42\u5219\u5220\u9664 setup \u914D\u7F6E\u3002");
     }
   }
-  const html = path11.join(root, "index.html");
+  const html = path12.join(root, "index.html");
   let hasEntry = false;
   if (fs11.existsSync(html)) for (const tag of fs11.readFileSync(html, "utf8").matchAll(/<script\b[^>]*>/gi)) {
     const entry = tag[0].match(/\bsrc=["']([^"']+)["']/i)?.[1];
@@ -5653,7 +5817,7 @@ async function runSourceDoctor(configPath) {
         }
         if (item.n.startsWith(".") || /^(?:\/?@\/|~\/)/.test(item.n)) {
           if (/\.(?:[cm]?js|jsx|ts|tsx|vue)$/.test(item.n.split(/[?#]/)[0]) || !/\.[a-z0-9]+$/i.test(item.n.split(/[?#]/)[0])) {
-            const next = resolveSource(item.n, path11.dirname(file));
+            const next = resolveSource(item.n, path12.dirname(file));
             if (next) pending.push(next);
             else {
               complete = false;