@fulgurjs/federation 0.4.2

package/dist/index.cjs

@@ -0,0 +1,1698 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  federation: () => federation
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_module2 = require("module");
+
+// src/options.ts
+var import_node_module = require("module");
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+
+// src/version.ts
+var RUNTIME_VERSION = "0.4.2";
+
+// src/options.ts
+var DEFAULT_FILENAME = "fulgur-remoteEntry.js";
+var RUNTIME_VIRTUAL_ID = "virtual:fulgur-runtime";
+var RUNTIME_PROXY_VIRTUAL_ID = "virtual:fulgur-runtime-proxy";
+var INIT_VIRTUAL_ID = "virtual:fulgur-init";
+var SHARED_FACADE_PREFIX = "virtual:fulgur-shared:";
+var SHARED_NS_FACADE_PREFIX = "virtual:fulgur-shared-ns:";
+var RESOLVED = {
+  runtime: "virtual:fulgur-runtime",
+  runtimeProxy: "virtual:fulgur-runtime-proxy",
+  init: "virtual:fulgur-init",
+  provides: "virtual:fulgur-provides",
+  remoteEntry: "virtual:fulgur-remote-entry",
+  sharedFacade: (name) => `virtual:fulgur-shared:${name}`,
+  sharedNsFacade: (name) => `virtual:fulgur-shared-ns:${name}`,
+  /** CJS require(<shared>) 垫片：与 sharedNsFacade 同体，仅 id 形态不同（保持 require 调用语义） */
+  cjsNsFacade: (name) => `virtual:fulgur-cjs-ns:${name}`
+};
+function joinUrl(base, file) {
+  const b = base.endsWith("/") ? base : `${base}/`;
+  return `${b}${file.replace(/^\//, "")}`;
+}
+function normalizeRemoteValue(key, value, filename, warnings) {
+  if (typeof value === "function") {
+    warnings.push(
+      `remotes["${key}"] is a function (promise-based remote): it cannot be serialized into the bundle; register it at runtime via registerRemote() (same semantics as webpack "promise new Promise"). The key stays in config for import-syntax rewriting.`
+    );
+    return {
+      key,
+      name: key,
+      shareScope: "default",
+      devEntry: "",
+      prodEntry: "",
+      promise: true
+    };
+  }
+  const cfg = typeof value === "string" ? { external: value } : value;
+  let raw = cfg.external ?? "";
+  let selfName = key;
+  if (raw) {
+    const at = raw.indexOf("@");
+    if (at > 0 && at < raw.length - 1 && !/^https?:$/.test(raw.slice(0, at))) {
+      selfName = raw.slice(0, at);
+      raw = raw.slice(at + 1);
+    } else if (at === 0 || at === raw.length - 1) {
+      throw new Error(`Invalid remote request "${raw}" for "${key}": misplaced "@".`);
+    }
+  }
+  const resolveEntry = (rawUrl, mode) => {
+    if (!rawUrl) return "";
+    if (/\.js(\?.*)?$/.test(rawUrl)) {
+      if (mode === "prod") return rawUrl;
+      return rawUrl;
+    }
+    return joinUrl(rawUrl, mode === "dev" ? "@fulgur-entry.js" : filename);
+  };
+  const explicitDev = cfg.dev;
+  const explicitProd = cfg.prod;
+  return {
+    key,
+    name: selfName,
+    shareScope: cfg.shareScope || "default",
+    devEntry: resolveEntry(explicitDev || raw, "dev"),
+    prodEntry: resolveEntry(explicitProd || raw, "prod"),
+    timeout: cfg.timeout,
+    retries: cfg.retries,
+    fallback: cfg.fallback,
+    breaker: cfg.breaker
+  };
+}
+function readPkgDependencies(root) {
+  try {
+    const pkgPath = import_node_path.default.join(root, "package.json");
+    const pkg = JSON.parse(import_node_fs.default.readFileSync(pkgPath, "utf8"));
+    return {
+      ...pkg.dependencies ?? {},
+      ...pkg.optionalDependencies ?? {},
+      ...pkg.peerDependencies ?? {},
+      ...pkg.devDependencies ?? {}
+    };
+  } catch {
+    return {};
+  }
+}
+function readInstalledVersion(root, specifier) {
+  try {
+    const req = (0, import_node_module.createRequire)(import_node_path.default.join(root, "package.json"));
+    const pkgJsonPath = req.resolve(`${specifier}/package.json`, { paths: [root] });
+    const pkg = JSON.parse(import_node_fs.default.readFileSync(pkgJsonPath, "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeShared(shared, shareScopeDefault, pkgDependencies, root, warnings) {
+  if (!shared) return [];
+  const entries = [];
+  if (Array.isArray(shared)) {
+    for (const item of shared) entries.push([item, {}]);
+  } else {
+    for (const [key, val] of Object.entries(shared)) {
+      entries.push([key, typeof val === "string" ? { requiredVersion: val } : val ?? {}]);
+    }
+  }
+  const out = [];
+  for (const [configKey, hint] of entries) {
+    if (hint.eager && hint.import === false) {
+      configError(
+        `CFG-008: shared["${configKey}"] combines eager with import:false`,
+        hint,
+        "eager requires a local copy to bundle into the initial chunk",
+        `shared: { '${configKey}': { eager: true } }  // or drop eager: { '${configKey}': { import: false } }`
+      );
+    }
+    const canonical = configKey.endsWith("/") ? configKey.slice(0, -1) : configKey;
+    const importSpec = hint.import === void 0 ? canonical : hint.import;
+    const lookupName = hint.packageName || canonical;
+    const shareScopeOfHint = hint.shareScope || shareScopeDefault;
+    const shareKeyOfHint = hint.shareKey || canonical;
+    const dup = out.find((s) => s.shareKey === shareKeyOfHint && s.shareScope === shareScopeOfHint);
+    if (dup) {
+      configError(
+        `CFG-008: shared key "${shareKeyOfHint}" is declared twice in share scope "${shareScopeOfHint}" (keys "${dup.configKey}" and "${configKey}")`,
+        configKey,
+        "one declaration per shareKey per share scope",
+        `merge hints: { '${shareKeyOfHint}': { singleton: true } }  // or use distinct shareKey values`
+      );
+    }
+    let requiredVersion;
+    if (hint.requiredVersion !== void 0) {
+      requiredVersion = hint.requiredVersion;
+    } else if (typeof hint.import === "string" && hint.import !== canonical) {
+      requiredVersion = false;
+    } else {
+      const depRange = pkgDependencies[lookupName];
+      if (depRange) {
+        requiredVersion = depRange;
+      } else {
+        requiredVersion = false;
+        warnings.push(
+          `shared["${configKey}"]: requiredVersion could not be inferred from package.json; accepting any version.`
+        );
+      }
+    }
+    const singleton = hint.singleton ?? false;
+    const strictVersion = hint.strictVersion ?? (importSpec !== false && !singleton);
+    let version = hint.version ?? "";
+    if (!version) {
+      const installed = readInstalledVersion(root, importSpec === false ? canonical : importSpec);
+      if (installed) {
+        version = installed;
+      } else {
+        version = "0.0.0";
+        warnings.push(
+          `shared["${configKey}"]: installed version not found; registering as 0.0.0 (it will still be consumable but ranked lowest).`
+        );
+      }
+    }
+    const extraAliases = canonical === "vue" || hint.shareKey === "vue" || hint.packageName === "vue" ? ["vue-demi"] : [];
+    out.push({
+      configKey,
+      shareKey: hint.shareKey || canonical,
+      import: importSpec,
+      requiredVersion,
+      singleton,
+      strictVersion,
+      shareScope: hint.shareScope || shareScopeDefault,
+      eager: hint.eager ?? false,
+      version,
+      aliases: [
+        .../* @__PURE__ */ new Set([
+          canonical,
+          ...typeof importSpec === "string" ? [importSpec] : [],
+          ...hint.packageName ? [hint.packageName] : [],
+          ...extraAliases
+        ])
+      ]
+    });
+  }
+  return out;
+}
+function configError(what, got, expect, example) {
+  const gotText = typeof got === "string" ? `"${got}"` : JSON.stringify(got);
+  throw new Error(
+    [
+      `[fulgur] Invalid federation() config \u2014 ${what}`,
+      `  got:      ${gotText}`,
+      `  expected: ${expect}`,
+      `  example:  ${example}`
+    ].join("\n")
+  );
+}
+function validateOptions(options) {
+  if (options.name === void 0 || options.name === null || options.name === "") {
+    configError(
+      "`name` is required (container name, also used as uniqueName)",
+      options.name,
+      "a non-empty string unique among host/remotes in the same page",
+      `federation({ name: 'my-app', ... })`
+    );
+  }
+  if (typeof options.name !== "string" || !/^[a-zA-Z][\w.-]*$/.test(options.name)) {
+    configError(
+      "`name` must match /^[a-zA-Z][\\w.-]*$/ (letters first, no spaces/slashes)",
+      options.name,
+      'e.g. "my-app", "host-app"',
+      `federation({ name: 'my-app', ... })`
+    );
+  }
+  if (options.exposes !== void 0 && typeof options.exposes !== "object") {
+    configError("`exposes` must be an object", options.exposes, 'an object of { "./Module": "./src/path" }', `exposes: { './Button': './src/Button.vue' }`);
+  }
+  if (options.remotes !== void 0 && typeof options.remotes !== "object") {
+    configError("`remotes` must be an object", options.remotes, "an object of { name: url | { dev, prod } | () => Promise<container> }", `remotes: { 'remote-a': 'http://localhost:5101' }`);
+  }
+  if (options.shared !== void 0 && typeof options.shared !== "object") {
+    configError("`shared` must be an array or an object", options.shared, '["vue"] or { vue: { singleton: true } }', `shared: { vue: { singleton: true } }`);
+  }
+  for (const [key, val] of Object.entries(options.exposes ?? {})) {
+    const importPath = typeof val === "string" ? val : val?.import;
+    if (!importPath || typeof importPath !== "string") {
+      configError(
+        `exposes["${key}"].import is missing`,
+        val,
+        'a source path string, or { import: "./src/path" }',
+        `exposes: { '${key.startsWith("./") ? key : "./" + key}': './src/views/Home.vue' }`
+      );
+    }
+  }
+  for (const [key, val] of Object.entries(options.remotes ?? {})) {
+    if (/[/@\s]/.test(key)) {
+      configError(
+        `remotes key "${key}" contains invalid characters (@, / or whitespace)`,
+        key,
+        'a bare module-style name used as import prefix, e.g. "remote-a"',
+        `remotes: { 'remote-a': '...' }  // then: import X from 'remote-a/Button'`
+      );
+    }
+    if (typeof val === "function") continue;
+    const cfg = typeof val === "string" ? { external: val } : val;
+    if (typeof val === "string" && val.trim() === "") {
+      configError(`remotes["${key}"] is an empty string`, val, "a remote base URL or full entry URL", `remotes: { '${key}': 'http://localhost:5101' }`);
+    }
+    if (typeof val !== "string" && typeof cfg !== "object") {
+      configError(`remotes["${key}"] has unsupported type`, val, "string | { dev?, prod?, external? } | () => Promise<container>", `remotes: { '${key}': { dev: 'http://localhost:5101', prod: '/remote-a' } }`);
+    }
+    if (!cfg?.external && !cfg?.dev && !cfg?.prod) {
+      configError(
+        `remotes["${key}"] has no address (need one of external / dev / prod)`,
+        val,
+        "at least one address; with only one URL it is used for both dev and prod",
+        `remotes: { '${key}': 'http://localhost:5101' }
+  // or split: { '${key}': { dev: 'http://localhost:5101', prod: '/${key}' } }`
+      );
+    }
+    for (const slot of ["dev", "prod", "external"]) {
+      const v = cfg[slot];
+      if (v !== void 0 && typeof v !== "string") {
+        configError(`remotes["${key}"].${slot} must be a string`, v, "a URL string", `remotes: { '${key}': { ${slot}: 'http://localhost:5101' } }`);
+      }
+      if (slot !== "external") {
+        const slotUrl = cfg[slot];
+        if (typeof slotUrl === "string" && /^[A-Za-z][\w.-]*@/.test(slotUrl)) {
+          configError(
+            `CFG-007: remotes["${key}"].${slot} uses the "name@url" prefix, which the object form does not support (it is concatenated verbatim into a broken URL)`,
+            slotUrl,
+            "a bare URL (the remote self-name defaults to the key), or the plain string form if renaming is needed",
+            `remotes: { '${key}': 'http://localhost:5101' }  // or: remotes: { '${key}': { dev: 'http://localhost:5101', prod: '/${key}' } }`
+          );
+        }
+      }
+    }
+  }
+}
+function normalizeOptions(options, root, command) {
+  const warnings = [];
+  validateOptions(options);
+  if (!options.name) throw new Error("[fulgur] option `name` is required.");
+  if (options.remoteType && options.remoteType !== "module") {
+    warnings.push(
+      `remoteType "${options.remoteType}" requires webpack-host interop (P3 milestone); falling back to "module".`
+    );
+  }
+  if (options.library?.type && options.library.type !== "module" && options.library.type !== "esm") {
+    warnings.push(
+      `library.type "${options.library.type}" requires webpack-host interop (P3 milestone); falling back to "module".`
+    );
+  }
+  if (options.automaticAsyncBoundary === false) {
+    warnings.push(
+      "automaticAsyncBoundary=false has no effect: fulgur uses TLA-based automatic async boundaries (better than webpack manual bootstrap)."
+    );
+  }
+  const exposes = [];
+  for (const [rawName, val] of Object.entries(options.exposes ?? {})) {
+    const name = rawName.startsWith("./") ? rawName : `./${rawName}`;
+    if (rawName !== name) warnings.push(`exposes key "${rawName}" normalized to "${name}".`);
+    const hint = typeof val === "string" ? { import: val } : val;
+    exposes.push({ name, import: hint.import, chunkName: hint.name });
+  }
+  const shareScopeDefault = options.shareScope || "default";
+  const filename = options.filename || DEFAULT_FILENAME;
+  const pkgDependencies = readPkgDependencies(root);
+  const shared = normalizeShared(options.shared, shareScopeDefault, pkgDependencies, root, warnings);
+  const remotes = [];
+  for (const [key, value] of Object.entries(options.remotes ?? {})) {
+    remotes.push(normalizeRemoteValue(key, value, filename, warnings));
+  }
+  const seenNames = /* @__PURE__ */ new Map();
+  for (const r of remotes) {
+    if (seenNames.has(r.name) && seenNames.get(r.name) !== r.key) {
+      warnings.push(`remote name "${r.name}" is declared for multiple keys; names must be unique.`);
+    }
+    seenNames.set(r.name, r.key);
+  }
+  if ((options.exposes === void 0 || Object.keys(options.exposes).length === 0) && (options.remotes === void 0 || Object.keys(options.remotes).length === 0)) {
+    warnings.push(
+      'federation() has neither `exposes` nor `remotes` \u2014 it only sets up shared modules. If you intended a remote, add `exposes: { "./Module": "./src/path" }`; if a host, add `remotes: { ... }`.'
+    );
+  }
+  if (Object.keys(options.exposes ?? {}).length === 0 && Object.keys(options.remotes ?? {}).length > 0) {
+    warnings.push(
+      `federation({ name: "${options.name}" }) consumes remotes but exposes nothing \u2014 this app is a pure host. Files will not be available to other apps; add \`exposes\` if that is unintended.`
+    );
+  }
+  return {
+    name: options.name,
+    uniqueName: options.name,
+    filename,
+    exposes,
+    remotes,
+    shared,
+    shareScope: shareScopeDefault,
+    remoteType: "module",
+    runtime: options.runtime,
+    runtimeChunk: options.runtimeChunk,
+    manifest: options.manifest === void 0 ? true : !!options.manifest,
+    runtimePlugins: options.runtimePlugins ?? [],
+    dts: options.dts === void 0 ? true : options.dts,
+    root,
+    pluginVersion: RUNTIME_VERSION,
+    pkgDependencies,
+    warnings,
+    // dev 改写开关：默认纯 remote 参与 shared 协商，宿主（有 remotes）不参与；可显式覆盖
+    devSharedSelf: options.devSharedSelf ?? remotes.length === 0
+  };
+}
+
+// src/transform.ts
+var import_es_module_lexer = require("es-module-lexer");
+var import_magic_string = __toESM(require("magic-string"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var lexerReady = null;
+function ensureLexer() {
+  lexerReady ??= import_es_module_lexer.init;
+  return lexerReady;
+}
+function isExposeTargetFile(cleanPath, root, exposes) {
+  for (const e of exposes) {
+    const abs = import_node_path2.default.resolve(root, e.import.replace(/^\.\//, ""));
+    if (cleanPath === abs) return true;
+    for (const ext of [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".vue"]) {
+      if (cleanPath === abs + ext) return true;
+    }
+  }
+  return false;
+}
+function buildSharedMatcher(shared) {
+  const exact = /* @__PURE__ */ new Map();
+  const prefixes = [];
+  for (const s of shared) {
+    for (const alias of s.aliases) {
+      if (!exact.has(alias)) exact.set(alias, s);
+    }
+    if (s.configKey.endsWith("/")) prefixes.push({ prefix: s.configKey, item: s });
+  }
+  return { exact, prefixes };
+}
+function matchShared(spec, matcher) {
+  const exact = matcher.exact.get(spec);
+  if (exact) return exact;
+  for (const p of matcher.prefixes) {
+    if (spec.startsWith(p.prefix)) return p.item;
+  }
+  return null;
+}
+function serializeShareCallForFacade(item, fallbackUrl) {
+  const opts = [];
+  opts.push(`shareScope: ${JSON.stringify(item.shareScope)}`);
+  opts.push(`shareKey: ${JSON.stringify(item.shareKey)}`);
+  if (item.requiredVersion !== false) opts.push(`requiredVersion: ${JSON.stringify(item.requiredVersion)}`);
+  if (item.singleton) opts.push("singleton: true");
+  if (item.strictVersion) opts.push("strictVersion: true");
+  if (item.import !== false) {
+    const facadeUrl = fallbackUrl ?? SHARED_FACADE_PREFIX + item.shareKey;
+    opts.push(`fallback: () => import(${JSON.stringify(facadeUrl)})`);
+  }
+  return `__fulgur_loadShare(${JSON.stringify(item.shareKey)}, { ${opts.join(", ")} })`;
+}
+function serializeShareCall(item, devUrls) {
+  const opts = [];
+  opts.push(`shareScope: ${JSON.stringify(item.shareScope)}`);
+  opts.push(`shareKey: ${JSON.stringify(item.shareKey)}`);
+  if (item.requiredVersion !== false) opts.push(`requiredVersion: ${JSON.stringify(item.requiredVersion)}`);
+  if (item.singleton) opts.push("singleton: true");
+  if (item.strictVersion) opts.push("strictVersion: true");
+  if (item.import !== false) {
+    const facadeUrl = devUrls ? devUrls.namespaceFacade(item.shareKey) : SHARED_FACADE_PREFIX + item.shareKey;
+    opts.push(`fallback: () => import(${JSON.stringify(facadeUrl)})`);
+  }
+  return `__fulgur_loadShare(${JSON.stringify(item.shareKey)}, { ${opts.join(", ")} })`;
+}
+function stripComments(s) {
+  return s.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+}
+function parseBindings(inner) {
+  const out = [];
+  for (const piece of stripComments(inner).split(",")) {
+    const raw = piece.trim();
+    if (!raw) continue;
+    if (/^type\s/.test(raw)) continue;
+    const asMatch = raw.match(/^(.*?)\s+as\s+(.+)$/);
+    const imported = asMatch ? asMatch[1].trim() : raw;
+    const local = asMatch ? asMatch[2].trim() : raw;
+    out.push({ imported, local, isDefault: imported === "default" });
+  }
+  return out;
+}
+function parseImportClause(clause) {
+  const nsMatch = clause.match(/\*\s+as\s+(\w+)/);
+  const braceStart = clause.indexOf("{");
+  const bindings = braceStart !== -1 ? parseBindings(clause.slice(braceStart + 1, clause.lastIndexOf("}"))) : null;
+  let head = clause.replace(/^\s*import\s*/, "");
+  if (braceStart !== -1) head = head.slice(0, head.indexOf("{"));
+  if (nsMatch) head = head.slice(0, head.indexOf("*"));
+  const defaultLocal = head.replace(/,\s*$/, "").trim() || null;
+  return { ns: nsMatch?.[1] ?? null, bindings, defaultLocal };
+}
+var JS_EXT_RE = /\.(m|c)?[jt]sx?$/;
+function isTransformableId(id, allowNodeModules = false) {
+  const clean = id.split("?")[0];
+  if (!JS_EXT_RE.test(clean) && !clean.endsWith(".vue")) return false;
+  if (clean.includes("node_modules") && !allowNodeModules) return false;
+  return true;
+}
+var facadeRegistry = /* @__PURE__ */ new Map();
+function shortSig(kind, key, bindings) {
+  const full = kind + "|" + key + "|" + bindings.join("|");
+  let h = 5381;
+  for (let i = 0; i < full.length; i++) h = (h << 5) + h + full.charCodeAt(i) | 0;
+  const id = (h >>> 0).toString(36) + bindings.length.toString(36);
+  facadeRegistry.set(id, kind === "shared" ? { bindings, shareKey: key } : { bindings, remoteName: key });
+  return id;
+}
+function getFacadeEntry(id) {
+  return facadeRegistry.get(id);
+}
+function canonicalBindings(bindings) {
+  const names = /* @__PURE__ */ new Set();
+  for (const bRaw of bindings) {
+    if (bRaw === "default") continue;
+    const asMatch = bRaw.match(/^(.*?)\s+as\s+(.+)$/);
+    names.add((asMatch ? asMatch[1] : bRaw).trim());
+  }
+  return [...names].sort();
+}
+function bindingFacadeId(item, bindings) {
+  const canonical = canonicalBindings(bindings);
+  const sig = canonical.length ? `?f=${shortSig("shared", item.shareKey, canonical)}` : "";
+  return `${SHARED_FACADE_PREFIX}${item.shareKey}${sig}`;
+}
+function facadeSpecFor(ctx, item, bindings) {
+  const id = bindingFacadeId(item, bindings);
+  return ctx.devUrls ? ctx.devUrls.bindingFacade(id) : id;
+}
+function remoteBindingFacadeId(remoteName, exposeName, bindings) {
+  const canonical = canonicalBindings(bindings);
+  const sig = canonical.length ? `?f=${shortSig("remote", `${remoteName}/${exposeName}`, canonical)}` : "";
+  return `${SHARED_FACADE_PREFIX}__remote__${remoteName}/${exposeName}${sig}`;
+}
+function remoteFacadeSpecFor(ctx, remoteName, exposeName, bindings) {
+  const id = remoteBindingFacadeId(remoteName, exposeName, bindings);
+  return ctx.devUrls ? ctx.devUrls.bindingFacade(id) : id;
+}
+async function transformModule(code, id, ctx) {
+  const { options } = ctx;
+  if (options.shared.length === 0 && options.remotes.length === 0) return null;
+  const candidates = [];
+  for (const s2 of options.shared) candidates.push(s2.configKey.replace(/\/$/, ""));
+  for (const r of options.remotes) candidates.push(r.key);
+  if (!candidates.some((c) => code.includes(c))) return null;
+  if (ctx.cjsRequireRewrite && /require\s*\(\s*["']/.test(code)) {
+    const sharedByAlias = /* @__PURE__ */ new Map();
+    for (const s2 of options.shared) {
+      if (s2.import === false) continue;
+      for (const a of s2.aliases) if (!a.includes("/")) sharedByAlias.set(a, s2);
+    }
+    let cjsEdited = false;
+    for (const [alias, item] of sharedByAlias) {
+      const re = new RegExp(`require\\((["'])${alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\1\\)`, "g");
+      if (!re.test(code)) continue;
+      code = code.replace(re, `require(${JSON.stringify(`virtual:fulgur-cjs-ns:${item.shareKey}`)})`);
+      cjsEdited = true;
+    }
+    if (!cjsEdited) return null;
+    return { code, map: null };
+  }
+  await ensureLexer();
+  let imports;
+  try {
+    ;
+    [imports] = (0, import_es_module_lexer.parse)(code);
+  } catch {
+    return null;
+  }
+  const matcher = ctx.rewriteShared ? buildSharedMatcher(options.shared) : null;
+  const remotesByKey = new Map(options.remotes.map((r) => [r.key, r]));
+  const s = new import_magic_string.default(code);
+  let edited = false;
+  let usesRuntimeHelpers = false;
+  const tlaLines = [];
+  let tempIdx = 0;
+  const genTemp = () => `__fulgur_m${tempIdx++}`;
+  const remap = (spec) => ctx.remapSpecifier?.(spec) ?? spec;
+  const remoteExposeName = (spec, remoteKey) => {
+    if (!spec.startsWith(`${remoteKey}/`)) return null;
+    const exposeRaw = spec.slice(remoteKey.length + 1);
+    if (!exposeRaw) return null;
+    return exposeRaw.startsWith(".") ? exposeRaw : `./${exposeRaw}`;
+  };
+  const bindingsOf = (clause) => [
+    ...clause.defaultLocal ? ["default"] : [],
+    ...(clause.bindings ?? []).map((b) => b.imported === b.local ? b.imported : `${b.imported} as ${b.local}`)
+  ];
+  const genTlaOverwrite = (stmtStart, stmtEnd, shared, remoteName, exposeName, clauseRaw, clause) => {
+    usesRuntimeHelpers = true;
+    const call = shared ? serializeShareCall(shared, ctx?.devUrls) : `__fulgur_loadRemote(${JSON.stringify(`${remoteName}/${exposeName}`)})`;
+    const nsAs = clauseRaw.match(/export\s+\*\s+as\s+(\w+)\s+from/);
+    if (nsAs) {
+      s.overwrite(stmtStart, stmtEnd, `const ${nsAs[1]} = await ${call};
+export { ${nsAs[1]} };`);
+      return;
+    }
+    if (!clause.ns && !clause.bindings && !clause.defaultLocal) {
+      s.overwrite(stmtStart, stmtEnd, `await ${call};`);
+      return;
+    }
+    const tmp = genTemp();
+    const parts = [`${tmp} = await ${call}`];
+    if (clause.ns) parts.push(`${clause.ns} = ${tmp}`);
+    if (clause.defaultLocal) parts.push(`${clause.defaultLocal} = __fulgurU(${tmp})`);
+    const named = clause.bindings?.filter((b) => !b.isDefault) ?? [];
+    if (named.length) {
+      const destructure = named.map((b) => b.imported === b.local ? b.local : `${b.imported}: ${b.local}`);
+      parts.push(`{ ${destructure.join(", ")} } = ${tmp}`);
+    }
+    for (const b of clause.bindings?.filter((x) => x.isDefault) ?? []) {
+      parts.push(`${b.local} = __fulgurU(${tmp})`);
+    }
+    s.overwrite(stmtStart, stmtEnd, `const ${parts.join(", ")}`);
+  };
+  for (const imp of imports) {
+    const { d } = imp;
+    if (d === -2) continue;
+    if (d === -1) {
+      const rawSpec = code.slice(imp.s, imp.e).replace(/['"]/g, "");
+      const spec2 = remap(rawSpec);
+      const stmtStart = imp.ss;
+      let stmtEnd = imp.se;
+      while (code[stmtEnd] === ";") stmtEnd++;
+      const head = code.slice(stmtStart, stmtStart + 24);
+      if (/^\s*(import|export)\s+type[\s{]/.test(head)) continue;
+      const shared2 = matcher ? matchShared(spec2, matcher) : null;
+      const firstSeg2 = spec2.split("/")[0];
+      const remote2 = remotesByKey.get(firstSeg2);
+      const exposeName2 = remote2 ? remoteExposeName(spec2, remote2.key) : null;
+      if (!shared2 && !(remote2 && exposeName2)) continue;
+      edited = true;
+      const clauseRaw = code.slice(stmtStart, imp.s).replace(/['"]\s*$/, "");
+      const isImport = clauseRaw.trimStart().startsWith("import");
+      const clause = parseImportClause(clauseRaw.replace(/\bfrom\s*$/, ""));
+      if (clause.ns || /export\s+\*\s+as\s+\w+\s+from/.test(clauseRaw)) {
+        genTlaOverwrite(stmtStart, stmtEnd, shared2, remote2?.name ?? null, exposeName2, clauseRaw, clause);
+        continue;
+      }
+      if (!isImport) {
+        const inner = clauseRaw.slice(clauseRaw.indexOf("{") + 1, clauseRaw.lastIndexOf("}"));
+        if (/export\s+\*/.test(clauseRaw) && !clauseRaw.includes("{")) {
+          throw new Error(
+            `[fulgur] "export * from '${spec2}'" on a shared module is not supported (ESM cannot create dynamic export bindings). Use named re-exports: "export { a, b } from '${spec2}'".`
+          );
+        }
+        const bindings = parseBindings(inner).map((b) => b.imported === "default" ? "default" : b.imported);
+        const facadeSpec2 = shared2 ? facadeSpecFor(ctx, shared2, bindings) : remoteFacadeSpecFor(ctx, remote2.name, exposeName2, bindings);
+        s.overwrite(imp.s, imp.e, facadeSpec2);
+        continue;
+      }
+      const facadeSpec = shared2 ? facadeSpecFor(ctx, shared2, bindingsOf(clause)) : remoteFacadeSpecFor(ctx, remote2.name, exposeName2, bindingsOf(clause));
+      s.overwrite(imp.s, imp.e, facadeSpec);
+      continue;
+    }
+    const specExpr = code.slice(imp.s, imp.e).trim();
+    const literal = specExpr.match(/^['"](.*)['"]$/s);
+    if (!literal) continue;
+    const spec = remap(literal[1]);
+    const shared = matcher ? matchShared(spec, matcher) : null;
+    const firstSeg = spec.split("/")[0];
+    const remote = remotesByKey.get(firstSeg);
+    const exposeName = remote ? remoteExposeName(spec, remote.key) : null;
+    if (!shared && !(remote && exposeName)) continue;
+    edited = true;
+    usesRuntimeHelpers = true;
+    const callStart = code.lastIndexOf("import", d);
+    const closeParen = code.indexOf(")", imp.e);
+    if (shared) {
+      s.overwrite(callStart, closeParen + 1, serializeShareCall(shared, ctx?.devUrls));
+    } else if (remote && exposeName) {
+      s.overwrite(
+        callStart,
+        closeParen + 1,
+        `__fulgur_loadRemote(${JSON.stringify(`${remote.name}/${exposeName}`)})`
+      );
+    }
+  }
+  if (!edited) return null;
+  if (usesRuntimeHelpers) {
+    const runtimeSpec = JSON.stringify(ctx.devUrls?.runtime ?? "virtual:fulgur-runtime");
+    s.prepend(
+      `import { loadShare as __fulgur_loadShare, loadRemote as __fulgur_loadRemote, unwrapDefault as __fulgurU } from ${runtimeSpec};
+`
+    );
+  }
+  return { code: s.toString(), map: null };
+}
+
+// src/virtual.ts
+function jsonReplacer(_k, v) {
+  return v;
+}
+function genSharedFacade(specifier, exportNames) {
+  const names = (exportNames ?? []).filter(
+    (n) => n !== "default" && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(n)
+  );
+  if (names.length === 0) {
+    return [
+      `import * as __fulgur_facade from ${JSON.stringify(specifier)};`,
+      `export * from ${JSON.stringify(specifier)};`,
+      `export default __fulgur_facade.default ?? __fulgur_facade;`,
+      ""
+    ].join("\n");
+  }
+  return [
+    `import * as __fulgur_facade from ${JSON.stringify(specifier)};`,
+    ...names.map((n) => `export const ${n} = __fulgur_facade[${JSON.stringify(n)}];`),
+    `export default __fulgur_facade.default ?? __fulgur_facade;`,
+    ""
+  ].join("\n");
+}
+function genSharedNsFacade(item, loadShareCall, exportNames) {
+  const lines = [
+    `import { loadShare as __fulgur_loadShare, unwrapDefault as __fulgurU } from "virtual:fulgur-runtime";`,
+    `const __fulgur_m = await ${loadShareCall};`,
+    `const __fulgur_d = __fulgurU(__fulgur_m);`,
+    `export default __fulgur_d;`
+  ];
+  const seen = /* @__PURE__ */ new Set(["default"]);
+  for (const name of exportNames) {
+    if (seen.has(name) || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) continue;
+    seen.add(name);
+    lines.push(`export const ${name} = __fulgur_d[${JSON.stringify(name)}];`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function genBindingFacade(item, bindings, loadShareCall) {
+  const lines = [
+    `import { loadShare as __fulgur_loadShare, unwrapDefault as __fulgurU } from "virtual:fulgur-runtime";`,
+    `const __fulgur_m = await ${loadShareCall};`
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const bRaw of bindings) {
+    if (bRaw === "default") continue;
+    const asMatch = bRaw.match(/^(.*?)\s+as\s+(.+)$/);
+    const imported = (asMatch ? asMatch[1] : bRaw).trim();
+    if (seen.has(imported)) continue;
+    seen.add(imported);
+    lines.push(`export const ${imported} = __fulgur_m.${imported};`);
+  }
+  lines.push(`export default __fulgurU(__fulgur_m);`);
+  lines.push("");
+  return lines.join("\n");
+}
+function genRemoteBindingFacade(remoteSpec, bindings) {
+  const lines = [
+    `import { loadRemote as __fulgur_loadRemote, unwrapDefault as __fulgurU } from "virtual:fulgur-runtime";`,
+    `const __fulgur_m = await __fulgur_loadRemote(${JSON.stringify(remoteSpec)});`
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const bRaw of bindings) {
+    if (bRaw === "default") continue;
+    const asMatch = bRaw.match(/^(.*?)\s+as\s+(.+)$/);
+    const imported = (asMatch ? asMatch[1] : bRaw).trim();
+    if (seen.has(imported)) continue;
+    seen.add(imported);
+    lines.push(`export const ${imported} = __fulgur_m.${imported};`);
+  }
+  lines.push(`export default __fulgurU(__fulgur_m);`);
+  lines.push("");
+  return lines.join("\n");
+}
+function providesRecords(options) {
+  return options.shared.filter((s) => s.import !== false).map((s) => ({
+    shareScope: s.shareScope,
+    name: s.shareKey,
+    version: s.version,
+    eager: s.eager,
+    from: options.name
+  }));
+}
+function genInitModule(options, command) {
+  const lines = [];
+  lines.push(`import { initSharing, registerShare, registerRemotes, registerPlugins } from "virtual:fulgur-runtime";`);
+  const provides = providesRecords(options);
+  const eagerShared = options.shared.filter((s) => s.eager && s.import !== false);
+  eagerShared.forEach((s, i) => {
+    lines.push(`import * as __fulgur_eager_${i} from "virtual:fulgur-shared:${s.shareKey}";`);
+  });
+  const isDevHost = command === "serve" && options.remotes.length > 0;
+  const loadedFlag = isDevHost ? "true" : "false";
+  lines.push(`initSharing(${JSON.stringify(options.shareScope)});`);
+  if (options.runtimePlugins.length > 0) {
+    options.runtimePlugins.forEach((p, i) => {
+      lines.push(`import * as __fulgur_rp_${i} from ${JSON.stringify(p)};`);
+    });
+    lines.push(
+      `registerPlugins([${options.runtimePlugins.map((_, i) => `(__fulgur_rp_${i}.default ?? __fulgur_rp_${i})`).join(", ")}]);`
+    );
+  }
+  if (options.remotes.length > 0) {
+    lines.push(...registerRemotesLines(options, command));
+  }
+  provides.forEach((p) => {
+    const eagerIdx = eagerShared.findIndex((s) => s.shareKey === p.name && s.shareScope === p.shareScope);
+    if (p.eager && eagerIdx !== -1) {
+      lines.push(
+        `registerShare(${JSON.stringify(p.shareScope)}, ${JSON.stringify(p.name)}, ${JSON.stringify(p.version)}, () => Promise.resolve(__fulgur_eager_${eagerIdx}), { from: ${JSON.stringify(p.from)}, eager: true, loaded: ${loadedFlag} });`
+      );
+    } else {
+      lines.push(
+        `registerShare(${JSON.stringify(p.shareScope)}, ${JSON.stringify(p.name)}, ${JSON.stringify(p.version)}, () => import("virtual:fulgur-shared:${p.name}"), { from: ${JSON.stringify(p.from)}, eager: false, loaded: ${loadedFlag} });`
+      );
+    }
+  });
+  return `${lines.join("\n")}
+`;
+}
+function manifestUrlFor(r, command) {
+  const entry = command === "serve" ? r.devEntry : r.prodEntry;
+  if (!entry) return null;
+  try {
+    const u = new URL(entry);
+    if (u.pathname.includes("@fulgur-entry.js")) {
+      u.pathname = u.pathname.replace("@fulgur-entry.js", "@fulgur-manifest.json");
+    } else {
+      u.pathname = u.pathname.replace(/[^/]*$/, "") + "fulgur-manifest.json";
+    }
+    return u.href;
+  } catch {
+    return null;
+  }
+}
+function registerRemotesLines(options, command) {
+  if (options.remotes.length === 0) return [];
+  const remotesJson = options.remotes.filter((r) => !r.promise).map((r) => ({
+    name: r.name,
+    entry: command === "serve" ? r.devEntry : r.prodEntry,
+    shareScope: r.shareScope,
+    timeout: r.timeout,
+    retries: r.retries,
+    fallback: r.fallback,
+    breaker: r.breaker,
+    manifestUrl: manifestUrlFor(r, command)
+  }));
+  if (remotesJson.length === 0) return [];
+  return [
+    `registerRemotes(${JSON.stringify(remotesJson, jsonReplacer).replace(/"manifestUrl":null,?/g, "")});`
+  ];
+}
+function genRuntimeProxyModule() {
+  const promiseApis = [
+    "loadRemote",
+    "loadShare",
+    "preloadRemote",
+    "getContainer",
+    "registerRemote",
+    "registerRemotes",
+    "registerShare",
+    "initSharing",
+    "registerPlugins",
+    "parseSpec"
+  ];
+  const lines = [
+    `let __fulgur_mod_p;`,
+    `const __fulgur_rt = async () => {`,
+    `  __fulgur_mod_p ??= import('virtual:fulgur-runtime');`,
+    `  return await __fulgur_mod_p;`,
+    `};`,
+    ...promiseApis.map((m) => `export const ${m} = (...a) => __fulgur_rt().then((m2) => m2.${m}(...a));`),
+    `export const getRuntime = () => (globalThis).__FULGUR_RUNTIME__;`,
+    `export const getFulgurAppConfig = () =>`,
+    `  (globalThis).__FULGUR_RUNTIME__?.getFulgurAppConfig?.() ?? (globalThis).__FULGUR_APP_CONFIG__ ?? {};`,
+    `export const provideFulgurAppConfig = (c) => {`,
+    `  const g = (globalThis);`,
+    `  g.__FULGUR_APP_CONFIG__ = { ...(g.__FULGUR_APP_CONFIG__ ?? {}), ...c };`,
+    `  g.__FULGUR_RUNTIME__?.provideFulgurAppConfig?.(c);`,
+    `};`,
+    `export const unwrapDefault = (ns) =>`,
+    `  ns && typeof ns === 'object' && 'default' in ns ? (ns.default !== undefined ? ns.default : ns) : ns;`,
+    `export const version = (globalThis).__FULGUR_RUNTIME__?.version;`,
+    `export default { get runtime() { return (globalThis).__FULGUR_RUNTIME__; } };`,
+    ``
+  ];
+  return lines.join("\n");
+}
+function genDevRemoteEntry(options, base) {
+  const b = base.endsWith("/") ? base : `${base}/`;
+  const remoteLines = registerRemotesLines(options, "serve");
+  return `import ${JSON.stringify(`${b}@vite/client`)};
+import { name as _fulgur_name, exposes, provides } from ${JSON.stringify(`${b}@id/__x00__virtual:fulgur-provides`)};
+${remoteLines.length > 0 ? `import { registerRemotes } from ${JSON.stringify(`${b}@id/virtual:fulgur-runtime`)};
+${remoteLines.join("\n")}` : ""}
+
+export const name = _fulgur_name;
+
+export async function init(shareScopeMap) {
+  for (const p of provides) {
+    const scope = shareScopeMap[p.shareScope] || (shareScopeMap[p.shareScope] = {});
+    const byName = scope[p.name] || (scope[p.name] = {});
+    if (byName[p.version]) continue; // \u5DF2\u6CE8\u518C\u7248\u672C\u6C38\u4E0D\u66FF\u6362
+    byName[p.version] = { version: p.version, get: p.get, from: name, eager: p.eager, loaded: false };
+  }
+}
+
+export async function get(moduleName) {
+  const loader = exposes[moduleName];
+  if (!loader) {
+    const err = new Error('MFU-006: module "' + moduleName + '" is not exposed by remote "' + name + '"');
+    err.code = 'MFU-006';
+    throw err;
+  }
+  return loader();
+}
+`;
+}
+function genDevProvides(options) {
+  const exposes = [];
+  for (const e of options.exposes) {
+    const devUrl = `/${e.import.replace(/^\.?\//, "")}`;
+    exposes.push(
+      `  ${JSON.stringify(e.name)}: () => import(${JSON.stringify(devUrl)}),`
+    );
+  }
+  const provides = providesRecords(options).map(
+    (p) => `  { shareScope: ${JSON.stringify(p.shareScope)}, name: ${JSON.stringify(p.name)}, version: ${JSON.stringify(p.version)}, eager: ${p.eager}, get: () => import("virtual:fulgur-shared:${p.name}") },`
+  );
+  return [
+    `export const name = ${JSON.stringify(options.name)};`,
+    `export const exposes = {`,
+    ...exposes,
+    `};`,
+    `export const provides = [`,
+    ...provides,
+    `];`,
+    ""
+  ].join("\n");
+}
+function genBuildRemoteEntry(options, exposeAbsPaths) {
+  const exposes = [];
+  for (const e of options.exposes) {
+    const abs = exposeAbsPaths[e.import];
+    if (!abs) continue;
+    exposes.push(`  ${JSON.stringify(e.name)}: () => import(${JSON.stringify(abs)}),`);
+  }
+  const provides = providesRecords(options).map(
+    (p) => `  { shareScope: ${JSON.stringify(p.shareScope)}, name: ${JSON.stringify(p.name)}, version: ${JSON.stringify(p.version)}, eager: ${p.eager}, get: () => import("virtual:fulgur-shared:${p.name}") },`
+  );
+  const remoteLines = registerRemotesLines(options, "build");
+  return [
+    ...remoteLines.length > 0 ? [`import { registerRemotes } from "virtual:fulgur-runtime";`, ...remoteLines] : [],
+    `const exposes = {`,
+    ...exposes,
+    `};`,
+    `const provides = [`,
+    ...provides,
+    `];`,
+    `export const name = ${JSON.stringify(options.name)};`,
+    ``,
+    `export async function init(shareScopeMap) {`,
+    `  for (const p of provides) {`,
+    `    const scope = shareScopeMap[p.shareScope] || (shareScopeMap[p.shareScope] = {});`,
+    `    const byName = scope[p.name] || (scope[p.name] = {});`,
+    `    if (byName[p.version]) continue; // \u5DF2\u6CE8\u518C\u7248\u672C\u6C38\u4E0D\u66FF\u6362`,
+    `    byName[p.version] = { version: p.version, get: p.get, from: name, eager: p.eager, loaded: false };`,
+    `  }`,
+    `}`,
+    ``,
+    `export async function get(moduleName) {`,
+    `  const loader = exposes[moduleName];`,
+    `  if (!loader) {`,
+    `    const err = new Error('MFU-006: module "' + moduleName + '" is not exposed by remote "' + name + '"');`,
+    `    err.code = 'MFU-006';`,
+    `    throw err;`,
+    `  }`,
+    `  return loader();`,
+    `}`,
+    ""
+  ].join("\n");
+}
+function genDevManifest(options, base) {
+  const b = base.endsWith("/") ? base : `${base}/`;
+  return {
+    id: options.name,
+    name: options.name,
+    version: options.pkgDependencies?.["fulgur"] ?? "0.0.0",
+    devServer: true,
+    base: b,
+    entry: `${b}@fulgur-entry.js`,
+    /** 本地联调时供宿主端 dts 类型直连（见 dts.ts）；远程不在本机时宿主回退 any 桩 */
+    fsRoot: options.root,
+    exposes: options.exposes.map((e) => ({
+      name: e.name,
+      src: e.import,
+      file: `${b}@fulgur-src/${e.import.replace(/^\.?\//, "")}`
+    })),
+    shared: options.shared.map((s) => ({
+      name: s.shareKey,
+      version: s.version,
+      singleton: s.singleton,
+      requiredVersion: s.requiredVersion,
+      shareScope: s.shareScope,
+      eager: s.eager
+    }))
+  };
+}
+function genProdManifest(options, exposeFiles, entryFile) {
+  return {
+    id: options.name,
+    name: options.name,
+    entry: entryFile,
+    exposes: exposeFiles,
+    shared: options.shared.map((s) => ({
+      name: s.shareKey,
+      version: s.version,
+      singleton: s.singleton,
+      requiredVersion: s.requiredVersion,
+      shareScope: s.shareScope,
+      eager: s.eager
+    })),
+    buildInfo: {
+      builtBy: "fulgur-federation",
+      timestamp: Date.now()
+    }
+  };
+}
+
+// src/dts.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+async function fetchManifest(devEntry, attempts = 30, delayMs = 2e3) {
+  let manifestUrl;
+  try {
+    const u = new URL(devEntry);
+    u.pathname = u.pathname.replace("@fulgur-entry.js", "@fulgur-manifest.json");
+    manifestUrl = u;
+  } catch {
+    return null;
+  }
+  for (let i = 0; i < attempts; i++) {
+    try {
+      const res = await fetch(manifestUrl, { signal: AbortSignal.timeout(3e3) });
+      if (res.ok) return await res.json();
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, delayMs));
+  }
+  return null;
+}
+function sourceHasDefaultExport(file) {
+  try {
+    const text = import_node_fs2.default.readFileSync(file, "utf8");
+    return /export\s+default\b/.test(text) || /export\s*\{[^}]*\bdefault\b[^}]*\}/.test(text);
+  } catch {
+    return false;
+  }
+}
+async function generateDevTypes(options, _server) {
+  const dtsOpt = options.dts === void 0 ? true : options.dts;
+  if (dtsOpt === false) return;
+  const defaultDir = import_node_fs2.default.existsSync(import_node_path3.default.join(options.root, "src")) ? "src/fulgur-types" : "fulgur-types";
+  const dir = typeof dtsOpt === "object" ? dtsOpt.dir ?? defaultDir : defaultDir;
+  const outDir = import_node_path3.default.join(options.root, dir);
+  import_node_fs2.default.mkdirSync(outDir, { recursive: true });
+  for (const remote of options.remotes) {
+    if (!remote.devEntry || remote.promise) continue;
+    const manifest = await fetchManifest(remote.devEntry);
+    if (!manifest || !manifest.exposes) {
+      console.warn(`[fulgur] dts: remote "${remote.key}" dev manifest unavailable; type mapping skipped.`);
+      continue;
+    }
+    const remoteRoot = manifest.fsRoot;
+    if (!remoteRoot || !import_node_fs2.default.existsSync(remoteRoot)) {
+      console.warn(
+        `[fulgur] dts: remote "${remote.key}" is not on this machine; type mapping skipped (module types fall back to any).`
+      );
+      continue;
+    }
+    const lines = [
+      `// \u81EA\u52A8\u751F\u6210\uFF1Afulgur-federation dev \u7C7B\u578B\u76F4\u8FDE\uFF08remote: ${remote.name}\uFF09`,
+      `// \u91CD\u65B0\u751F\u6210\uFF1A\u91CD\u542F host dev server`
+    ];
+    for (const expose of manifest.exposes ?? []) {
+      const abs = import_node_path3.default.join(remoteRoot, expose.src.replace(/^\//, ""));
+      if (!import_node_fs2.default.existsSync(abs)) continue;
+      const rel = import_node_path3.default.relative(outDir, abs).split(import_node_path3.default.sep).join("/");
+      const importPath = rel.startsWith(".") ? rel : `./${rel}`;
+      const moduleSpecifier = `${remote.key}/${expose.name.replace(/^\.\//, "")}`;
+      lines.push("");
+      if (abs.endsWith(".vue")) {
+        lines.push(`declare module '${moduleSpecifier}' {`);
+        lines.push(`  import type { DefineComponent } from 'vue'`);
+        lines.push(`  const component: DefineComponent<Record<string, unknown>, Record<string, unknown>, unknown>`);
+        lines.push(`  export default component`);
+        lines.push(`  export * from '${importPath}'`);
+        lines.push(`}`);
+      } else {
+        lines.push(`declare module '${moduleSpecifier}' {`);
+        lines.push(`  export * from '${importPath}'`);
+        if (sourceHasDefaultExport(abs)) lines.push(`  export { default } from '${importPath}'`);
+        lines.push(`}`);
+      }
+    }
+    import_node_fs2.default.writeFileSync(import_node_path3.default.join(outDir, `${remote.key}.d.ts`), `${lines.join("\n")}
+`);
+    console.log(
+      `[fulgur] dts: generated ${dir}/${remote.key}.d.ts (${manifest.exposes?.length ?? 0} exposes). \u786E\u4FDD tsconfig include \u5305\u542B "${dir}" \u4EE5\u83B7\u5F97\u6E90\u7801\u7EA7\u7C7B\u578B\u8865\u5168\u3002`
+    );
+  }
+}
+
+// src/diagnostics.ts
+function formatFulgurDiagnostic(input) {
+  const ctx = input.details ? `
+\u4E0A\u4E0B\u6587\uFF1A${JSON.stringify(input.details)}` : "";
+  return `[fulgur:${input.code}] ${input.symptom}
+\u6839\u56E0\uFF1A${input.cause}
+\u4FEE\u6CD5\uFF1A${input.fix}` + ctx;
+}
+async function isPortReachable(host, port, timeoutMs = 800) {
+  const net = await import("net");
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const done = (ok) => {
+      socket.destroy();
+      resolve(ok);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => done(true));
+    socket.once("timeout", () => done(false));
+    socket.once("error", () => done(false));
+    socket.connect(port, host);
+  });
+}
+
+// src/remote-schema.ts
+function manifestUrlOf(devEntry) {
+  try {
+    const u = new URL(devEntry);
+    u.pathname = u.pathname.replace("@fulgur-entry.js", "@fulgur-manifest.json");
+    return u;
+  } catch {
+    return null;
+  }
+}
+async function probeRemotesAndBuildSchema(options) {
+  const schema = {};
+  for (const remote of options.remotes) {
+    if (!remote.devEntry || remote.promise) {
+      schema[remote.key] = { exposes: [], exists: false };
+      continue;
+    }
+    const u = manifestUrlOf(remote.devEntry);
+    if (!u) {
+      schema[remote.key] = { exposes: [], exists: false };
+      continue;
+    }
+    try {
+      const res = await fetch(u, { signal: AbortSignal.timeout(3e3) });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const manifest = await res.json();
+      const exposes = (manifest?.exposes ?? []).map((e) => e.name);
+      schema[remote.key] = { exposes, exists: true };
+      if (exposes.length === 0) {
+        console.warn(
+          formatFulgurDiagnostic({
+            code: "DEV-002",
+            symptom: `remote "${remote.key}" \u7684 dev manifest \u53EF\u8FBE\u4F46 exposes \u4E3A\u7A7A\uFF08${u.href}\uFF09`,
+            cause: "remote \u4FA7 federation({ exposes }) \u4E3A\u7A7A\uFF0C\u6216\u5176\u63D2\u4EF6\u7248\u672C\u8FC7\u65E7\u5BFC\u81F4 manifest \u7F3A\u5B57\u6BB5",
+            fix: "\u6838\u5BF9 remote \u7684 federation \u914D\u7F6E exposes\uFF0C\u5E76\u786E\u8BA4 @fulgurjs/federation \u7248\u672C\u4E0E\u5BBF\u4E3B\u4E00\u81F4",
+            details: { remote: remote.key, url: u.href, pluginVersion: manifest?.buildInfo?.version }
+          })
+        );
+      }
+      const remoteVersion = manifest?.buildInfo?.version;
+      if (remoteVersion && remoteVersion !== options.pluginVersion) {
+        console.warn(
+          formatFulgurDiagnostic({
+            code: "DEV-006",
+            symptom: `\u5BBF\u4E3B\u4E0E remote "${remote.key}" \u7684 @fulgurjs/federation \u7248\u672C\u4E0D\u4E00\u81F4`,
+            cause: `\u5BBF\u4E3B ${options.pluginVersion} vs \u8FDC\u7A0B ${remoteVersion}\uFF08pnpm tarball \u65AD\u94FE/\u6F0F\u5347\u7EA7\u5E38\u89C1\uFF09`,
+            fix: "\u7EDF\u4E00\u5347\u7EA7\u5404\u5E94\u7528\u4F9D\u8D56\u5230\u540C\u4E00\u7248\u672C\uFF1Apnpm add -D @fulgurjs/federation@<version> \u5E76\u91CD\u542F dev server",
+            details: { host: options.pluginVersion, remote: remoteVersion }
+          })
+        );
+      }
+    } catch (err) {
+      schema[remote.key] = { exposes: [], exists: false };
+      const port = u.port ? Number(u.port) : u.protocol === "https:" ? 443 : 80;
+      const portOpen = await isPortReachable(u.hostname, port);
+      console.warn(
+        formatFulgurDiagnostic({
+          code: "DEV-001",
+          symptom: `remote "${remote.key}" \u7684 dev manifest \u4E0D\u53EF\u8FBE\uFF08${u.href}\uFF09\u2014\u2014\u8BE5 remote \u7684\u8DEF\u7531\u5B58\u5728\u6027\u6821\u9A8C\u5C06\u8DF3\u8FC7`,
+          cause: portOpen ? "\u7AEF\u53E3\u6709\u8FDB\u7A0B\u76D1\u542C\u4F46 manifest \u7AEF\u70B9\u5F02\u5E38\uFF1Aremote dev server \u53EF\u80FD\u4EE5\u975E\u8054\u90A6\u914D\u7F6E\u542F\u52A8\uFF0C\u6216 base/\u8DEF\u5F84\u4E0E remotes[].dev \u4E0D\u4E00\u81F4" : "\u7AEF\u53E3\u65E0\u8FDB\u7A0B\u76D1\u542C\uFF1Aremote dev server \u672A\u542F\u52A8\uFF0C\u6216 remotes[].dev \u7AEF\u53E3\u5199\u9519\uFF08server.origin \u9519\u4F4D\u540C\u6B3E\uFF09",
+          fix: "\u542F\u52A8\u5BF9\u5E94 remote \u7684 dev server\uFF1B\u6838\u5BF9\u5BBF\u4E3B federation({ remotes }) \u7684 dev URL \u4E0E remote \u5B9E\u9645 VITE_PORT/base",
+          details: { remote: remote.key, url: u.href, port, portOpen, error: String(err?.message ?? err) }
+        })
+      );
+    }
+  }
+  return schema;
+}
+function genEmptyRemoteSchemaModule() {
+  console.info("[fulgur] build \u671F\u8DF3\u8FC7\u8DEF\u7531 spec \u5B58\u5728\u6027\u6821\u9A8C\uFF08\u8FDC\u7A0B manifest \u4E0D\u5728\u6784\u5EFA\u673A\u672C\u5730\uFF1Bdev \u4E0B\u81EA\u52A8\u542F\u7528\uFF09");
+  return "export default {}";
+}
+
+// src/vite-cache.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+function syncViteCacheMarker(root, pluginVersion, log) {
+  const viteDir = import_node_path4.default.join(root, "node_modules", ".vite");
+  const marker = import_node_path4.default.join(viteDir, "fulgur-version.txt");
+  try {
+    if (import_node_fs3.default.existsSync(viteDir)) {
+      const prev = import_node_fs3.default.existsSync(marker) ? import_node_fs3.default.readFileSync(marker, "utf8").trim() : "";
+      if (prev === pluginVersion) return;
+      import_node_fs3.default.rmSync(viteDir, { recursive: true, force: true });
+      log(
+        `[fulgur] \u63D2\u4EF6\u7248\u672C\u53D8\u5316\uFF08${prev || "\u65E0\u8BB0\u5F55"} \u2192 ${pluginVersion}\uFF09\uFF0C\u5DF2\u81EA\u52A8\u6E05\u9664 ${import_node_path4.default.relative(root, viteDir)} \u9884\u6784\u5EFA\u7F13\u5B58\uFF08\u907F\u514D\u65E7\u95E8\u9762\u7B7E\u540D 404 / DEV-009\uFF09\u3002\u672C\u6B21\u542F\u52A8\u5C06\u91CD\u65B0\u9884\u6784\u5EFA\uFF0C\u9996\u8F6E 30~60s \u5C5E\u6682\u6001\uFF08DEV-010\uFF09\u3002`
+      );
+    }
+    import_node_fs3.default.mkdirSync(viteDir, { recursive: true });
+    import_node_fs3.default.writeFileSync(marker, pluginVersion);
+  } catch (e) {
+    log(
+      `[fulgur] \u81EA\u52A8\u6E05\u7406 .vite \u7F13\u5B58\u5931\u8D25\uFF08\u4E0D\u5F71\u54CD\u542F\u52A8\uFF1B\u5982\u9047\u8054\u90A6\u6A21\u5757 404 \u8BF7\u624B\u5DE5\u6267\u884C rm -rf ${viteDir}\uFF09\uFF1A${String(e.message ?? e)}`
+    );
+  }
+}
+
+// src/runtime-code.gen.ts
+var runtime_code_gen_default = 'var Q=/^v?(\\d+)(?:\\.(\\d+))?(?:\\.(\\d+))?(?:-((?:[0-9A-Za-z-]+)(?:\\.[0-9A-Za-z-]+)*))?(?:\\+[0-9A-Za-z.-]+)?$/;function k(t){let n=Q.exec(String(t).trim());return n?{major:Number(n[1]),minor:Number(n[2]??0),patch:Number(n[3]??0),pre:n[4]?n[4].split("."):[]}:null}function ee(t,n){if(t.length===0&&n.length===0)return 0;if(t.length===0)return 1;if(n.length===0)return-1;let o=Math.max(t.length,n.length);for(let r=0;r<o;r++){let l=t[r],m=n[r];if(l===void 0)return-1;if(m===void 0)return 1;let y=/^\\d+$/.test(l),w=/^\\d+$/.test(m);if(y&&w){let M=Number(l)-Number(m);if(M!==0)return M}else{if(y!==w)return y?-1:1;if(l!==m)return l<m?-1:1}}return 0}function T(t,n){let o=k(t),r=k(n);return!o||!r?t<n?-1:t>n?1:0:o.major!==r.major?o.major-r.major:o.minor!==r.minor?o.minor-r.minor:o.patch!==r.patch?o.patch-r.patch:ee(o.pre,r.pre)}var re=/^[a-z]+[+:-]/i;function N(t,n){if(n===!1||n==null||n==="")return!0;let o=String(n).trim();return!o||o==="*"||o==="latest"||re.test(o)?!0:o.split("||").some(r=>te(t,r.trim()))}function te(t,n){if(!n||n==="*")return!k(t)?.pre.length;let o=n.split(/\\s+-\\s+/);if(o.length===2){let m=o[0].trim(),y=o[1].trim();return!(!N(t,`>=${m}`)||!N(t,`<=${y}`))}let r=k(t);if(!r)return!1;let l=ne(n);if(l===null)return!0;for(let m of l)if(!ue(r,t,m))return!1;return!(r.pre.length>0&&!l.some(m=>m.ver.pre.length>0)&&!l.some(y=>y.ver.major===r.major&&y.ver.minor===r.minor&&y.ver.patch===r.patch))}function ne(t){let n=[],o=t.trim().split(/\\s+/).filter(Boolean);if(o.length===0)return null;for(let r of o){let l=/^(>=|<=|>|<|=|\\^|~)?(.*)$/.exec(r);if(!l)return null;let m=l[1],y=l[2],w=oe(m,y);if(w===null)return null;n.push(...w)}return n}function oe(t,n){let o=ae(n);if(!o)return null;let{ver:r,partial:l}=o;switch(t){case"^":{let m=ie(r);return m?[{op:">=",ver:r},{op:"<",ver:m}]:null}case"~":{let m=l>=2?{major:r.major,minor:r.minor+1,patch:0,pre:[]}:{major:r.major+1,minor:0,patch:0,pre:[]};return[{op:">=",ver:r},{op:"<",ver:m}]}case">=":return[{op:">=",ver:r}];case">":return l===1?[{op:">=",ver:{major:r.major+1,minor:0,patch:0,pre:[]}}]:l===2?[{op:">=",ver:{major:r.major,minor:r.minor+1,patch:0,pre:[]}}]:[{op:">",ver:r}];case"<":return l===1?[{op:"<",ver:{major:r.major,minor:0,patch:0,pre:[]}}]:l===2?[{op:"<",ver:{major:r.major,minor:r.minor,patch:0,pre:[]}}]:[{op:"<",ver:r}];case"<=":return[{op:"<=",ver:r}];case"=":case void 0:return l===1?[{op:">=",ver:r},{op:"<",ver:{major:r.major+1,minor:0,patch:0,pre:[]}}]:l===2?[{op:">=",ver:r},{op:"<",ver:{major:r.major,minor:r.minor+1,patch:0,pre:[]}}]:[{op:"=",ver:r}];default:return null}}function ie(t){return t.major>0?{major:t.major+1,minor:0,patch:0,pre:[]}:t.minor>0?{major:0,minor:t.minor+1,patch:0,pre:[]}:{major:0,minor:0,patch:t.patch+1,pre:[]}}function ae(t){let n=t.replace(/^v/,"").trim();if(!n||n==="*"||n==="x"||n==="X")return{ver:{major:0,minor:0,patch:0,pre:[]},partial:0};let o=n.split("."),r=[],l=0;for(let w of o.slice(0,3))if(/^\\d+$/.test(w))r.push(Number(w)),l++;else{if(w==="x"||w==="X"||w==="*")break;break}let m=n.split("-"),y=m.length>1?m.slice(1).join("-").split("+")[0].split("."):[];return l===0&&y.length===0?{ver:{major:0,minor:0,patch:0,pre:[]},partial:0}:{ver:{major:r[0]??0,minor:r[1]??0,patch:r[2]??0,pre:y},partial:l}}function se(t,n){switch(n){case">=":return t>=0;case">":return t>0;case"<":return t<0;case"<=":return t<=0;case"=":return t===0}}function ue(t,n,o){let r=`${t.major}.${t.minor}.${t.patch}`+(t.pre.length?`-${t.pre.join(".")}`:"");if(o.upper)return!(!(T(r,`${o.ver.major}.${o.ver.minor}.${o.ver.patch}`+(o.ver.pre.length?`-${o.ver.pre.join(".")}`:""))>=0)||!(T(r,`${o.upper.major}.${o.upper.minor}.${o.upper.patch}`)<0));let l=T(r,`${o.ver.major}.${o.ver.minor}.${o.ver.patch}`+(o.ver.pre.length?`-${o.ver.pre.join(".")}`:"")),m=se(l,o.op);return o.ver.pre.length>0&&t.pre.length===0&&(o.op===">"||o.op==="<")?!1:m}var g=class extends Error{code;details;constructor(n,o,r){super(`[fulgur:${n}] ${o}`),this.name="FulgurError",this.code=n,this.details=r}},R={REMOTE_LOAD_FAILED:"MFU-001",REMOTE_NAME_MISMATCH:"MFU-002",SHARE_STRICT_VERSION:"MFU-003",SHARE_NOT_AVAILABLE:"MFU-004",CONTAINER_REINIT_CONFLICT:"MFU-005",MODULE_NOT_EXPOSED:"MFU-006",PRELOAD_FAILED:"MFU-007",REMOTE_UNKNOWN:"MFU-008",EMPTY_EXPORTS:"MFU-009",SINGLETON_SKEW:"MFU-010"};var F="0.4.2";var U=15e3,P=2,ce=5,le=3e4;function fe(){let t={},n=new Map,o=[],r=new Map,l=new WeakMap,m={};function y(e){m={...m,...e},typeof globalThis<"u"&&(globalThis.__FULGUR_APP_CONFIG__=m)}function w(){return m}let M={},D=()=>{for(let e of o)try{e.init?.(M)}catch(i){console.warn("[fulgur] runtimePlugin init failed:",e.name,i)}},I=e=>t[e]??={};function $(e){try{M.onRemoteError?.(e)}catch{}typeof window<"u"&&window.dispatchEvent(new CustomEvent("fulgur:error",{detail:e}))}function H(e="default"){return I(e),t}function K(e,i,a,u,E={}){let s=I(e||"default"),c=s[i]??={};c[a]||(c[a]={version:a,get:u,from:E.from??"unknown",eager:!!E.eager,loaded:!!E.loaded})}function x(e){for(let i of e){let a=n.get(i.name);n.set(i.name,{timeout:U,retries:P,...a,...i,state:a?.state??"idle",breakerState:a?.breakerState??{fails:0,openUntil:0},debug:a?.debug??{entry:i.entry,status:"idle"}})}}function q(e){x([e])}function G(e){o.push(...e),D()}async function z(e,i={}){let a=i.shareScope||"default",u=i.shareKey||e,s=I(a)[u]||{},c=Object.keys(s),d=i.requiredVersion,f=c.filter(p=>d===void 0||d===!1||N(p,d)),b;if(i.singleton&&c.length>0){let p=c.filter(h=>s[h].loaded);if(b=[...p.length?p:c].sort(T).pop(),c.length>1||!f.includes(b)){let h=s[b],O=`singleton skew "${u}": req "${d??"any"}" use ${b} from ${h.from}`;if(i.strictVersion){let v=new g(R.SHARE_STRICT_VERSION,O,{shareKey:u,requiredVersion:d});throw $({remote:h.from,error:v}),v}console.warn(`[fulgur:MFU-010] ${O}`)}}else if(b=[...f].sort(T).pop(),!b){if(i.strictVersion){let h=new g(R.SHARE_STRICT_VERSION,`no satisfying version for "${u}" (required "${d}") in share scope "${a}"`);throw $({remote:u,error:h}),h}if(i.fallback)return i.fallback();let p=new g(R.SHARE_NOT_AVAILABLE,`shared "${u}" (${d??"any"}) unavailable in scope "${a}" (no local fallback)`,{shareKey:u,requiredVersion:d});throw $({remote:u,error:p}),p}let _=s[b];if(M.resolveShare){let p=await M.resolveShare({shareKey:u,shareScope:a,requiredVersion:d,picked:_,available:Object.values(s)});p&&(_=p)}return _.loaded=!0,_.get()}function W(e,i,a){return new Promise((u,E)=>{let s=setTimeout(()=>E(new Error(`timeout after ${i}ms: ${a}`)),i);e.then(c=>{clearTimeout(s),u(c)},c=>{clearTimeout(s),E(c)})})}let B=e=>new Promise(i=>setTimeout(i,e));function j(e,i){if(!e||typeof e.get!="function")throw new Error(`remoteEntry of "${i.name}" does not export a container interface (get/init)`);if(e.name&&i.name&&e.name!==i.name){let a=`remoteEntry self-reported name "${e.name}" mismatches configured name "${i.name}"`;if(i.promise)console.warn(`[fulgur] ${a} (promise-based remote, continuing)`);else throw Object.assign(new Error(a),{code:R.REMOTE_NAME_MISMATCH})}}async function L(e,i){return W(import(e),i.timeout??U,`load remoteEntry ${e}`)}async function C(e,i){let a=e.shareScope||"default";if(e.container){let s=l.get(e.container);if(s&&s!==a)throw new g(R.CONTAINER_REINIT_CONFLICT,`container "${e.name}" already initialized with share scope "${s}", cannot re-init with "${a}"`);return e.container}if(e.containerPromise)return e.containerPromise;let u=e.breakerState;if(u.openUntil>Date.now()){let s=new g(R.REMOTE_LOAD_FAILED,`circuit breaker open for remote "${e.name}" until ${new Date(u.openUntil).toISOString()}`,{remote:e.name});throw $({remote:e.name,error:s}),s}e.state="loading",e.debug.status="loading";let E=(async()=>{let s=[];if(e.promise)s.push(async()=>{let p=await e.promise(),h=typeof p=="string"?await L(p,e):p;return j(h,e),h});else for(let p of[e.entry,...e.fallback??[]])s.push(async()=>{let h=await L(p,e);return j(h,e),h});let c,d,f=!1,b=i?.retries??e.retries??P;for(let p of s){for(let h=0;h<=b;h++){let O=performance.now();try{c=await p(),e.lastLoadMs=Math.round(performance.now()-O),e.debug.lastLoadMs=e.lastLoadMs,f=!0;break}catch(v){if(d=v,v?.code)throw v;h<b&&await B(200*2**h)}}if(f)break}if(!f||!c){let p=[];throw/^https?:\\/\\//.test(e.entry)&&typeof location<"u"?(p.push(`1. is the remote dev server running?  try opening ${e.entry} in the browser \\u2014 it must return JS, not HTML/an error`),p.push("2. is the URL correct in federation({ remotes })?  dev and prod entries can differ"),p.push("3. CORS: the remote dev server must allow cross-origin requests (fulgur-federation enables server.cors automatically; a custom server config may have disabled it)")):(p.push(`1. is the remote deployed and reachable?  try opening ${e.entry} in the browser \\u2014 it must return JS`),p.push("2. NGINX/CDN routing: the entry path must serve the remoteEntry JS file (check try_files / fallback rules)")),new g(R.REMOTE_LOAD_FAILED,`failed to load remote "${e.name}" from ${e.entry}: ${String(d?.message??d)}\n`+p.join(`\n`),{remote:e.name})}j(c,e);let _=l.get(c);if(_&&_!==a)throw new g(R.CONTAINER_REINIT_CONFLICT,`container "${e.name}" already initialized with share scope "${_}", cannot re-init with "${a}"`);return typeof c.init=="function"&&await c.init(t),l.set(c,a),e.container=c,e.state="loaded",e.debug.status="loaded",u.fails=0,c})();e.containerPromise=E;try{return await E}catch(s){if(e.containerPromise=void 0,e.state="failed",e.debug.status="failed",e.debug.error=String(s?.message??s),u.fails+=1,u.fails>=ce&&(u.openUntil=Date.now()+le,u.fails=0),s instanceof g)throw $({remote:e.name,error:s}),s;if(s?.code)throw $({remote:e.name,error:s}),s;let c=new g(R.REMOTE_LOAD_FAILED,String(s?.message??s),{remote:e.name});throw $({remote:e.name,error:c}),c}}function A(e){let i=e.indexOf("/");return i===-1?{remote:e,module:""}:{remote:e.slice(0,i),module:X(e.slice(i+1))}}function X(e){return e?e.startsWith(".")?e:`./${e}`:""}async function J(e,i){let{remote:a,module:u}=A(e);M.beforeLoadRemote?.({remote:a,module:u});let E=n.get(a);if(!E)throw new g(R.REMOTE_UNKNOWN,`unknown remote "${a}". Register it via federation({ remotes }) or registerRemote().`,{remote:a});let s;try{s=await C(E,{retries:i?.retries})}catch(f){if(i?.fallbackModule)return console.error(`[fulgur] loadRemote("${e}") failed; returning fallbackModule (\\u663E\\u5F0F\\u964D\\u7EA7\\uFF0C\\u9519\\u8BEF\\u5DF2\\u900F\\u51FA)`,f),$({remote:a,error:f}),await i.fallbackModule();throw f}if(!u)return s;let c=`${a}@${E.shareScope||"default"}#${u}`;r.has(c)||r.set(c,s.get(u).catch(f=>{throw r.delete(c),f instanceof g||f?.code?f:new g(R.REMOTE_LOAD_FAILED,`failed to load module "${u}" from remote "${a}": ${String(f?.message??f)}`,{remote:a,module:u})}));let d;try{d=await r.get(c)}catch(f){if(i?.fallbackModule)return console.error(`[fulgur] loadRemote("${e}") failed; returning fallbackModule (\\u663E\\u5F0F\\u964D\\u7EA7\\uFF0C\\u9519\\u8BEF\\u5DF2\\u900F\\u51FA)`,f),$({remote:a,error:f}),await i.fallbackModule();throw f}if(M.afterLoadRemote?.({remote:a,module:u,module_ns:d}),d&&typeof d=="object"&&Object.keys(d).length===0){let f=new g(R.EMPTY_EXPORTS,`no exports: ${u} @ ${a}`,{remote:a,module:u});$({remote:a,error:f}),console.error(`[fulgur:MFU-009] ${f.message}`)}return d}function Y(e){let i=n.get(e);if(!i)throw new g(R.REMOTE_UNKNOWN,`unknown remote "${e}"`,{remote:e});return C(i)}async function Z(e,i={}){let{remote:a}=A(e),u=n.get(a);if(!u)throw new g(R.REMOTE_UNKNOWN,`unknown remote "${a}"`,{remote:a});let E=i.mode??"preload",s=(c,d)=>{if(typeof document>"u"||document.querySelector(`link[href="${c}"]`))return;let f=document.createElement("link");f.rel=d==="style"?"stylesheet":"modulepreload",f.href=c,E==="prefetch"&&(f.fetchPriority="low"),document.head.appendChild(f)};try{if(u.manifestUrl){let c=await fetch(u.manifestUrl,{cache:"no-cache"});if(c.ok){let d=await c.json();s(u.entry,"modulepreload");let f=d.exposes??{};for(let b of Object.keys(f)){let _=f[b];_?.file&&s(new URL(_.file,u.entry).href,"modulepreload");for(let p of _?.css??[])s(new URL(p,u.entry).href,"style")}return}}s(u.entry,"modulepreload")}catch(c){$({remote:a,error:new g(R.PRELOAD_FAILED,String(c?.message??c),{remote:a})})}}return typeof window>"u"||(window.__FULGUR_SCOPE__=t,window.__FULGUR_INFO__={get remotes(){let e={};for(let[i,a]of n)e[i]={...a.debug,entry:a.entry};return e},errors:[]}),{shareScopeMap:t,initSharing:H,registerShare:K,registerRemotes:x,registerRemote:q,registerPlugins:G,loadShare:z,loadRemote:J,getContainer:Y,preloadRemote:Z,parseSpec:A,provideFulgurAppConfig:y,getFulgurAppConfig:w}}var V=globalThis,S=V.__FULGUR_RUNTIME__??fe();V.__FULGUR_RUNTIME__=S;try{Object.freeze(S)}catch{}var Re=F;function Se(){return S}var we=S.initSharing,be=S.registerShare,_e=S.registerRemotes,$e=S.registerRemote,Me=S.registerPlugins,ve=S.loadShare,Te=S.loadRemote,Oe=S.getContainer,ke=S.preloadRemote,Ne=S.shareScopeMap,Ie=S.provideFulgurAppConfig,je=S.getFulgurAppConfig;function Ae(t){if(t&&typeof t=="object"&&"default"in t){let n=t.default;return n!==void 0?n:t}return t}var xe=S;export{xe as default,Oe as getContainer,je as getFulgurAppConfig,Se as getRuntime,we as initSharing,Te as loadRemote,ve as loadShare,ke as preloadRemote,Ie as provideFulgurAppConfig,Me as registerPlugins,$e as registerRemote,_e as registerRemotes,be as registerShare,S as runtime,Ne as shareScopeMap,Ae as unwrapDefault,Re as version};\n';
+
+// src/index.ts
+function readRuntimeCode() {
+  return runtime_code_gen_default;
+}
+function normalizeBase(base) {
+  if (!base || base === "/") return "/";
+  return base.endsWith("/") ? base : `${base}/`;
+}
+var FULGUR_STUB_NAMESPACE = "fulgur-opt-stub";
+var nsExportCache = /* @__PURE__ */ new Map();
+function enumerateCjsExports(packageName, appRoot) {
+  const cached = nsExportCache.get(packageName);
+  if (cached) return cached;
+  let names = [];
+  try {
+    const appRequire = (0, import_node_module2.createRequire)(import_node_path5.default.join(appRoot, "package.json"));
+    const mod = appRequire(packageName);
+    names = Object.keys(mod);
+  } catch {
+    console.warn(
+      `[fulgur] cannot enumerate CJS exports of shared package "${packageName}" for the optimize-deps facade; the facade will export default only. If consumers destructure named exports from it, add this package to optimizeDeps.exclude to serve it through the transform pipeline instead.`
+    );
+  }
+  nsExportCache.set(packageName, names);
+  return names;
+}
+function injectInitScript(html, scriptSrc) {
+  const tag = `<script type="module" src="${scriptSrc}"></script>`;
+  const moduleScriptRe = /<script[^>]+type=["']module["'][^>]*>/;
+  const m = moduleScriptRe.exec(html);
+  if (m) {
+    return html.slice(0, m.index) + tag + html.slice(m.index);
+  }
+  if (html.includes("</head>")) {
+    return html.replace("</head>", `${tag}
+</head>`);
+  }
+  return tag + html;
+}
+function federation(options) {
+  const warnedUnknownPrefixes = /* @__PURE__ */ new Set();
+  let remoteSchemaPromise = null;
+  const state = {
+    command: "serve",
+    base: "/",
+    exposeAbsPaths: {},
+    exposeFiles: {},
+    resolvedSharedPaths: /* @__PURE__ */ new Map(),
+    entryAbsPaths: /* @__PURE__ */ new Set(),
+    entryInitInjected: /* @__PURE__ */ new Set()
+  };
+  const pre = {
+    name: "fulgur:core",
+    enforce: "pre",
+    async config(userConfig, env) {
+      state.command = env.command;
+      const root = import_node_path5.default.resolve(userConfig.root ?? process.cwd());
+      const normalized = normalizeOptions(options, root, env.command);
+      state.normalized = normalized;
+      const extra = {};
+      if (env.command === "serve" && normalized.exposes.length > 0 && normalized.devSharedSelf) {
+        const aliasToShare = /* @__PURE__ */ new Map();
+        for (const s of normalized.shared) {
+          if (s.import === false) continue;
+          for (const a of s.aliases) if (!a.includes("/")) aliasToShare.set(a, s);
+        }
+        if (aliasToShare.size > 0) {
+          const escapeRe = (v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          const filter = new RegExp(`^(${[...aliasToShare.keys()].map(escapeRe).join("|")})$`);
+          const devBase = normalizeBase(userConfig.base ?? "/");
+          const sharedExternal = {
+            name: "fulgur:optimize-shared-external",
+            setup(build) {
+              const facadeUrlFor = (shareKey) => `${devBase}@id/__x00__virtual:fulgur-shared-ns:${shareKey}?import`;
+              const b = build;
+              b.onResolve({ filter: /fulgur-shared-ns:/ }, (args) => ({ path: args.path, external: true }));
+              b.onResolve({ filter }, (args) => {
+                if (args.kind === "entry-point" || args.kind === "entry-point-render") return null;
+                const s = aliasToShare.get(args.path);
+                if (!s) return null;
+                return { path: `fulgur-stub:${s.shareKey}`, namespace: FULGUR_STUB_NAMESPACE };
+              });
+              b.onLoad({ filter: /^fulgur-stub:/, namespace: FULGUR_STUB_NAMESPACE }, (args) => {
+                const shareKey = args.path.slice("fulgur-stub:".length);
+                const url = facadeUrlFor(shareKey);
+                return {
+                  contents: `export * from ${JSON.stringify(url)};
+export { default } from ${JSON.stringify(url)};
+`,
+                  loader: "js"
+                };
+              });
+            }
+          };
+          extra.optimizeDeps = {
+            esbuildOptions: { plugins: [sharedExternal] }
+          };
+        }
+      }
+      if (env.command === "serve") {
+        syncViteCacheMarker(root, normalized.pluginVersion, (msg) => console.warn(msg));
+        extra.server = {
+          ...userConfig.server ?? {},
+          cors: userConfig.server?.cors ?? true
+        };
+      } else {
+        const userTarget = userConfig.build?.target;
+        if (userTarget) {
+          if (/es20(0\d|1\d|20|21)/.test(String(userTarget))) {
+            normalized.warnings.push(
+              `build.target="${String(userTarget)}" does not support top-level await; fulgur requires es2022 or higher.`
+            );
+          }
+        } else {
+          ;
+          extra.build = { target: "es2022" };
+        }
+      }
+      for (const w of normalized.warnings) console.warn(`[fulgur] ${w}`);
+      return extra;
+    },
+    configResolved(resolved) {
+      state.base = normalizeBase(resolved.base);
+      if (resolved.build?.ssr) {
+        console.warn("[fulgur] SSR builds are not supported in this version; plugin hooks disabled.");
+      }
+      const n0 = state.normalized;
+      const optimize = resolved.optimizeDeps;
+      if (n0 && optimize) {
+        const include = optimize.include ?? [];
+        const exclude = optimize.exclude ?? [];
+        const excl = (pkg) => exclude.some((e) => e === pkg || e.startsWith(pkg + "/") || e.startsWith(pkg + ">"));
+        const incl = (pkg) => include.some((e) => e === pkg || e.startsWith(pkg + "/") || e.startsWith(pkg + ">"));
+        const KNOWN_UMD = ["@smallwei/avue"];
+        for (const pkg of KNOWN_UMD) {
+          if (n0.pkgDependencies[pkg] && !incl(pkg) && !excl(pkg)) {
+            console.warn(
+              formatFulgurDiagnostic({
+                code: "DEV-004",
+                symptom: `UMD-only \u4F9D\u8D56 "${pkg}" \u4E0D\u5728 optimizeDeps.include`,
+                cause: "UMD \u5305\u53EA\u80FD\u7ECF\u9884\u6784\u5EFA\u6D88\u8D39\uFF1B\u4E0D\u58F0\u660E\u4F1A\u88AB\u88F8 CJS \u670D\u52A1\u6216\u5185\u8054\u672C\u5730 vue\uFF08\u9875\u9762\u7A7A\u767D/\u53CC\u5B9E\u4F8B\uFF09",
+                fix: `\u52A0\u5165 optimizeDeps.include: ['${pkg}']`,
+                details: { pkg }
+              })
+            );
+          }
+        }
+      }
+    },
+    resolveId(source) {
+      let s = source;
+      if (s.startsWith("/@id/")) s = s.slice(5);
+      if (s.startsWith("__x00__")) s = "\0" + s.slice(7);
+      const q = s.indexOf("?");
+      const bare = q === -1 ? s : s.slice(0, q);
+      const query = q === -1 ? "" : s.slice(q);
+      const bareClean = bare.startsWith("\0") ? bare.slice(1) : bare;
+      const n = state.normalized;
+      if (n && !bareClean.startsWith("\0") && !bareClean.startsWith(".") && !bareClean.startsWith("/") && !bareClean.startsWith("virtual:")) {
+        const slash = bareClean.indexOf("/");
+        if (slash > 0) {
+          const prefix = bareClean.slice(0, slash);
+          const known = n.remotes.some((r) => r.key === prefix) || n.shared.some((sh) => sh.aliases.includes(prefix) || sh.aliases.some((a) => a.endsWith("/") && prefix.startsWith(a)));
+          if (!known && !warnedUnknownPrefixes.has(prefix)) {
+            warnedUnknownPrefixes.add(prefix);
+            console.warn(
+              `[fulgur] "${source}" uses prefix "${prefix}/", which is not in federation({ remotes }) or shared. If "${prefix}" is a federated remote, add it: remotes: { '${prefix}': '<url>' }. (Ignore this if it is a plain npm package.)`
+            );
+          }
+        }
+      }
+      if (bareClean === RUNTIME_VIRTUAL_ID) return RESOLVED.runtime;
+      if (bareClean === RUNTIME_PROXY_VIRTUAL_ID) return RESOLVED.runtimeProxy;
+      if (bareClean === INIT_VIRTUAL_ID) return RESOLVED.init;
+      if (bareClean === "virtual:fulgur-remote-schema") return bareClean;
+      if (bareClean === "virtual:fulgur-provides") return RESOLVED.provides;
+      if (bareClean === "virtual:fulgur-remote-entry") return RESOLVED.remoteEntry;
+      if (bareClean.startsWith(SHARED_NS_FACADE_PREFIX)) {
+        return RESOLVED.sharedNsFacade(bareClean.slice(SHARED_NS_FACADE_PREFIX.length)) + query;
+      }
+      if (bareClean.startsWith("virtual:fulgur-cjs-ns:")) {
+        return RESOLVED.sharedNsFacade(bareClean.slice("virtual:fulgur-cjs-ns:".length)) + query;
+      }
+      if (bareClean.startsWith("virtual:fulgur-shared:")) {
+        const body = bareClean.slice("virtual:fulgur-shared:".length);
+        return RESOLVED.sharedFacade(body) + query;
+      }
+      return null;
+    },
+    load(id) {
+      const raw = id.startsWith("\0") ? id.slice(1) : id;
+      const q = raw.indexOf("?");
+      const clean = q === -1 ? raw : raw.slice(0, q);
+      if (clean === "virtual:fulgur-runtime") return readRuntimeCode();
+      if (clean === RESOLVED.runtimeProxy || clean === RUNTIME_PROXY_VIRTUAL_ID) return genRuntimeProxyModule();
+      if (clean === "virtual:fulgur-init" && state.normalized) {
+        return genInitModule(state.normalized, state.command);
+      }
+      if (clean === "virtual:fulgur-provides" && state.normalized) {
+        return genDevProvides(state.normalized);
+      }
+      if (clean === "virtual:fulgur-remote-schema" && state.normalized) {
+        if (state.command === "build") return genEmptyRemoteSchemaModule();
+        remoteSchemaPromise ??= probeRemotesAndBuildSchema(state.normalized).then(
+          (schema) => `export default ${JSON.stringify(schema)}`
+        );
+        return remoteSchemaPromise;
+      }
+      if (clean === "virtual:fulgur-remote-entry" && state.normalized) {
+        return genBuildRemoteEntry(state.normalized, state.exposeAbsPaths);
+      }
+      if (clean.startsWith(SHARED_NS_FACADE_PREFIX) && state.normalized) {
+        const body = clean.slice(SHARED_NS_FACADE_PREFIX.length);
+        const item = state.normalized.shared.find((x) => x.shareKey === body);
+        if (!item || item.import === false) return null;
+        const names = enumerateCjsExports(item.import, state.normalized.root);
+        if (item.shareKey === "vue") {
+          for (const compat of ["isVue2", "isVue3", "Vue2", "set", "del"]) {
+            if (!names.includes(compat)) names.push(compat);
+          }
+        }
+        return genSharedNsFacade(item, serializeShareCallForFacade(item), names);
+      }
+      if (clean.startsWith("virtual:fulgur-shared:") && state.normalized) {
+        const body = clean.slice("virtual:fulgur-shared:".length);
+        const f = raw.indexOf("?f=");
+        if (f === -1) {
+          const item2 = state.normalized.shared.find((x) => x.shareKey === body);
+          if (item2 && item2.import !== false) {
+            const names = /^(\.|\/)/.test(item2.import) ? [] : enumerateCjsExports(item2.import, state.normalized.root);
+            return genSharedFacade(item2.import, names);
+          }
+          return null;
+        }
+        const entry = getFacadeEntry(raw.slice(f + 3));
+        if (!entry) return null;
+        if (entry.remoteName && entry.exposeName) {
+          return genRemoteBindingFacade(entry.remoteName + "/" + entry.exposeName, entry.bindings);
+        }
+        const item = state.normalized.shared.find((x) => x.shareKey === entry.shareKey);
+        if (!item || item.import === false) return null;
+        const opts = [
+          "shareScope: " + JSON.stringify(item.shareScope),
+          "shareKey: " + JSON.stringify(item.shareKey),
+          ...item.requiredVersion !== false ? ["requiredVersion: " + JSON.stringify(item.requiredVersion)] : [],
+          ...item.singleton ? ["singleton: true"] : [],
+          ...item.strictVersion ? ["strictVersion: true"] : [],
+          "fallback: () => import(" + JSON.stringify(item.import) + ")"
+        ];
+        const call = "__fulgur_loadShare(" + JSON.stringify(item.shareKey) + ", { " + opts.join(", ") + " })";
+        return genBindingFacade(item, entry.bindings, call);
+      }
+      return null;
+    },
+    async transform(code, id) {
+      if (!state.normalized) return null;
+      const clean = id.split("?")[0];
+      if (state.command === "build" && state.entryAbsPaths.has(clean) && !state.entryInitInjected.has(clean)) {
+        state.entryInitInjected.add(clean);
+        const initCode = genInitModule(state.normalized, state.command);
+        return { code: `${initCode}
+${code}`, map: null };
+      }
+      const isPureRemoteBuild = state.normalized.exposes.length > 0 && state.normalized.remotes.length === 0;
+      const allowNodeModules = state.normalized.devSharedSelf || isPureRemoteBuild;
+      if (/\.vue(\?|$)/.test(id)) {
+        if (state.command === "build" && /type=script/.test(id)) {
+          return transformModule(code, id, {
+            options: state.normalized,
+            rewriteShared: true,
+            allowNodeModules,
+            cjsRequireRewrite: true
+          });
+        }
+        return null;
+      }
+      if (!isTransformableId(id, allowNodeModules)) return null;
+      return transformModule(code, id, {
+        options: state.normalized,
+        // build：全量改写；dev：默认仅纯 remote 改写 shared（被宿主消费的组件需协商到宿主实例），
+        // 双角色宿主可显式 devSharedSelf: true 参与协商
+        rewriteShared: state.command === "build" || state.normalized.devSharedSelf,
+        allowNodeModules,
+        cjsRequireRewrite: state.command === "build"
+      });
+    },
+    transformIndexHtml: {
+      order: "pre",
+      handler(html) {
+        if (!state.normalized) return html;
+        if (state.command === "serve") {
+          const src = `/@id/__x00__${INIT_VIRTUAL_ID}?import`;
+          return injectInitScript(html, src);
+        }
+        const moduleScriptRe = /<script[^>]+type=["']module["'][^>]*>/g;
+        const srcRe = /src=["']([^"']+)["']/;
+        for (const tag of html.match(moduleScriptRe) ?? []) {
+          const src = srcRe.exec(tag)?.[1];
+          if (!src || src.startsWith("http") || src.startsWith("//")) continue;
+          const abs = import_node_path5.default.resolve(state.normalized.root, src.startsWith("/") ? src.slice(1) : src);
+          state.entryAbsPaths.add(abs);
+        }
+        return html;
+      }
+    },
+    async buildStart() {
+      if (state.command !== "build" || !state.normalized) return;
+      const n = state.normalized;
+      if (n.exposes.length > 0) {
+        for (const e of n.exposes) {
+          const resolved = await this.resolve(e.import, import_node_path5.default.join(n.root, "index.html"));
+          if (resolved) {
+            state.exposeAbsPaths[e.import] = resolved.id.split("?")[0];
+          } else {
+            this.error(`[fulgur] expose "${e.import}" could not be resolved from ${n.root}`);
+          }
+        }
+        this.emitFile({
+          type: "chunk",
+          id: "virtual:fulgur-remote-entry",
+          fileName: n.filename.replace(/^\//, ""),
+          preserveSignature: "allow-extension"
+        });
+      }
+    },
+    async generateBundle(_opts, bundle) {
+      const n = state.normalized;
+      if (state.command !== "build" || !n || n.exposes.length === 0 || !n.manifest) return;
+      const facadeToChunk = {};
+      for (const [fileName, chunk] of Object.entries(bundle)) {
+        if (chunk.type !== "chunk") continue;
+        const facade = chunk.facadeModuleId?.split("?")[0];
+        if (facade) {
+          const viteMeta = chunk.viteMetadata;
+          facadeToChunk[facade] = {
+            file: fileName,
+            css: viteMeta ? [...viteMeta.importedCss ?? []] : []
+          };
+        }
+      }
+      for (const e of n.exposes) {
+        const abs = state.exposeAbsPaths[e.import];
+        const hit = abs ? facadeToChunk[abs] : void 0;
+        if (hit) state.exposeFiles[e.name] = hit;
+      }
+      const entryChunkName = Object.keys(bundle).find((k) => bundle[k].type === "chunk" && k === n.filename);
+      const manifest = genProdManifest(n, state.exposeFiles, entryChunkName ?? n.filename);
+      this.emitFile({
+        type: "asset",
+        fileName: "fulgur-manifest.json",
+        source: JSON.stringify(manifest, null, 2)
+      });
+    },
+    configureServer(server) {
+      const n = state.normalized;
+      if (!n) return;
+      warmResolvedSharedPaths(server);
+      if (n.exposes.length > 0 || n.remotes.length > 0) {
+        console.warn(
+          formatFulgurDiagnostic({
+            code: "DEV-010",
+            symptom: 'dev \u51B7\u542F\u52A8\u9884\u6784\u5EFA\u7A97\u53E3\uFF1A\u9996\u6B21\u542F\u52A8\u6216\u6E05 node_modules/.vite \u540E\u9996\u8F6E 30~60s \u5185\uFF0C\u8054\u90A6\u6A21\u5757\u8BF7\u6C42\u53EF\u80FD\u51FA\u73B0\u77AC\u65F6 504 / "ce" / Outdated Optimize Dep',
+            cause: "vite \u4F9D\u8D56\u9884\u6784\u5EFA\uFF08\u542B fulgur \u5916\u90E8\u5316\u6869\uFF09\u5C1A\u672A\u5C31\u7EEA\uFF0C\u5C5E\u9884\u6784\u5EFA\u6682\u6001\u800C\u975E\u56DE\u5F52\uFF1B\u9996\u8F6E\u7ED3\u675F\u540E\u81EA\u884C\u6062\u590D",
+            fix: "\u5148\u771F\u5B9E\u6253\u5F00\u4E00\u6B21\u9875\u9762\u9884\u70ED\uFF08\u7B49\u5230\u7F51\u7EDC\u7A7A\u95F2\uFF09\uFF0C\u518D\u505A\u9A8C\u6536\u65AD\u8A00\u6216\u4EBA\u5DE5\u5224\u65AD\uFF1B\u91CD\u590D\u51FA\u73B0\u624D\u6309 DEV-009 \u6E05\u7F13\u5B58\u6392\u67E5"
+          })
+        );
+      }
+      if (n.exposes.length > 0) {
+        const baseNorm = state.base;
+        server.middlewares.use((req, res, next) => {
+          const raw = (req.url ?? "").split("?")[0];
+          const stripped = raw.startsWith(baseNorm) ? `/${raw.slice(baseNorm.length)}` : raw;
+          if (stripped === "/@fulgur-entry.js" || stripped === "/@fulgur-manifest.json") {
+            res.setHeader("Access-Control-Allow-Origin", "*");
+            res.setHeader("Access-Control-Allow-Methods", "GET,OPTIONS");
+            res.setHeader("Access-Control-Allow-Headers", "*");
+            if (req.method === "OPTIONS") {
+              res.statusCode = 204;
+              res.end();
+              return;
+            }
+            if (stripped === "/@fulgur-entry.js") {
+              res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+              res.setHeader("Cache-Control", "no-cache");
+              res.end(genDevRemoteEntry(n, baseNorm));
+              return;
+            }
+            res.setHeader("Content-Type", "application/json; charset=utf-8");
+            res.end(JSON.stringify(genDevManifest(n, baseNorm)));
+            return;
+          }
+          next();
+        });
+      }
+      if (n.remotes.length > 0 && n.dts) {
+        server.httpServer?.once("listening", () => {
+          void generateDevTypes(n, server);
+        });
+      }
+      if (n.remotes.length > 0) {
+        server.httpServer?.once("listening", () => {
+          setTimeout(() => {
+            remoteSchemaPromise ??= probeRemotesAndBuildSchema(n).then(
+              (schema) => `export default ${JSON.stringify(schema)}`
+            );
+          }, 5e3);
+        });
+      }
+      return () => {
+        server.middlewares.use((req, res, next) => {
+          const url = req.url ?? "";
+          if (req.method === "GET" && url.includes("fulgur")) {
+            res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+            res.end(
+              formatFulgurDiagnostic({
+                code: "DEV-009",
+                symptom: `\u8054\u90A6\u6A21\u5757\u8BF7\u6C42 404\uFF1A${url.slice(0, 120)}`,
+                cause: "node_modules/.vite \u9884\u6784\u5EFA\u7F13\u5B58\u4E0E\u5F53\u524D\u63D2\u4EF6\u4EA7\u7269\u4E0D\u4E00\u81F4\uFF08immutable \u7F13\u5B58\u6309 ?f= \u7B7E\u540D\u957F\u671F\u6301\u6709\uFF0C\u63D2\u4EF6 dist \u66F4\u65B0\u540E\u65E7\u7B7E\u540D\u5FC5 404\uFF09",
+                fix: "rm -rf node_modules/.vite \u540E\u91CD\u542F dev server\uFF0C\u5E76\u66F4\u6362\u5168\u65B0\u6D4F\u89C8\u5668 profile\uFF08\u6D4F\u89C8\u5668\u4E5F\u6301\u6709\u65E7\u7F13\u5B58\uFF09"
+              })
+            );
+            return;
+          }
+          next();
+        });
+      };
+    }
+  };
+  const post = {
+    name: "fulgur:vue-post",
+    enforce: "post",
+    async transform(code, id) {
+      if (!state.normalized) return null;
+      const clean = id.split("?")[0];
+      if (state.command === "serve" && code.includes("virtual:fulgur-runtime") && !code.includes("virtual:fulgur-runtime-proxy") && isExposeTargetFile(clean, state.normalized.root, state.normalized.exposes)) {
+        return { code: code.split("virtual:fulgur-runtime").join("virtual:fulgur-runtime-proxy"), map: null };
+      }
+      if (code.includes("virtual:fulgur-runtime")) return null;
+      if (state.command === "build" && !/\.vue(\?|$)/.test(id)) return null;
+      if (/type=(style|template)/.test(id)) return null;
+      const isJsLike = /\.(m|c)?[jt]sx?$/.test(clean) || clean.endsWith(".vue");
+      if (!isJsLike) return null;
+      const devRewriteAll = state.command === "serve" && state.normalized.devSharedSelf;
+      if (clean.includes("node_modules") && !id.includes(".vite/deps") && !devRewriteAll) return null;
+      const rewriteShared = state.command === "build" || state.normalized.devSharedSelf;
+      const remapSpecifier = (spec) => {
+        if (state.normalized.shared.some((s) => s.aliases.includes(spec))) return spec;
+        const depMatch = spec.match(/\/node_modules\/\.vite\/deps\/([^/?]+)\.js/);
+        if (depMatch) {
+          const depName = depMatch[1];
+          return state.normalized.shared.some((s) => s.aliases.includes(depName)) ? depName : null;
+        }
+        const cleanSpec = spec.startsWith("/@fs/") ? spec.slice(5) : spec;
+        const cleanPath = cleanSpec.split("?")[0];
+        if (!cleanPath.startsWith("/")) return null;
+        return state.resolvedSharedPaths.get(cleanPath) ?? null;
+      };
+      return transformModule(code, id, { options: state.normalized, remapSpecifier, rewriteShared });
+    }
+  };
+  function warmResolvedSharedPaths(server) {
+    const n = state.normalized;
+    if (!n) return;
+    for (const s of n.shared) {
+      if (s.import === false) continue;
+      void server.pluginContainer.resolveId(s.import, import_node_path5.default.join(n.root, "index.html")).then((r) => {
+        if (r?.id) state.resolvedSharedPaths.set(r.id.split("?")[0], s.configKey);
+      }).catch(() => {
+      });
+    }
+  }
+  return [pre, post];
+}
+var index_default = federation;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  federation
+});