@fulgurjs/federation 0.6.2 → 0.7.1

package/dist/vue.js

@@ -0,0 +1,760 @@
+import "./chunk-6EGDSX3S.js";
+
+// src/vue.ts
+import { defineAsyncComponent, defineComponent, h } from "vue";
+
+// src/semver.ts
+var VERSION_RE = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-((?:[0-9A-Za-z-]+)(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseVersion(input) {
+  const m = VERSION_RE.exec(String(input).trim());
+  if (!m) return null;
+  return {
+    major: Number(m[1]),
+    minor: Number(m[2] ?? 0),
+    patch: Number(m[3] ?? 0),
+    pre: m[4] ? m[4].split(".") : []
+  };
+}
+function preCompare(a, b) {
+  if (a.length === 0 && b.length === 0) return 0;
+  if (a.length === 0) return 1;
+  if (b.length === 0) return -1;
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    const xn = /^\d+$/.test(x);
+    const yn = /^\d+$/.test(y);
+    if (xn && yn) {
+      const d = Number(x) - Number(y);
+      if (d !== 0) return d;
+    } else if (xn !== yn) {
+      return xn ? -1 : 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function compareVersions(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (!va || !vb) return a < b ? -1 : a > b ? 1 : 0;
+  if (va.major !== vb.major) return va.major - vb.major;
+  if (va.minor !== vb.minor) return va.minor - vb.minor;
+  if (va.patch !== vb.patch) return va.patch - vb.patch;
+  return preCompare(va.pre, vb.pre);
+}
+var ANY_RANGE = /^[a-z]+[+:-]/i;
+function satisfies(version, range) {
+  if (range === false || range == null || range === "") return true;
+  const rangeStr = String(range).trim();
+  if (!rangeStr || rangeStr === "*" || rangeStr === "latest" || ANY_RANGE.test(rangeStr)) return true;
+  return rangeStr.split("||").some((part) => satisfiesSet(version, part.trim()));
+}
+function satisfiesSet(version, set) {
+  if (!set || set === "*") return !parseVersion(version)?.pre.length;
+  const hyphen = set.split(/\s+-\s+/);
+  if (hyphen.length === 2) {
+    const lo = hyphen[0].trim();
+    const hi = hyphen[1].trim();
+    if (!satisfies(version, `>=${lo}`)) return false;
+    if (!satisfies(version, `<=${hi}`)) return false;
+    return true;
+  }
+  const v = parseVersion(version);
+  if (!v) return false;
+  const comps = parseComparators(set);
+  if (comps === null) return true;
+  for (const c of comps) {
+    if (!testComparator(v, version, c)) return false;
+  }
+  if (v.pre.length > 0 && !comps.some((c) => c.ver.pre.length > 0)) {
+    const tupleMatch = comps.some(
+      (c) => c.ver.major === v.major && c.ver.minor === v.minor && c.ver.patch === v.patch
+    );
+    if (!tupleMatch) return false;
+  }
+  return true;
+}
+function parseComparators(set) {
+  const comps = [];
+  const tokens = set.trim().split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) return null;
+  for (const token of tokens) {
+    const m = /^(>=|<=|>|<|=|\^|~)?(.*)$/.exec(token);
+    if (!m) return null;
+    const op = m[1];
+    const raw = m[2];
+    const c = buildComparator(op, raw);
+    if (c === null) return null;
+    comps.push(...c);
+  }
+  return comps;
+}
+function buildComparator(op, raw) {
+  const parsed = parseLoose(raw);
+  if (!parsed) return null;
+  const { ver, partial } = parsed;
+  switch (op) {
+    case "^": {
+      const upper = caretUpper(ver);
+      if (!upper) return null;
+      return [{ op: ">=", ver }, { op: "<", ver: upper }];
+    }
+    case "~": {
+      const upper = partial >= 2 ? { major: ver.major, minor: ver.minor + 1, patch: 0, pre: [] } : { major: ver.major + 1, minor: 0, patch: 0, pre: [] };
+      return [{ op: ">=", ver }, { op: "<", ver: upper }];
+    }
+    case ">=":
+      return [{ op: ">=", ver }];
+    case ">":
+      if (partial === 1) return [{ op: ">=", ver: { major: ver.major + 1, minor: 0, patch: 0, pre: [] } }];
+      if (partial === 2)
+        return [{ op: ">=", ver: { major: ver.major, minor: ver.minor + 1, patch: 0, pre: [] } }];
+      return [{ op: ">", ver }];
+    case "<":
+      if (partial === 1) return [{ op: "<", ver: { major: ver.major, minor: 0, patch: 0, pre: [] } }];
+      if (partial === 2)
+        return [{ op: "<", ver: { major: ver.major, minor: ver.minor, patch: 0, pre: [] } }];
+      return [{ op: "<", ver }];
+    case "<=":
+      return [{ op: "<=", ver }];
+    case "=":
+    case void 0:
+      if (partial === 1)
+        return [
+          { op: ">=", ver },
+          { op: "<", ver: { major: ver.major + 1, minor: 0, patch: 0, pre: [] } }
+        ];
+      if (partial === 2)
+        return [
+          { op: ">=", ver },
+          { op: "<", ver: { major: ver.major, minor: ver.minor + 1, patch: 0, pre: [] } }
+        ];
+      return [{ op: "=", ver }];
+    default:
+      return null;
+  }
+}
+function caretUpper(ver) {
+  if (ver.major > 0) return { major: ver.major + 1, minor: 0, patch: 0, pre: [] };
+  if (ver.minor > 0) return { major: 0, minor: ver.minor + 1, patch: 0, pre: [] };
+  return { major: 0, minor: 0, patch: ver.patch + 1, pre: [] };
+}
+function parseLoose(raw) {
+  const cleaned = raw.replace(/^v/, "").trim();
+  if (!cleaned || cleaned === "*" || cleaned === "x" || cleaned === "X") {
+    return { ver: { major: 0, minor: 0, patch: 0, pre: [] }, partial: 0 };
+  }
+  const parts = cleaned.split(".");
+  const nums = [];
+  let partial = 0;
+  for (const p of parts.slice(0, 3)) {
+    if (/^\d+$/.test(p)) {
+      nums.push(Number(p));
+      partial++;
+    } else if (p === "x" || p === "X" || p === "*") {
+      break;
+    } else {
+      break;
+    }
+  }
+  const rest = cleaned.split("-");
+  const pre = rest.length > 1 ? rest.slice(1).join("-").split("+")[0].split(".") : [];
+  if (partial === 0 && pre.length === 0) return { ver: { major: 0, minor: 0, patch: 0, pre: [] }, partial: 0 };
+  return {
+    ver: { major: nums[0] ?? 0, minor: nums[1] ?? 0, patch: nums[2] ?? 0, pre },
+    partial
+  };
+}
+function cmpToBool(cmp, op) {
+  switch (op) {
+    case ">=":
+      return cmp >= 0;
+    case ">":
+      return cmp > 0;
+    case "<":
+      return cmp < 0;
+    case "<=":
+      return cmp <= 0;
+    case "=":
+      return cmp === 0;
+  }
+}
+function testComparator(v, versionStr, c) {
+  const full = `${v.major}.${v.minor}.${v.patch}` + (v.pre.length ? `-${v.pre.join(".")}` : "");
+  if (c.upper) {
+    const cmpLo = compareVersions(full, `${c.ver.major}.${c.ver.minor}.${c.ver.patch}` + (c.ver.pre.length ? `-${c.ver.pre.join(".")}` : ""));
+    if (!(cmpLo >= 0)) return false;
+    const cmpHi = compareVersions(full, `${c.upper.major}.${c.upper.minor}.${c.upper.patch}`);
+    if (!(cmpHi < 0)) return false;
+    return true;
+  }
+  const cmp = compareVersions(full, `${c.ver.major}.${c.ver.minor}.${c.ver.patch}` + (c.ver.pre.length ? `-${c.ver.pre.join(".")}` : ""));
+  const baseOk = cmpToBool(cmp, c.op);
+  if (c.ver.pre.length > 0 && v.pre.length === 0 && (c.op === ">" || c.op === "<")) {
+    return false;
+  }
+  return baseOk;
+}
+
+// src/runtime/errors.ts
+var FulgurjsError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(`[fulgurjs:${code}] ${message}`);
+    this.name = "FulgurjsError";
+    this.code = code;
+    this.details = details;
+  }
+};
+var ErrorCodes = {
+  /** 远程容器加载失败（网络/超时/重试耗尽/熔断） */
+  REMOTE_LOAD_FAILED: "MFU-001",
+  /** remoteEntry 自报名与 remotes 配置的名称不匹配 */
+  REMOTE_NAME_MISMATCH: "MFU-002",
+  /** strictVersion 开启且共享版本不满足 */
+  SHARE_STRICT_VERSION: "MFU-003",
+  /** 共享模块缺失且无本地 fallback（import: false） */
+  SHARE_NOT_AVAILABLE: "MFU-004",
+  /** 同一容器用不同 share scope 重复 init */
+  CONTAINER_REINIT_CONFLICT: "MFU-005",
+  /** 请求的模块未被该远程 exposes */
+  MODULE_NOT_EXPOSED: "MFU-006",
+  /** 预加载失败 */
+  PRELOAD_FAILED: "MFU-007",
+  /** 未知远程 */
+  REMOTE_UNKNOWN: "MFU-008",
+  /** 加载到的模块没有任何导出（常见：exposes 指向了不导出内容的文件） */
+  EMPTY_EXPORTS: "MFU-009",
+  /** singleton 共享协商版本与消费方 requiredVersion 不一致（使用作用域版本，仅告警） */
+  SINGLETON_SKEW: "MFU-010"
+};
+
+// src/runtime/index.ts
+var DEFAULT_TIMEOUT = 15e3;
+var DEFAULT_RETRIES = 2;
+var BREAKER_THRESHOLD = 5;
+var BREAKER_RESET_MS = 3e4;
+function createRuntime() {
+  const shareScopeMap2 = {};
+  const remotes = /* @__PURE__ */ new Map();
+  const plugins = [];
+  const loadedModules = /* @__PURE__ */ new Map();
+  const containerInitScopes = /* @__PURE__ */ new WeakMap();
+  let fulgurjsAppConfig = {};
+  function provideFulgurjsAppConfig2(config) {
+    fulgurjsAppConfig = { ...fulgurjsAppConfig, ...config };
+    if (typeof globalThis !== "undefined") {
+      ;
+      globalThis.__FULGURJS_APP_CONFIG__ = fulgurjsAppConfig;
+    }
+  }
+  function getFulgurjsAppConfig2() {
+    return fulgurjsAppConfig;
+  }
+  const hooks = {};
+  const applyPlugins = () => {
+    for (const p of plugins) {
+      try {
+        p.init?.(hooks);
+      } catch (err) {
+        console.warn("[fulgurjs] runtimePlugin init failed:", p.name, err);
+      }
+    }
+  };
+  const getScope = (name) => shareScopeMap2[name] ??= {};
+  function emitError(info) {
+    try {
+      hooks.onRemoteError?.(info);
+    } catch {
+    }
+    if (typeof window !== "undefined") {
+      window.dispatchEvent(new CustomEvent("fulgurjs:error", { detail: info }));
+    }
+  }
+  function initSharing2(scopeName = "default") {
+    getScope(scopeName);
+    return shareScopeMap2;
+  }
+  function registerShare2(scopeName, name, version, get, opts = {}) {
+    const scope = getScope(scopeName || "default");
+    const byName = scope[name] ??= {};
+    if (byName[version]) {
+      return;
+    }
+    byName[version] = { version, get, from: opts.from ?? "unknown", eager: !!opts.eager, loaded: !!opts.loaded };
+  }
+  function registerRemotes2(list) {
+    for (const r of list) {
+      const prev = remotes.get(r.name);
+      remotes.set(r.name, {
+        timeout: DEFAULT_TIMEOUT,
+        retries: DEFAULT_RETRIES,
+        ...prev,
+        ...r,
+        state: prev?.state ?? "idle",
+        breakerState: prev?.breakerState ?? { fails: 0, openUntil: 0 },
+        debug: prev?.debug ?? { entry: r.entry, status: "idle" }
+      });
+    }
+  }
+  function registerRemote2(remote) {
+    registerRemotes2([remote]);
+  }
+  function registerPlugins2(list) {
+    plugins.push(...list);
+    applyPlugins();
+  }
+  async function loadShare2(name, opts = {}) {
+    const scopeName = opts.shareScope || "default";
+    const shareKey = opts.shareKey || name;
+    const scope = getScope(scopeName);
+    const byName = scope[shareKey] || {};
+    const versions = Object.keys(byName);
+    const req = opts.requiredVersion;
+    const satisfying = versions.filter(
+      (v) => req === void 0 || req === false || satisfies(v, req)
+    );
+    let pick;
+    if (opts.singleton && versions.length > 0) {
+      const loadedVersions = versions.filter((v) => byName[v].loaded);
+      pick = [...loadedVersions.length ? loadedVersions : versions].sort(compareVersions).pop();
+      if (versions.length > 1 || !satisfying.includes(pick)) {
+        const entry0 = byName[pick];
+        const msg = `singleton skew "${shareKey}": req "${req ?? "any"}" use ${pick} from ${entry0.from}`;
+        if (opts.strictVersion) {
+          const err = new FulgurjsError(ErrorCodes.SHARE_STRICT_VERSION, msg, {
+            shareKey,
+            requiredVersion: req
+          });
+          emitError({ remote: entry0.from, error: err });
+          throw err;
+        }
+        console.warn(`[fulgurjs:MFU-010] ${msg}`);
+      }
+    } else {
+      pick = [...satisfying].sort(compareVersions).pop();
+      if (!pick) {
+        if (opts.strictVersion) {
+          const err2 = new FulgurjsError(
+            ErrorCodes.SHARE_STRICT_VERSION,
+            `no satisfying version for "${shareKey}" (required "${req}") in share scope "${scopeName}"`
+          );
+          emitError({ remote: shareKey, error: err2 });
+          throw err2;
+        }
+        if (opts.fallback) return opts.fallback();
+        const err = new FulgurjsError(
+          ErrorCodes.SHARE_NOT_AVAILABLE,
+          `shared "${shareKey}" (${req ?? "any"}) unavailable in scope "${scopeName}" (no local fallback)`,
+          { shareKey, requiredVersion: req }
+        );
+        emitError({ remote: shareKey, error: err });
+        throw err;
+      }
+    }
+    let entry = byName[pick];
+    if (hooks.resolveShare) {
+      const picked = await hooks.resolveShare({
+        shareKey,
+        shareScope: scopeName,
+        requiredVersion: req,
+        picked: entry,
+        available: Object.values(byName)
+      });
+      if (picked) entry = picked;
+    }
+    entry.loaded = true;
+    return entry.get();
+  }
+  function withTimeout(p, ms, label) {
+    return new Promise((resolve, reject) => {
+      const t = setTimeout(() => reject(new Error(`timeout after ${ms}ms: ${label}`)), ms);
+      p.then(
+        (v) => {
+          clearTimeout(t);
+          resolve(v);
+        },
+        (e) => {
+          clearTimeout(t);
+          reject(e);
+        }
+      );
+    });
+  }
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  function validateContainerInterface(container, remote) {
+    if (!container || typeof container.get !== "function") {
+      throw new Error(
+        `remoteEntry of "${remote.name}" does not export a container interface (get/init)`
+      );
+    }
+    if (container.name && remote.name && container.name !== remote.name) {
+      const msg = `remoteEntry self-reported name "${container.name}" mismatches configured name "${remote.name}"`;
+      if (remote.promise) {
+        console.warn(`[fulgurjs] ${msg} (promise-based remote, continuing)`);
+      } else {
+        throw Object.assign(new Error(msg), { code: ErrorCodes.REMOTE_NAME_MISMATCH });
+      }
+    }
+  }
+  async function importEntry(url, remote) {
+    return withTimeout(
+      import(
+        /* @vite-ignore */
+        url
+      ),
+      remote.timeout ?? DEFAULT_TIMEOUT,
+      `load remoteEntry ${url}`
+    );
+  }
+  async function acquireContainer(remote, overrides) {
+    const scopeKey = remote.shareScope || "default";
+    if (remote.container) {
+      const prevScope = containerInitScopes.get(remote.container);
+      if (prevScope && prevScope !== scopeKey) {
+        throw new FulgurjsError(
+          ErrorCodes.CONTAINER_REINIT_CONFLICT,
+          `container "${remote.name}" already initialized with share scope "${prevScope}", cannot re-init with "${scopeKey}"`
+        );
+      }
+      return remote.container;
+    }
+    if (remote.containerPromise) return remote.containerPromise;
+    const b = remote.breakerState;
+    if (b.openUntil > Date.now()) {
+      const err = new FulgurjsError(
+        ErrorCodes.REMOTE_LOAD_FAILED,
+        `circuit breaker open for remote "${remote.name}" until ${new Date(b.openUntil).toISOString()}`,
+        { remote: remote.name }
+      );
+      emitError({ remote: remote.name, error: err });
+      throw err;
+    }
+    remote.state = "loading";
+    remote.debug.status = "loading";
+    const containerPromise = (async () => {
+      const loaders = [];
+      if (remote.promise) {
+        loaders.push(async () => {
+          const resolved = await remote.promise();
+          const container2 = typeof resolved === "string" ? await importEntry(resolved, remote) : resolved;
+          validateContainerInterface(container2, remote);
+          return container2;
+        });
+      } else {
+        for (const url of [remote.entry, ...remote.fallback ?? []]) {
+          loaders.push(async () => {
+            const container2 = await importEntry(url, remote);
+            validateContainerInterface(container2, remote);
+            return container2;
+          });
+        }
+      }
+      let container;
+      let lastErr;
+      let succeeded = false;
+      const maxRetries = overrides?.retries ?? remote.retries ?? DEFAULT_RETRIES;
+      for (const loader of loaders) {
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+          const start = performance.now();
+          try {
+            container = await loader();
+            remote.lastLoadMs = Math.round(performance.now() - start);
+            remote.debug.lastLoadMs = remote.lastLoadMs;
+            succeeded = true;
+            break;
+          } catch (err) {
+            lastErr = err;
+            if (err?.code) throw err;
+            if (attempt < maxRetries) {
+              await sleep(200 * 2 ** attempt);
+            }
+          }
+        }
+        if (succeeded) break;
+      }
+      if (!succeeded || !container) {
+        const hints = [];
+        if (/^https?:\/\//.test(remote.entry) && typeof location !== "undefined") {
+          hints.push(`1. is the remote dev server running?  try opening ${remote.entry} in the browser \u2014 it must return JS, not HTML/an error`);
+          hints.push(`2. is the URL correct in federation({ remotes })?  dev and prod entries can differ`);
+          hints.push(`3. CORS: the remote dev server must allow cross-origin requests (fulgurjs-federation enables server.cors automatically; a custom server config may have disabled it)`);
+        } else {
+          hints.push(`1. is the remote deployed and reachable?  try opening ${remote.entry} in the browser \u2014 it must return JS`);
+          hints.push(`2. NGINX/CDN routing: the entry path must serve the remoteEntry JS file (check try_files / fallback rules)`);
+        }
+        throw new FulgurjsError(
+          ErrorCodes.REMOTE_LOAD_FAILED,
+          `failed to load remote "${remote.name}" from ${remote.entry}: ${String(lastErr?.message ?? lastErr)}
+` + hints.join("\n"),
+          { remote: remote.name }
+        );
+      }
+      validateContainerInterface(container, remote);
+      const prevScope = containerInitScopes.get(container);
+      if (prevScope && prevScope !== scopeKey) {
+        throw new FulgurjsError(
+          ErrorCodes.CONTAINER_REINIT_CONFLICT,
+          `container "${remote.name}" already initialized with share scope "${prevScope}", cannot re-init with "${scopeKey}"`
+        );
+      }
+      if (typeof container.init === "function") {
+        await container.init(shareScopeMap2);
+      }
+      containerInitScopes.set(container, scopeKey);
+      remote.container = container;
+      remote.state = "loaded";
+      remote.debug.status = "loaded";
+      b.fails = 0;
+      return container;
+    })();
+    remote.containerPromise = containerPromise;
+    try {
+      return await containerPromise;
+    } catch (err) {
+      remote.containerPromise = void 0;
+      remote.state = "failed";
+      remote.debug.status = "failed";
+      remote.debug.error = String(err?.message ?? err);
+      b.fails += 1;
+      if (b.fails >= BREAKER_THRESHOLD) {
+        b.openUntil = Date.now() + BREAKER_RESET_MS;
+        b.fails = 0;
+      }
+      if (err instanceof FulgurjsError) {
+        emitError({ remote: remote.name, error: err });
+        throw err;
+      }
+      if (err?.code) {
+        emitError({ remote: remote.name, error: err });
+        throw err;
+      }
+      const wrapped = new FulgurjsError(ErrorCodes.REMOTE_LOAD_FAILED, String(err?.message ?? err), {
+        remote: remote.name
+      });
+      emitError({ remote: remote.name, error: wrapped });
+      throw wrapped;
+    }
+  }
+  function parseSpec(spec) {
+    const idx = spec.indexOf("/");
+    if (idx === -1) return { remote: spec, module: "" };
+    return { remote: spec.slice(0, idx), module: normalizeModuleName(spec.slice(idx + 1)) };
+  }
+  function normalizeModuleName(m) {
+    if (!m) return "";
+    return m.startsWith(".") ? m : `./${m}`;
+  }
+  async function loadRemote2(spec, opts) {
+    const { remote: name, module } = parseSpec(spec);
+    hooks.beforeLoadRemote?.({ remote: name, module });
+    const remote = remotes.get(name);
+    if (!remote) {
+      throw new FulgurjsError(
+        ErrorCodes.REMOTE_UNKNOWN,
+        `unknown remote "${name}". Register it via federation({ remotes }) or registerRemote().`,
+        { remote: name }
+      );
+    }
+    let container;
+    try {
+      container = await acquireContainer(remote, { retries: opts?.retries });
+    } catch (err) {
+      if (opts?.fallbackModule) {
+        console.error(`[fulgurjs] loadRemote("${spec}") failed; returning fallbackModule (\u663E\u5F0F\u964D\u7EA7\uFF0C\u9519\u8BEF\u5DF2\u900F\u51FA)`, err);
+        emitError({ remote: name, error: err });
+        return await opts.fallbackModule();
+      }
+      throw err;
+    }
+    if (!module) return container;
+    const cacheKey = `${name}@${remote.shareScope || "default"}#${module}`;
+    if (!loadedModules.has(cacheKey)) {
+      loadedModules.set(
+        cacheKey,
+        container.get(module).catch((err) => {
+          loadedModules.delete(cacheKey);
+          if (err instanceof FulgurjsError || err?.code) throw err;
+          throw new FulgurjsError(
+            ErrorCodes.REMOTE_LOAD_FAILED,
+            `failed to load module "${module}" from remote "${name}": ${String(err?.message ?? err)}`,
+            { remote: name, module }
+          );
+        })
+      );
+    }
+    let ns;
+    try {
+      ns = await loadedModules.get(cacheKey);
+    } catch (err) {
+      if (opts?.fallbackModule) {
+        console.error(`[fulgurjs] loadRemote("${spec}") failed; returning fallbackModule (\u663E\u5F0F\u964D\u7EA7\uFF0C\u9519\u8BEF\u5DF2\u900F\u51FA)`, err);
+        emitError({ remote: name, error: err });
+        return await opts.fallbackModule();
+      }
+      throw err;
+    }
+    hooks.afterLoadRemote?.({ remote: name, module, module_ns: ns });
+    if (ns && typeof ns === "object" && Object.keys(ns).length === 0) {
+      const err = new FulgurjsError(
+        ErrorCodes.EMPTY_EXPORTS,
+        `no exports: ${module} @ ${name}`,
+        { remote: name, module }
+      );
+      emitError({ remote: name, error: err });
+      console.error(`[fulgurjs:MFU-009] ${err.message}`);
+    }
+    return ns;
+  }
+  function getContainer2(name) {
+    const remote = remotes.get(name);
+    if (!remote) {
+      throw new FulgurjsError(ErrorCodes.REMOTE_UNKNOWN, `unknown remote "${name}"`, { remote: name });
+    }
+    return acquireContainer(remote);
+  }
+  async function preloadRemote2(spec, opts = {}) {
+    const { remote: name } = parseSpec(spec);
+    const remote = remotes.get(name);
+    if (!remote) {
+      throw new FulgurjsError(ErrorCodes.REMOTE_UNKNOWN, `unknown remote "${name}"`, { remote: name });
+    }
+    const mode = opts.mode ?? "preload";
+    const inject = (href, as) => {
+      if (typeof document === "undefined") return;
+      if (document.querySelector(`link[href="${href}"]`)) return;
+      const link = document.createElement("link");
+      link.rel = as === "style" ? "stylesheet" : "modulepreload";
+      link.href = href;
+      if (mode === "prefetch") {
+        ;
+        link.fetchPriority = "low";
+      }
+      document.head.appendChild(link);
+    };
+    try {
+      if (remote.manifestUrl) {
+        const res = await fetch(remote.manifestUrl, { cache: "no-cache" });
+        if (res.ok) {
+          const manifest = await res.json();
+          inject(remote.entry, "modulepreload");
+          const exposes = manifest.exposes ?? {};
+          for (const key of Object.keys(exposes)) {
+            const item = exposes[key];
+            if (item?.file) inject(new URL(item.file, remote.entry).href, "modulepreload");
+            for (const css of item?.css ?? []) inject(new URL(css, remote.entry).href, "style");
+          }
+          return;
+        }
+      }
+      inject(remote.entry, "modulepreload");
+    } catch (err) {
+      emitError({
+        remote: name,
+        error: new FulgurjsError(ErrorCodes.PRELOAD_FAILED, String(err?.message ?? err), {
+          remote: name
+        })
+      });
+    }
+  }
+  const attachDebug = () => {
+    if (typeof window === "undefined") return;
+    window.__FULGURJS_SCOPE__ = shareScopeMap2;
+    window.__FULGURJS_INFO__ = {
+      get remotes() {
+        const out = {};
+        for (const [k, v] of remotes) {
+          out[k] = { ...v.debug, entry: v.entry };
+        }
+        return out;
+      },
+      errors: []
+    };
+  };
+  attachDebug();
+  return {
+    shareScopeMap: shareScopeMap2,
+    initSharing: initSharing2,
+    registerShare: registerShare2,
+    registerRemotes: registerRemotes2,
+    registerRemote: registerRemote2,
+    registerPlugins: registerPlugins2,
+    loadShare: loadShare2,
+    loadRemote: loadRemote2,
+    getContainer: getContainer2,
+    preloadRemote: preloadRemote2,
+    parseSpec,
+    provideFulgurjsAppConfig: provideFulgurjsAppConfig2,
+    getFulgurjsAppConfig: getFulgurjsAppConfig2
+  };
+}
+var g = globalThis;
+var runtime = g.__FULGURJS_RUNTIME__ ?? createRuntime();
+g.__FULGURJS_RUNTIME__ = runtime;
+try {
+  Object.freeze(runtime);
+} catch {
+}
+var initSharing = runtime.initSharing;
+var registerShare = runtime.registerShare;
+var registerRemotes = runtime.registerRemotes;
+var registerRemote = runtime.registerRemote;
+var registerPlugins = runtime.registerPlugins;
+var loadShare = runtime.loadShare;
+var loadRemote = runtime.loadRemote;
+var getContainer = runtime.getContainer;
+var preloadRemote = runtime.preloadRemote;
+var shareScopeMap = runtime.shareScopeMap;
+var provideFulgurjsAppConfig = runtime.provideFulgurjsAppConfig;
+var getFulgurjsAppConfig = runtime.getFulgurjsAppConfig;
+
+// src/vue.ts
+var ERROR_STYLE = {
+  padding: "16px",
+  border: "1px solid #fde2e2",
+  borderRadius: "4px",
+  background: "#fef0f0",
+  color: "#c45656",
+  fontSize: "13px",
+  lineHeight: "1.6"
+};
+var RemoteErrorPlaceholder = defineComponent({
+  name: "FulgurjsRemoteError",
+  props: {
+    error: { type: Object, default: void 0 }
+  },
+  setup(props) {
+    return () => {
+      const err = props.error;
+      const code = err?.code ?? "UNKNOWN";
+      const message = err?.message ?? String(props.error ?? "unknown error");
+      return h("div", { style: ERROR_STYLE }, [
+        h("p", { style: "margin:0 0 4px;font-weight:600" }, `\u8FDC\u7A0B\u7EC4\u4EF6\u52A0\u8F7D\u5931\u8D25\uFF08\u9519\u8BEF\u7801 ${code}\uFF09`),
+        h("p", { style: "margin:0 0 8px;word-break:break-all" }, message),
+        h(
+          "p",
+          { style: "margin:0" },
+          "\u4FEE\u6CD5\uFF1A\u2460 \u6838\u5BF9 spec \u7684\u300C\u8FDC\u7A0B\u540D/expose \u540D\u300D\u4E0E\u8FDC\u7A0B\u5E94\u7528 exposes \u662F\u5426\u4E00\u81F4\uFF08MFU-006/008\uFF09\uFF1B\u2461 \u6838\u5BF9 remotes \u5730\u5740\u7AEF\u53E3\u4E0E\u8FDC\u7A0B\u670D\u52A1\u53EF\u8FBE\u6027\u3001remoteEntry \u662F\u5426\u53EF\u8BBF\u95EE\uFF08MFU-001\uFF09\uFF1B\u2462 \u67E5\u770B window \u7684 fulgurjs:error \u4E8B\u4EF6\u4E0E console \u540C\u6E90\u9519\u8BEF\u5B9A\u4F4D\u6839\u56E0\u3002"
+        )
+      ]);
+    };
+  }
+});
+function remoteComponent(spec, opts = {}) {
+  return defineAsyncComponent({
+    loader: () => loadRemote(spec, { retries: opts.retries }).then((m) => m.default ?? m),
+    loadingComponent: opts.loadingComponent,
+    errorComponent: opts.errorComponent ?? RemoteErrorPlaceholder,
+    delay: opts.delay,
+    timeout: opts.timeout
+  });
+}
+export {
+  remoteComponent
+};