@fulgurjs/federation 0.4.2

package/dist/cli.js

@@ -0,0 +1,650 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config.ts
+async function loadFulgurConfig(configPath) {
+  const { pathToFileURL, fileURLToPath } = await import("node:url");
+  const { createRequire } = await import("node:module");
+  const fs2 = await import("node:fs");
+  const os = await import("node:os");
+  const path2 = await import("node:path");
+  const selfDir = path2.dirname(fileURLToPath(import.meta.url));
+  const selfConfigJs = path2.join(selfDir, "config.js");
+  const SELF_SPEC = fs2.existsSync(selfConfigJs) ? pathToFileURL(selfConfigJs).href : "@fulgur-federation-config-unavailable";
+  const rewriteSelfImports = (source) => source.replace(/(['"])@fulgur\/federation\/config\1/g, (_m, q) => `${q}${SELF_SPEC}${q}`);
+  const importConfigs = async (cacheKey) => {
+    return await import(`${cacheKey}?t=${Date.now()}`);
+  };
+  let mod;
+  if (configPath.endsWith(".json")) {
+    mod = { default: JSON.parse(fs2.readFileSync(configPath, "utf8")) };
+  } else {
+    const source = rewriteSelfImports(fs2.readFileSync(configPath, "utf8"));
+    const tmpBase = path2.join(os.tmpdir(), `fulgur-config-${Date.now()}`);
+    if (/\.(ts|mts|cts)$/.test(configPath)) {
+      try {
+        const tmpTs = `${tmpBase}.ts`;
+        fs2.writeFileSync(tmpTs, source);
+        mod = await importConfigs(pathToFileURL(tmpTs).href);
+      } catch (e) {
+        if (!/Unexpected|SyntaxError|ERR_UNSUPPORTED_NODE_MODULES|ERR_UNKNOWN_FILE_EXTENSION|ERR_IMPORT_ATTRIBUTE/.test(String(e)) && process.version.startsWith("v2")) {
+          throw e;
+        }
+        const requireFromConfig = createRequire(configPath);
+        let esbuild;
+        try {
+          esbuild = requireFromConfig("esbuild");
+        } catch {
+          const requireFromSelf = createRequire(import.meta.url);
+          esbuild = requireFromSelf("esbuild");
+        }
+        const out = esbuild.buildSync({ entryPoints: [configPath], bundle: false, write: false, format: "esm", target: "node18" });
+        const jsFile = `${tmpBase}.mjs`;
+        fs2.writeFileSync(jsFile, rewriteSelfImports(out.outputFiles[0].text));
+        mod = await importConfigs(pathToFileURL(jsFile).href);
+      }
+    } else {
+      const jsFile = `${tmpBase}.mjs`;
+      fs2.writeFileSync(jsFile, source);
+      mod = await importConfigs(pathToFileURL(jsFile).href);
+    }
+  }
+  const cfg = mod.default;
+  if (!cfg?.root) {
+    throw new Error(
+      `[fulgur:init] \u914D\u7F6E\u7F3A\u5C11 root\uFF08\u5DE5\u7A0B\u6839\u76EE\u5F55\u7EDD\u5BF9\u8DEF\u5F84\uFF09
+\u6839\u56E0\uFF1ACLI \u9700\u8981\u77E5\u9053\u5728\u54EA\u4E2A\u5DE5\u7A0B\u4E0A\u505A\u96C6\u6210
+\u4FEE\u6CD5\uFF1Afulgur.config.ts \u9876\u5C42\u8865 root: '/abs/path/to/repo'\uFF08\u8D77\u6B65\u6A21\u677F\uFF1Afulgur init\uFF09`
+    );
+  }
+  if (!Array.isArray(cfg.apps) || cfg.apps.length === 0) {
+    throw new Error("[fulgur:init] \u914D\u7F6E\u7F3A\u5C11 apps\uFF08\u81F3\u5C11\u4E00\u4E2A\u5BBF\u4E3B\u6216\u8FDC\u7A0B\u5E94\u7528\uFF09");
+  }
+  for (const app of cfg.apps) {
+    if (!app.host && !app.remote) {
+      throw new Error(
+        `[fulgur:init] \u5E94\u7528 "${app.path}" \u65E2\u65E0 host \u4E5F\u65E0 remote \u89D2\u8272
+\u6839\u56E0\uFF1A\u5E94\u7528\u5FC5\u987B\u81F3\u5C11\u58F0\u660E\u4E00\u4E2A\u89D2\u8272
+\u4FEE\u6CD5\uFF1A\u5BBF\u4E3B\u8865 host: { pages, remotePrefixes, remotes }\uFF0C\u8FDC\u7A0B\u8865 remote: { exposes }`
+      );
+    }
+  }
+  return cfg;
+}
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+  }
+});
+
+// src/init.ts
+var init_exports = {};
+__export(init_exports, {
+  STARTER_CONFIG: () => STARTER_CONFIG,
+  inspectConfig: () => inspectConfig,
+  writeConfigTemplate: () => writeConfigTemplate
+});
+import fs from "node:fs";
+import path from "node:path";
+async function writeConfigTemplate(target, force = false) {
+  if (fs.existsSync(target) && !force) {
+    return "exists";
+  }
+  fs.mkdirSync(path.dirname(path.resolve(target)), { recursive: true });
+  fs.writeFileSync(path.resolve(target), STARTER_CONFIG);
+  return "written";
+}
+function remoteEntriesLiteral(remotes) {
+  return Object.entries(remotes).map(([k, v]) => `    '${k}': { dev: '${v.dev}', prod: '${v.prod}' },`).join("\n");
+}
+function exposesLiteral(exposes) {
+  return Object.entries(exposes).map(([k, v]) => `    '${k}': '${v}',`).join("\n");
+}
+function viteSnippetFor(app) {
+  const hostRemotes = app.host ? remoteEntriesLiteral(app.host.remotes) : "";
+  const remoteRemotes = app.remote?.remotes ? remoteEntriesLiteral(app.remote.remotes) : "";
+  const remotesBlock = hostRemotes || remoteRemotes ? `  remotes: {
+${hostRemotes || remoteRemotes}
+  },
+` : "";
+  const exposesBlock = app.remote?.exposes ? `  exposes: {
+${exposesLiteral(app.remote.exposes)}
+  },
+` : "";
+  const sharedBlock = app.shared ? `  shared: {
+${Object.entries(app.shared).map(([k, v]) => {
+    const opts = [v.singleton ? "singleton: true" : "", v.requiredVersion ? `requiredVersion: '${v.requiredVersion}'` : ""].filter(Boolean);
+    return `    '${k}': { ${opts.join(", ")} },`;
+  }).join("\n")}
+  },
+` : `  ${DEFAULT_SHARED_BLOCK},
+`;
+  return `federation({
+  name: '${app.name}',
+${remotesBlock}${exposesBlock}${sharedBlock}})`;
+}
+function nginxSnippetFor(cfg) {
+  const listen = cfg.deploy?.listen ?? 8080;
+  const webRoot = cfg.deploy?.webRoot ?? "/var/www/your-site";
+  const hostApp = cfg.apps.find((a) => a.host) ?? cfg.apps[0];
+  const hostIndex = `/${hostApp.base.replace(/^\/|\/$/g, "")}/index.html`.replace(/\/{2,}/g, "/");
+  const blocks = cfg.apps.map(
+    (a) => {
+      const b = a.base === "/" || a.base === "" ? "/" : a.base.replace(/\/$/, "");
+      return `  location ${b} {
+    try_files $uri $uri/ ${hostIndex};
+
+    location = ${b}/fulgur-remoteEntry.js {
+      add_header Cache-Control "no-cache";
+      add_header Access-Control-Allow-Origin "*";
+    }
+    location = ${b}/fulgur-manifest.json {
+      add_header Cache-Control "no-cache";
+      add_header Access-Control-Allow-Origin "*";
+    }
+    location = ${b}/index.html {
+      add_header Cache-Control "no-cache";
+    }
+  }`;
+    }
+  ).join("\n\n");
+  return `# \u8054\u90A6\u7AD9\u70B9\u6A21\u677F\uFF08\u8981\u70B9\uFF1AremoteEntry/manifest/index.html \u5FC5\u987B no-cache\u2014\u2014
+# \u6587\u4EF6\u540D\u56FA\u5B9A\u800C\u5185\u5BB9\u6BCF\u6B21\u6784\u5EFA\u53D8\u5316\uFF0Cimmutable \u957F\u7F13\u5B58\u4F1A\u8BA9\u6D4F\u89C8\u5668\u6301\u65E7\u5165\u53E3\u3001\u91CD\u90E8\u7F72\u540E\u5168 404\uFF1B
+# \u5E26 hash \u7684 assets \u624D\u914D\u957F\u7F13\u5B58\uFF1B\u8DE8\u6E90\u90E8\u7F72\u65F6\u4FDD\u7559 Access-Control-Allow-Origin\uFF09
+server {
+  listen ${listen};
+  root ${webRoot};
+
+${blocks}
+}`;
+}
+function appSummary(app) {
+  const role = app.host ? app.remote ? "\u5BBF\u4E3B+\u8FDC\u7A0B" : "\u5BBF\u4E3B" : "\u8FDC\u7A0B";
+  const lines = [];
+  lines.push(`  ${app.name}\uFF08${role}\uFF0C\u76EE\u5F55 ${app.path}\uFF0Cdev \u7AEF\u53E3 ${app.port}\uFF0Cbase ${app.base}\uFF09`);
+  if (app.host) {
+    for (const [k, v] of Object.entries(app.host.remotes)) {
+      lines.push(`    \u6D88\u8D39\u8FDC\u7A0B ${k} \u2192 dev ${v.dev} / prod ${v.prod}`);
+    }
+    lines.push(`    \u9875\u9762\u8DEF\u7531\u8868\uFF1A${app.host.pages.length} \u6761`);
+  }
+  if (app.remote?.exposes) {
+    lines.push(`    exposes\uFF1A${Object.keys(app.remote.exposes).join("\u3001")}`);
+  }
+  if (app.remote?.remotes) {
+    for (const [k, v] of Object.entries(app.remote.remotes)) {
+      lines.push(`    \u53CD\u5411\u6D88\u8D39 ${k} \u2192 dev ${v.dev} / prod ${v.prod}\uFF08\u53CC\u5411\u8054\u90A6\uFF0Cdev \u4E0B\u9700 devSharedSelf: true\uFF09`);
+    }
+  }
+  return lines.join("\n");
+}
+async function inspectConfig(configPath) {
+  const cfg = await loadFulgurConfig(configPath);
+  const out = [];
+  out.push(`${MARK} \u914D\u7F6E\u6821\u9A8C\u901A\u8FC7\uFF1Aroot=${cfg.root}\uFF0Capps=${cfg.apps.length}`);
+  out.push("\u5E94\u7528\u6458\u8981\uFF1A");
+  for (const app of cfg.apps) out.push(appSummary(app));
+  out.push("\n\u2500\u2500 \u5404\u5E94\u7528 vite.config.ts plugins \u7C98\u8D34\u5757 \u2500\u2500");
+  for (const app of cfg.apps) {
+    out.push(`
+# ${app.path}\uFF08${app.name}\uFF09`);
+    out.push(viteSnippetFor(app));
+  }
+  out.push("\n\u2500\u2500 NGINX \u7AD9\u70B9\u6A21\u677F \u2500\u2500");
+  out.push(nginxSnippetFor(cfg));
+  out.push("\n\u2500\u2500 \u63A5\u5165\u6838\u5BF9\u6E05\u5355\uFF08\u8054\u90A6\u901A\u7528\u9879\uFF0C\u4E0E\u5177\u4F53\u9879\u76EE\u65E0\u5173\uFF09 \u2500\u2500");
+  out.push("1. \u5BBF\u4E3B\u4E0E\u8FDC\u7A0B\u90FD\u5B89\u88C5\u4F9D\u8D56\uFF1Apnpm add @fulgurjs/federation");
+  out.push("2. expose \u4E00\u5F8B\u6307\u5411\u72EC\u7ACB\u9875\uFF08\u9875\u9762\u4ECE\u8DEF\u7531\u53D6\u53C2\uFF09\uFF1B\u7EC4\u4EF6\u9700\u8981\u5FC5\u586B props \u65F6\u7ED9\u9ED8\u8BA4\u503C\uFF08BLD-003\uFF09");
+  out.push("3. shared \u91CC vue / vue-router / pinia \u5EFA\u8BAE singleton: true\u2014\u2014\u8DE8\u5E94\u7528\u5FC5\u987B\u540C\u5B9E\u4F8B\uFF08\u5168\u5C40\u54CD\u5E94\u6027\u3001getActivePinia\u3001\u8DEF\u7531\u6CE8\u5165\uFF09");
+  out.push("4. \u8FDC\u7A0B\u7684\u5168\u5C40\u526F\u4F5C\u7528\uFF08\u5168\u5C40\u7EC4\u4EF6/\u6307\u4EE4/\u542F\u52A8\u671F\u521D\u59CB\u5316\uFF09\u5C01\u88C5\u4E3A\u542F\u52A8\u5668\u6A21\u5757\u5E76 expose\uFF0C\u5BBF\u4E3B\u5728 loadRemote \u9875\u9762\u524D\u8C03\u7528\uFF1B");
+  out.push("   \u8DE8\u5E94\u7528\u5168\u5C40\u914D\u7F6E\uFF08locale/size \u7B49\uFF09\u7528\u8FD0\u884C\u65F6 provideFulgurAppConfig / getFulgurAppConfig \u534F\u5546\uFF0C\u4E0D\u8981\u5404\u526F\u672C\u624B\u5DE5\u6CE8\u5165");
+  out.push("5. \u8FDC\u7A0B\u9875\u9762\u53D6\u5BBF\u4E3B\u8FD0\u884C\u65F6\u4E00\u5F8B\u8D70 globalThis.__FULGUR_RUNTIME__ / getRuntime()\uFF0C\u7981\u6B62\u9759\u6001\u5BFC\u5165\u865A\u62DF\u8FD0\u884C\u65F6\uFF08DEV-008\uFF09");
+  out.push('6. dev \u51B7\u542F\u52A8\u9996\u8F6E 30~60s \u6709\u9884\u6784\u5EFA\u7A97\u53E3\uFF08\u77AC\u65F6 504/"ce"\uFF0CDEV-010\uFF09\uFF1A\u5148\u771F\u5B9E\u6253\u5F00\u9875\u9762\u9884\u70ED\u518D\u505A\u65AD\u8A00');
+  out.push("7. \u90E8\u7F72\u540E\u4F53\u68C0\uFF1Afulgur doctor --base <URL> --apps <\u5E94\u7528...>\uFF08\u7F13\u5B58\u5934/\u8D44\u6E90\u5F62\u6001/CORS/chunk \u53EF\u8FBE/\u7248\u672C skew\uFF09");
+  out.push("8. \u90E8\u7F72\u8BED\u4E49\uFF1AremoteEntry/manifest/index.html \u5FC5\u987B no-cache\uFF08\u4E25\u7981 immutable\uFF09\uFF1B\u5E26 hash \u7684 assets \u957F\u7F13\u5B58");
+  return out.join("\n");
+}
+var MARK, STARTER_CONFIG, DEFAULT_SHARED_BLOCK;
+var init_init = __esm({
+  "src/init.ts"() {
+    "use strict";
+    init_config();
+    MARK = "[fulgur:init]";
+    STARTER_CONFIG = `// fulgur.config.ts \u2014\u2014 @fulgurjs/federation \u63A5\u5165\u914D\u7F6E\uFF08\u5355\u6587\u4EF6\u9A71\u52A8\uFF0C\u53EF\u5165\u5E93\u3001\u53EF\u590D\u8DD1\uFF09
+// \u7528\u6CD5\uFF1Anpx fulgur init --config fulgur.config.ts   \u6821\u9A8C\u914D\u7F6E\u5E76\u8F93\u51FA\u53EF\u7C98\u8D34\u6837\u677F\u4E0E\u6838\u5BF9\u6E05\u5355
+//       npx fulgur doctor --base http://<\u7AD9\u70B9> --apps <\u5E94\u7528\u76EE\u5F55\u540D...>   \u90E8\u7F72\u4F53\u68C0
+import { defineFulgurConfig } from '@fulgurjs/federation/config'
+
+export default defineFulgurConfig({
+  // \u5DE5\u7A0B\u6839\u76EE\u5F55\uFF08monorepo \u6839\u6216\u5355\u5E94\u7528\u4ED3\u5E93\u6839\uFF09
+  root: process.cwd(),
+  apps: [
+    // \u2500\u2500 \u5BBF\u4E3B\uFF1A\u6D88\u8D39\u8FDC\u7A0B\u9875\u9762/\u7EC4\u4EF6\uFF08\u4E5F\u53EF\u518D expose \u81EA\u5DF1\u7684\u7EC4\u4EF6\u7ED9\u66F4\u9AD8\u5C42\u6D88\u8D39\uFF09\u2500\u2500
+    {
+      path: 'apps/host',            // \u76F8\u5BF9 root \u7684\u5E94\u7528\u76EE\u5F55
+      name: 'host-app',             // \u8054\u90A6\u5BB9\u5668\u540D\uFF08\u8FDC\u7A0B\u5F15\u7528\u5B83\u65F6\u7528\u8FD9\u4E2A\u540D\uFF09
+      port: 5173,                   // dev \u7AEF\u53E3
+      base: '/',                    // \u90E8\u7F72/dev \u7684 URL \u524D\u7F00
+      host: {
+        // \u8DEF\u7531\u524D\u7F00 \u2192 \u8FDC\u7A0B\u540D\uFF1A\u5BBF\u4E3B\u628A /remote-a/** \u7684\u9875\u9762\u89E3\u6790\u5230\u8FDC\u7A0B remote-a
+        remotePrefixes: { '/remote-a/': 'remote-a' },
+        // \u8FDC\u7A0B\u5730\u5740\uFF1A\u88F8 URL\uFF08\u5BF9\u8C61\u5F62\u5F0F\u4E0D\u652F\u6301 name@ \u524D\u7F00\uFF0C\u89C1\u9519\u8BEF\u7801 CFG-007\uFF09
+        remotes: {
+          'remote-a': { dev: 'http://localhost:5174/remote-a', prod: '/remote-a' },
+        },
+        // \u9875\u9762\u8DEF\u7531\u8868\uFF1A\u5BBF\u4E3B\u8DEF\u5F84 \u2192 \u8FDC\u7A0B exposes \u952E\uFF08\u9ED8\u8BA4\u63A8\u5BFC pages/<\u53BB\u524D\u7F00\u53BB\u53C2\u6570\u6BB5>\uFF1B
+        // \u5E26\u53C2\u8DEF\u7531\u6216\u975E\u9ED8\u8BA4\u952E\u7528 spec \u663E\u5F0F\u8986\u76D6\uFF09
+        pages: [
+          { route: '/remote-a/home', name: 'RemoteAHome', title: '\u9996\u9875' },
+          { route: '/remote-a/detail/:id', name: 'RemoteADetail', spec: 'pages/remote-a/detail', title: '\u8BE6\u60C5' },
+        ],
+      },
+    },
+    // \u2500\u2500 \u8FDC\u7A0B\uFF1Aexpose \u72EC\u7ACB\u9875\uFF08\u9875\u9762\u81EA\u5DF1\u4ECE\u8DEF\u7531\u53D6\u53C2\uFF0C\u4E0D\u4F9D\u8D56\u7236\u7EC4\u4EF6\u4F20\u5FC5\u586B props\uFF0C\u89C1 BLD-003\uFF09\u2500\u2500
+    {
+      path: 'apps/remote-a',
+      name: 'remote-a',
+      port: 5174,
+      base: '/remote-a',
+      remote: {
+        exposes: {
+          './pages/remote-a/home': './src/views/Home.vue',
+          './pages/remote-a/detail': './src/views/Detail.vue',
+        },
+      },
+    },
+  ],
+  // \u90E8\u7F72\u4FE1\u606F\uFF08\u53EF\u9009\uFF09\uFF1A\u4EC5\u4F9B init \u8F93\u51FA NGINX \u6837\u677F\u65F6\u4F7F\u7528
+  deploy: { webRoot: '/var/www/your-site', listen: 8080 },
+})
+`;
+    DEFAULT_SHARED_BLOCK = `shared: {
+          vue: { singleton: true, requiredVersion: '^3.4.0' },
+          'vue-router': { singleton: true, requiredVersion: '^4.4.5' },
+          pinia: { singleton: true, requiredVersion: '^2.1.7' },
+        }`;
+  }
+});
+
+// src/cli.ts
+import { resolve } from "node:path";
+
+// src/doctor.ts
+import http from "node:http";
+import https from "node:https";
+function fetchHeadOrGet(url, method = "GET") {
+  return new Promise((resolve2, reject) => {
+    const mod = url.startsWith("https:") ? https : http;
+    const req = mod.request(url, { method, headers: { accept: "*/*" } }, (res) => {
+      const chunks = [];
+      res.on("data", (c) => {
+        if (chunks.reduce((n, b) => n + b.length, 0) < 2 * 1024 * 1024) chunks.push(c);
+      });
+      res.on(
+        "end",
+        () => resolve2({
+          status: res.statusCode ?? 0,
+          headers: res.headers,
+          body: Buffer.concat(chunks).toString("utf8")
+        })
+      );
+    });
+    req.on("error", reject);
+    req.setTimeout(8e3, () => req.destroy(new Error("timeout after 8000ms")));
+    req.end();
+  });
+}
+function header(res, name) {
+  const v = res.headers[name];
+  return Array.isArray(v) ? v[0] : v;
+}
+async function checkStatus(url, app, item, opts = {}) {
+  let res;
+  try {
+    res = await fetchHeadOrGet(url, opts.method ?? "GET");
+  } catch (e) {
+    return {
+      check: {
+        app,
+        item,
+        level: "FAIL",
+        symptom: `${item} \u4E0D\u53EF\u8FBE\uFF1A${url}\uFF08${String(e.message ?? e)}\uFF09`,
+        cause: "\u9759\u6001\u8D44\u6E90\u672A\u90E8\u7F72\u3001nginx \u7AD9\u70B9\u672A\u8D77\u6216\u8DEF\u5F84\u9519\u4F4D",
+        fix: "\u6838\u5BF9\u90E8\u7F72\u76EE\u5F55\uFF08rsync dist/{app}/\uFF09\u4E0E nginx location \u56DE\u9000\u89C4\u5219\uFF1Bcurl \u8BE5 URL \u786E\u8BA4\u53EF\u8FBE"
+      }
+    };
+  }
+  if (res.status !== 200) {
+    return {
+      check: {
+        app,
+        item,
+        level: "FAIL",
+        symptom: `${item} \u8FD4\u56DE ${res.status}\uFF1A${url}`,
+        cause: "\u6587\u4EF6\u7F3A\u5931\uFF08\u672A\u90E8\u7F72/\u5DF2\u88AB\u6E05\uFF09\u6216 nginx \u56DE\u9000\u5230\u4E86\u5BBF\u4E3B index.html\uFF08\u6DF1\u94FE\u56DE\u9000\u8FC7\u5BBD\uFF09",
+        fix: "\u91CD\u65B0\u90E8\u7F72\u8BE5\u5E94\u7528\u4EA7\u7269\uFF1B\u6838\u5BF9 nginx location \u7CBE\u786E\u5339\u914D remoteEntry \u7684\u89C4\u5219"
+      },
+      res
+    };
+  }
+  if (opts.expectJs) {
+    const head = res.body.slice(0, 200).trimStart();
+    if (head.startsWith("<")) {
+      return {
+        res,
+        check: {
+          app,
+          item,
+          level: "FAIL",
+          symptom: `${item} \u8FD4\u56DE\u7684\u662F HTML \u800C\u975E JS\uFF1A${url}`,
+          cause: "nginx try_files/\u6DF1\u94FE\u56DE\u9000\u628A\u5165\u53E3\u8BF7\u6C42\u515C\u5230\u4E86 index.html\uFF08\u8054\u90A6\u5BBF\u4E3B\u4F1A\u628A\u5B83\u5F53\u6A21\u5757\u89E3\u6790\u76F4\u63A5\u5931\u8D25\uFF09",
+          fix: "\u4E3A remoteEntry/\u5165\u53E3\u589E\u52A0\u7CBE\u786E location \u539F\u6837\u8FD4\u56DE JS"
+        }
+      };
+    }
+  }
+  if (opts.expectNoCache) {
+    const cc = header(res, "cache-control") ?? "";
+    if (/immutable/i.test(cc)) {
+      return {
+        res,
+        check: {
+          app,
+          item,
+          level: "FAIL",
+          symptom: `${item} \u7684 Cache-Control=${cc}\uFF08immutable\uFF09\uFF1A${url}`,
+          cause: "\u6587\u4EF6\u540D\u56FA\u5B9A\u800C\u5185\u5BB9\u6BCF\u6B21\u6784\u5EFA\u53D8\u5316\u2014\u2014\u6D4F\u89C8\u5668\u4F1A\u957F\u671F\u6301\u6709\u65E7\u7248\u672C\uFF0C\u91CD\u90E8\u7F72\u540E\u65E7 hash chunk \u88AB\u6E05\u7406\u5373\u5168 404\uFF082026-09-17 \u7528\u6237\u5B9E\u6D4B\u8E29\u5751\uFF09",
+          fix: 'nginx \u6539\u4E3A Cache-Control "no-cache"\uFF08\u534F\u5546\u7F13\u5B58\uFF09\uFF1B\u5E26 hash \u7684 assets \u624D\u914D\u957F\u7F13\u5B58'
+        }
+      };
+    }
+    if (!/no-cache|max-age=0/i.test(cc) && !/no-store/i.test(cc)) {
+      return {
+        res,
+        check: {
+          app,
+          item,
+          level: "WARN",
+          symptom: `${item} \u7F3A\u5C11 no-cache \u7F13\u5B58\u5934\uFF08Cache-Control=${cc || "\u65E0"}\uFF09\uFF1A${url}`,
+          cause: "\u6D4F\u89C8\u5668/\u4E2D\u95F4\u5C42\u53EF\u80FD\u6301\u6709\u65E7\u7248\u672C\uFF0C\u91CD\u90E8\u7F72\u540E\u884C\u4E3A\u4E0D\u53EF\u9884\u671F",
+          fix: 'nginx \u4E3A remoteEntry/manifest/index.html \u663E\u5F0F add_header Cache-Control "no-cache"'
+        }
+      };
+    }
+  }
+  return { res };
+}
+function extractChunkRefs(...sources) {
+  const refs = /* @__PURE__ */ new Set();
+  const add = (raw) => refs.add(raw.replace(/^\.\//, ""));
+  for (const body of sources) {
+    if (!body) continue;
+    for (const m of body.matchAll(/\.\/([\w./-]+\.js)/g)) add(m[1]);
+    for (const m of body.matchAll(/"([\w./-]+\.js)"/g)) add(m[1]);
+    for (const m of body.matchAll(/(?:src|href)="([\w./-]+\.js)"/g)) add(m[1]);
+  }
+  return [...refs];
+}
+function compareSharedVersions(perAppShared) {
+  const out = [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const { app, shared } of perAppShared) {
+    for (const s of shared ?? []) {
+      if (!byKey.has(s.name)) byKey.set(s.name, /* @__PURE__ */ new Map());
+      const byVer = byKey.get(s.name);
+      if (!byVer.has(s.version)) byVer.set(s.version, /* @__PURE__ */ new Set());
+      byVer.get(s.version).add(app);
+    }
+  }
+  for (const [key, byVer] of byKey) {
+    if (byVer.size <= 1) continue;
+    const dist = [...byVer.entries()].map(([v, apps]) => `${v}(${[...apps].join("/")})`).join(" vs ");
+    out.push({
+      app: "*",
+      item: `shared \u7248\u672C skew\uFF1A${key}`,
+      level: "WARN",
+      symptom: `\u5171\u4EAB\u952E "${key}" \u5728\u591A\u5E94\u7528\u95F4\u7248\u672C\u4E0D\u4E00\u81F4\uFF1A${dist}`,
+      cause: "\u975E singleton \u65F6\u9875\u9762\u5C06\u6309\u6700\u9AD8\u7248\u672C\u534F\u5546\uFF08\u5404\u5E94\u7528\u62FF\u5230\u7684\u5B9E\u4F8B\u53EF\u80FD\u4E0D\u540C\uFF09\uFF1Bsingleton \u65F6\u5168\u90E8\u6536\u655B\u5230\u5DF2\u52A0\u8F7D\u5B9E\u4F8B\u2014\u2014\u884C\u4E3A\u9700\u8981\u88AB\u77E5\u6653\u800C\u4E0D\u662F\u649E\u4E0A",
+      fix: "\u7EDF\u4E00\u5404\u5E94\u7528\u4F9D\u8D56\u7248\u672C\uFF1Bsingleton \u573A\u666F\u786E\u8BA4 skew \u544A\u8B66\uFF08MFU-010\uFF09\u53EF\u63A5\u53D7"
+    });
+  }
+  return out;
+}
+async function runDoctor(opts) {
+  const checks = [];
+  const perAppShared = [];
+  const chunkSample = opts.chunkSample ?? 16;
+  for (const app of opts.apps) {
+    const root = `${opts.base.replace(/\/$/, "")}/${app.replace(/^\//, "")}`;
+    const entry = await checkStatus(`${root}/fulgur-remoteEntry.js`, app, "fulgur-remoteEntry.js", {
+      expectJs: true,
+      expectNoCache: !opts.dev
+    });
+    if (entry.check) checks.push(entry.check);
+    if (entry.res && !opts.dev) {
+      const acao = header(entry.res, "access-control-allow-origin");
+      checks.push({
+        app,
+        item: "remoteEntry CORS",
+        level: acao ? "PASS" : "WARN",
+        symptom: acao ? `Access-Control-Allow-Origin: ${acao}` : "remoteEntry \u672A\u5E26 Access-Control-Allow-Origin",
+        cause: acao ? void 0 : "\u8DE8\u6E90\u8054\u90A6\uFF08dev \u53CC\u7AEF\u53E3/\u5F02\u57DF\u90E8\u7F72\uFF09\u4F1A\u88AB CORS \u62E6\u622A\uFF1B\u540C\u6E90\u90E8\u7F72\u4E0D\u53D7\u5F71\u54CD",
+        fix: acao ? void 0 : 'nginx \u5BF9 remoteEntry add_header Access-Control-Allow-Origin "*"'
+      });
+    }
+    const manifestRes = await checkStatus(`${root}/fulgur-manifest.json`, app, "fulgur-manifest.json", {
+      expectNoCache: !opts.dev
+    });
+    if (manifestRes.check) checks.push(manifestRes.check);
+    let manifest;
+    if (manifestRes.res?.status === 200) {
+      try {
+        manifest = JSON.parse(manifestRes.res.body);
+        perAppShared.push({ app, shared: manifest.shared ?? [] });
+      } catch {
+        checks.push({
+          app,
+          item: "manifest \u89E3\u6790",
+          level: "FAIL",
+          symptom: "fulgur-manifest.json \u4E0D\u662F\u5408\u6CD5 JSON",
+          cause: "\u4EA7\u7269\u4E0D\u5B8C\u6574\u6216\u88AB\u4E2D\u95F4\u5C42\u6539\u5199",
+          fix: "\u91CD\u65B0\u6784\u5EFA\u90E8\u7F72\uFF1B\u786E\u8BA4 nginx \u672A\u5BF9\u8BE5\u8DEF\u5F84\u505A sub/\u62FC\u63A5\u6539\u5199"
+        });
+      }
+    }
+    let htmlBody = "";
+    if (!opts.dev) {
+      const html = await checkStatus(`${root}/index.html`, app, "index.html", { expectNoCache: true });
+      if (html.check) checks.push(html.check);
+      htmlBody = html.res?.body ?? "";
+    }
+    if (opts.dev) {
+      const devEntry = await checkStatus(`${root}/@fulgur-entry.js`, app, "@fulgur-entry.js\uFF08dev \u5BB9\u5668\u5165\u53E3\uFF09", {
+        expectJs: true
+      });
+      if (devEntry.check) checks.push(devEntry.check);
+    }
+    if (!opts.dev && manifest) {
+      const manifestRefs = [];
+      const exposes = manifest.exposes ?? {};
+      for (const key of Object.keys(exposes)) {
+        const f = exposes[key]?.file;
+        if (f) manifestRefs.push(String(f).replace(/^\.\//, ""));
+      }
+      const htmlRefs = extractChunkRefs(htmlBody);
+      const entryRefs = extractChunkRefs(entry.res?.body ?? "");
+      const refs = [.../* @__PURE__ */ new Set([...htmlRefs, ...manifestRefs, ...entryRefs])];
+      const resolveUrl = (ref) => {
+        if (/^(https?:)?\/\//.test(ref)) return ref;
+        if (ref.startsWith("/")) return new URL(ref, opts.base).href;
+        return `${root}/${ref}`;
+      };
+      const maskedByFallback = (body) => body.trimStart().startsWith("<");
+      for (const ref of refs.slice(0, chunkSample)) {
+        const url = resolveUrl(ref);
+        try {
+          const r = await fetchHeadOrGet(url, "GET");
+          if (r.status !== 200) {
+            checks.push({
+              app,
+              item: `chunk \u53EF\u8FBE\uFF1A${ref}`,
+              level: "FAIL",
+              symptom: `\u5165\u53E3/manifest \u5F15\u7528\u7684 chunk \u8FD4\u56DE ${r.status}\uFF1A${url}`,
+              cause: "\u4EA7\u7269\u4E0D\u5B8C\u6574\u6216\u90E8\u7F72\u540E partial \u6E05\u7406\u2014\u2014\u6D4F\u89C8\u5668\u6301\u65E7 remoteEntry \u65F6\u5178\u578B\u75C7\u72B6\uFF08immutable \u5751\uFF09",
+              fix: "\u91CD\u65B0\u5B8C\u6574\u90E8\u7F72\u8BE5\u5E94\u7528\uFF08rsync -a --delete dist/<app>/\uFF09\uFF1B\u786E\u8BA4\u7F13\u5B58\u5934\u4E3A no-cache"
+            });
+          } else if (maskedByFallback(r.body)) {
+            checks.push({
+              app,
+              item: `chunk \u53EF\u8FBE\uFF1A${ref}`,
+              level: "FAIL",
+              symptom: `chunk \u8BF7\u6C42\u8FD4\u56DE 200 \u4F46\u5185\u5BB9\u662F HTML\uFF08nginx \u6DF1\u94FE\u56DE\u9000\u63A9\u76D6\u4E86\u8D44\u6E90\u7F3A\u5931\uFF09\uFF1A${url}`,
+              cause: "try_files \u56DE\u9000\u8FC7\u5BBD\uFF1A\u7F3A\u5931\u7684\u9759\u6001\u8D44\u6E90\u88AB\u515C\u5230\u5BBF\u4E3B index.html\uFF0C\u6D4F\u89C8\u5668\u628A\u5B83\u5F53\u6A21\u5757\u89E3\u6790\u76F4\u63A5\u62A5\u9519",
+              fix: "\u4E3A\u9759\u6001 assets \u76EE\u5F55\u589E\u52A0\u7CBE\u786E\u5339\u914D\uFF08try_files $uri =404 \u6216\u72EC\u7ACB location\uFF09\uFF0C\u907F\u514D JS \u8BF7\u6C42\u88AB\u56DE\u9000\u6210 HTML"
+            });
+          } else {
+            for (const sub of extractChunkRefs(r.body)) if (!refs.includes(sub)) refs.push(sub);
+          }
+        } catch (e) {
+          checks.push({
+            app,
+            item: `chunk \u53EF\u8FBE\uFF1A${ref}`,
+            level: "FAIL",
+            symptom: `chunk \u8BF7\u6C42\u5931\u8D25\uFF1A${url}\uFF08${String(e.message ?? e)}\uFF09`,
+            cause: "\u7F51\u7EDC/\u90E8\u7F72\u9762\u5F02\u5E38",
+            fix: "curl \u590D\u6838\u8BE5 URL\uFF1B\u6838\u5BF9\u90E8\u7F72\u5B8C\u6574\u6027"
+          });
+        }
+      }
+      for (const ref of refs.slice(chunkSample, chunkSample * 4)) {
+        const url = resolveUrl(ref);
+        try {
+          const r = await fetchHeadOrGet(url, "HEAD");
+          if (r.status !== 200 && r.status !== 404) {
+            checks.push({
+              app,
+              item: `chunk \u53EF\u8FBE\uFF1A${ref}`,
+              level: "FAIL",
+              symptom: `chunk \u5F15\u7528\u8FD4\u56DE ${r.status}\uFF1A${url}`,
+              cause: "\u4EA7\u7269\u4E0D\u5B8C\u6574\u6216\u90E8\u7F72\u540E partial \u6E05\u7406",
+              fix: "\u91CD\u65B0\u5B8C\u6574\u90E8\u7F72\u8BE5\u5E94\u7528\uFF08rsync -a --delete dist/<app>/\uFF09"
+            });
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  checks.push(...compareSharedVersions(perAppShared));
+  return { checks, failed: checks.some((c) => c.level === "FAIL") };
+}
+function formatDoctorReport(checks) {
+  const lines = [];
+  for (const c of checks) {
+    const head = `[fulgur:doctor] ${c.level} [${c.app}] ${c.item}`;
+    lines.push(c.level === "PASS" ? `${head} \u2014 ${c.symptom}` : `${head}
+  \u73B0\u8C61\uFF1A${c.symptom}`);
+    if (c.cause) lines.push(`  \u6839\u56E0\uFF1A${c.cause}`);
+    if (c.fix) lines.push(`  \u4FEE\u6CD5\uFF1A${c.fix}`);
+  }
+  const fail = checks.filter((c) => c.level === "FAIL").length;
+  const warn = checks.filter((c) => c.level === "WARN").length;
+  const pass = checks.filter((c) => c.level === "PASS").length;
+  lines.push(`[fulgur:doctor] \u6C47\u603B\uFF1A${pass} PASS / ${warn} WARN / ${fail} FAIL`);
+  return lines.join("\n");
+}
+
+// src/cli.ts
+var HELP = `fulgur \u2014 Vite Module Federation CLI (@fulgurjs/federation)
+
+\u7528\u6CD5\uFF1A
+  fulgur init [--template <path>] [--force]      \u751F\u6210\u5E26\u6CE8\u91CA\u7684 fulgur.config.ts \u8D77\u6B65\u6A21\u677F
+  fulgur init --config <path>                    \u6821\u9A8C\u914D\u7F6E\uFF1B\u8F93\u51FA\u5404\u5E94\u7528 federation() \u7C98\u8D34\u5757\u3001
+                                                 NGINX no-cache \u7AD9\u70B9\u6A21\u677F\u4E0E\u63A5\u5165\u6838\u5BF9\u6E05\u5355
+  fulgur doctor --base <URL> --apps <a,b,c> [--dev] [--json] [--chunk-sample N]
+  fulgur --help
+
+\u793A\u4F8B\uFF1A
+  fulgur init                                    # \u5F53\u524D\u76EE\u5F55\u5199 fulgur.config.ts\uFF08\u5DF2\u5B58\u5728\u5219\u62D2\u7EDD\uFF0C--force \u8986\u76D6\uFF09
+  fulgur init --config fulgur.config.ts          # \u6821\u9A8C + \u8F93\u51FA\u6837\u677F
+  fulgur doctor --base http://your-site --apps app-a,app-b
+  fulgur doctor --base http://localhost:5173 --apps app-a --dev
+`;
+async function main() {
+  const argv = process.argv.slice(2);
+  const cmd = argv[0];
+  if (!cmd || cmd === "--help" || cmd === "-h" || cmd === "help") {
+    console.log(HELP);
+    return 0;
+  }
+  const argOf = (k) => {
+    const i = argv.indexOf(k);
+    return i > -1 ? argv[i + 1] : void 0;
+  };
+  const has = (k) => argv.includes(k);
+  if (cmd === "init") {
+    const { writeConfigTemplate: writeConfigTemplate2, inspectConfig: inspectConfig2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+    const configPath = argOf("--config");
+    if (configPath) {
+      try {
+        console.log(await inspectConfig2(resolve(configPath)));
+        return 0;
+      } catch (e) {
+        console.error(String(e.message ?? e));
+        return 2;
+      }
+    }
+    const target = resolve(argOf("--template") ?? "fulgur.config.ts");
+    const result = await writeConfigTemplate2(target, has("--force"));
+    if (result === "exists") {
+      console.error(`[fulgur:init] ${target} \u5DF2\u5B58\u5728\uFF0C\u62D2\u7EDD\u8986\u76D6\uFF08--force \u5F3A\u5236\u8986\u76D6\uFF09`);
+      return 2;
+    }
+    console.log(`[fulgur:init] \u5DF2\u751F\u6210\u8D77\u6B65\u6A21\u677F ${target}
+\u540E\u7EED\u6B65\u9AA4\uFF1A
+  1. \u7F16\u8F91 fulgur.config.ts\uFF1A\u586B\u5165\u4F60\u7684\u5E94\u7528\u76EE\u5F55/\u5BB9\u5668\u540D/\u7AEF\u53E3/base/\u9875\u9762\u8DEF\u7531\u8868/exposes
+  2. npx fulgur init --config fulgur.config.ts   # \u6821\u9A8C\u5E76\u8F93\u51FA\u53EF\u7C98\u8D34\u6837\u677F\u4E0E\u6838\u5BF9\u6E05\u5355
+  3. \u6309\u6E05\u5355\u628A federation() \u5757\u63A5\u5165\u5404\u5E94\u7528 vite.config.ts\uFF0C\u5B89\u88C5\u4F9D\u8D56
+  4. \u90E8\u7F72\u540E\uFF1Anpx fulgur doctor --base <URL> --apps <\u5E94\u7528...>`);
+    return 0;
+  }
+  if (cmd === "doctor") {
+    const base = argOf("--base");
+    const appsRaw = argOf("--apps") ?? "main";
+    if (!base) {
+      console.error("[fulgur:doctor] \u7F3A\u5C11 --base <URL>\uFF08\u7AD9\u70B9\u6839\u5730\u5740\uFF0C\u5982 http://your-site\uFF09");
+      return 2;
+    }
+    const apps = appsRaw.split(",").map((s) => s.trim()).filter(Boolean);
+    const { checks, failed } = await runDoctor({
+      base,
+      apps,
+      dev: has("--dev"),
+      chunkSample: argOf("--chunk-sample") ? Number(argOf("--chunk-sample")) : void 0
+    });
+    if (has("--json")) {
+      console.log(JSON.stringify({ base, apps, dev: has("--dev"), checks, failed }, null, 2));
+    } else {
+      console.log(formatDoctorReport(checks));
+    }
+    return failed ? 1 : 0;
+  }
+  console.error(`\u672A\u77E5\u547D\u4EE4\uFF1A${cmd}
+${HELP}`);
+  return 2;
+}
+main().then(
+  (code) => process.exit(code),
+  (e) => {
+    console.error("[fulgur] \u6267\u884C\u5931\u8D25\uFF1A", e);
+    process.exit(2);
+  }
+);