@fulgurjs/federation 5.3.3 → 5.4.1

package/dist/bridge-router-react.d.ts

@@ -0,0 +1,73 @@
+import { ReactElement } from 'react';
+import { RouteObject } from 'react-router-dom';
+
+/** 统一逻辑位置：pathname 以 / 开头；search 空串或 ? 开头；hash 空串或 # 开头 */
+interface BridgeLocation {
+    pathname: string;
+    search: string;
+    hash: string;
+}
+type BridgeNavigationResult = {
+    status: 'committed';
+    location: BridgeLocation;
+} | {
+    status: 'cancelled';
+    location: BridgeLocation;
+};
+/** 宿主导航端口（宿主适配器把 Router 包装成本接口；逻辑路径不含部署 base） */
+interface BridgeHostNavigation {
+    getLocation(): BridgeLocation;
+    subscribe(listener: (location: BridgeLocation) => void): () => void;
+    navigate(target: BridgeLocation, action: 'push' | 'replace', options?: {
+        signal?: AbortSignal;
+    }): Promise<BridgeNavigationResult>;
+    go(delta: number): void;
+}
+/** 子应用路由通道（桥接宿主按挂载代次创建，随 mount 第三参数交给子应用） */
+interface BridgeChildRoute {
+    getLocation(): BridgeLocation;
+    subscribe(listener: (location: BridgeLocation) => void): () => void;
+    navigate(target: BridgeLocation, action: 'push' | 'replace'): Promise<BridgeNavigationResult>;
+    go(delta: number): void;
+}
+
+/** React Router data router 的宿主端口与子应用 memory router 接线（按需入口）。 */
+
+type ReactBridgeCancelPolicy = (next: BridgeLocation) => boolean;
+interface ReactDataRouterLike {
+    state: {
+        location: {
+            pathname: string;
+            search: string;
+            hash: string;
+            key?: string;
+        };
+        navigation?: {
+            state: string;
+            location?: BridgeLocation;
+        };
+        blockers?: ReadonlyMap<string, {
+            state: string;
+            reset?: () => void;
+        }>;
+    };
+    subscribe(cb: () => void): () => void;
+    navigate(to: string | number, opts?: {
+        replace?: boolean;
+    }): void | Promise<void>;
+}
+/** canNavigate 是可选预判；最终结果同时核对真实 blocker 与已提交位置。 */
+declare function createReactBridgeNavigation(router: ReactDataRouterLike, options?: {
+    canNavigate?: ReactBridgeCancelPolicy;
+    basename?: string;
+}): BridgeHostNavigation;
+interface ReactBridgeRouterConnection {
+    element: ReactElement;
+    dispose(): void;
+}
+/** 返回 RouterProvider 元素，直接作为 defineBridgeApp 工厂的 ReactElement 返回值。 */
+declare function createReactBridgeRouter(routing: BridgeChildRoute, routes: RouteObject[], options?: {
+    signal?: AbortSignal;
+}): ReactBridgeRouterConnection;
+
+export { type ReactBridgeCancelPolicy, type ReactBridgeRouterConnection, type ReactDataRouterLike, createReactBridgeNavigation, createReactBridgeRouter };

package/dist/bridge-router-react.js

@@ -0,0 +1,247 @@
+// src/bridge-router-react.tsx
+import { createElement } from "react";
+import { RouterProvider, createMemoryRouter } from "react-router-dom";
+
+// src/runtime/errors.ts
+var FgError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details, options) {
+    super(`[fulgurjs:${code}] ${message}`, options);
+    this.name = "FgError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/bridge-errors.ts
+var BridgeErrorCodes = {
+  /** 桥接契约非法（./bridge 默认导出缺 mount/unmount 或不是函数） */
+  BRIDGE_INVALID_CONTRACT: "MFU-015",
+  /** 桥接准备或生命周期失败（details.phase = getContext | mount | unmount） */
+  BRIDGE_LIFECYCLE_FAILED: "MFU-016",
+  /** 桥接会话参数与 AppContext 不一致（受控 sessionKey 与全局会话矛盾） */
+  BRIDGE_SESSION_MISMATCH: "MFU-017",
+  /** 路由同步配置/前缀冲突（basePath 非法、同页前缀冲突或重叠） */
+  ROUTING_CONFIG_INVALID: "MFU-030",
+  /** 路由协议缺失/通道失效（子应用未声明 routing 协议，或已销毁通道被再次使用） */
+  ROUTING_PROTOCOL_MISSING: "MFU-031",
+  /** 非法导航（目标越界前缀、非法 go 参数、失效实例的请求） */
+  ROUTING_NAVIGATION_INVALID: "MFU-032",
+  /** 路由准备/同步失败（重定向循环、子应用路由准备失败且已阻止错误页面显示） */
+  ROUTING_SYNC_FAILED: "MFU-033"
+};
+function routingSyncError(spec, reason, chain, cause) {
+  return new FgError(
+    BridgeErrorCodes.ROUTING_SYNC_FAILED,
+    `\u73B0\u8C61\uFF1A\u6865\u63A5\u5E94\u7528 "${spec}" \u7684 URL \u540C\u6B65\u5931\u8D25\u3002
+\u539F\u56E0\uFF1A${reason}
+\u4FEE\u6CD5\uFF1A\u68C0\u67E5\u8DEF\u7531\u5B88\u536B\u3001\u52A0\u8F7D\u5668\u4E0E\u5BFC\u822A\u5F02\u5E38\uFF1B\u91CD\u5B9A\u5411\u94FE\u4E0D\u5E94\u6210\u73AF\u3002\u76EE\u6807\u94FE\uFF1A${chain.join(" \u2192 ")}\u3002`,
+    { spec, chain: [...chain] },
+    { cause }
+  );
+}
+
+// src/bridge-router-core.ts
+function sameLocation(a, b) {
+  return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash;
+}
+
+// src/bridge-router-sync.ts
+function connectChildNavigation(routing, apply, onError) {
+  let disposed = false;
+  let generation = 0;
+  let tail = Promise.resolve();
+  let confirmed = routing.getLocation();
+  let pending;
+  const restore = () => apply(routing.getLocation());
+  const unsub = routing.subscribe((location) => {
+    if (disposed) return;
+    const changed = !sameLocation(location, confirmed);
+    confirmed = location;
+    if (pending && sameLocation(location, pending)) return;
+    if (changed) generation++;
+    tail = tail.then(() => disposed ? void 0 : restore()).catch(onError);
+  });
+  return {
+    enqueue(prepare, action) {
+      const version = generation;
+      const cancelled = () => ({ status: "cancelled", location: routing.getLocation() });
+      const task = tail.then(async () => {
+        if (disposed || version !== generation) return cancelled();
+        try {
+          const target = await prepare();
+          if (disposed) return cancelled();
+          if (version !== generation) {
+            await restore();
+            return cancelled();
+          }
+          if (!target) return cancelled();
+          pending = target;
+          const result = await routing.navigate(target, action);
+          if (!disposed) await restore();
+          return result;
+        } catch (cause) {
+          if (!disposed) {
+            try {
+              await restore();
+            } catch (restoreError) {
+              onError(restoreError);
+            }
+          }
+          throw routingSyncError("child-router", `\u5B50\u5E94\u7528\u8DEF\u7531\u51C6\u5907\u6216\u540C\u6B65\u5931\u8D25\uFF1A${cause instanceof Error ? cause.message : String(cause)}`, [], cause);
+        } finally {
+          pending = void 0;
+        }
+      });
+      tail = task.then(() => {
+      }, () => {
+      });
+      return task;
+    },
+    dispose() {
+      disposed = true;
+      generation++;
+      unsub();
+    }
+  };
+}
+
+// src/bridge-router-react.tsx
+function createReactBridgeNavigation(router, options = {}) {
+  const base = options.basename && options.basename !== "/" ? options.basename.replace(/\/$/, "") : "";
+  const toLogic = () => {
+    const l = router.state.location;
+    const pathname = base && (l.pathname === base || l.pathname.startsWith(base + "/")) ? l.pathname.slice(base.length) || "/" : l.pathname;
+    return { pathname, search: l.search, hash: l.hash };
+  };
+  return {
+    getLocation: toLogic,
+    subscribe(listener) {
+      let previous = toLogic();
+      return router.subscribe(() => {
+        const next = toLogic();
+        if (!sameLocation(previous, next)) {
+          previous = next;
+          listener(next);
+        }
+      });
+    },
+    async navigate(target, action, context) {
+      if (context?.signal?.aborted || options.canNavigate && !options.canNavigate(target)) return { status: "cancelled", location: toLogic() };
+      const initial = router.state.location;
+      return new Promise((resolve, reject) => {
+        let finished = false;
+        let returned = false;
+        let blocked = false;
+        let unwatch = () => {
+        };
+        const finish = (status) => {
+          if (finished) return;
+          finished = true;
+          unwatch();
+          context?.signal?.removeEventListener("abort", abort);
+          resolve({ status, location: toLogic() });
+        };
+        const abort = () => {
+          finish("cancelled");
+          for (const blocker of router.state.blockers?.values() ?? []) if (blocker.state === "blocked") blocker.reset?.();
+          const loading = router.state.navigation;
+          if (loading && loading.state !== "idle" && loading.location?.pathname === base + target.pathname) {
+            const current = toLogic();
+            void Promise.resolve().then(() => {
+              const latest = router.state.navigation;
+              if (!latest || latest.state === "idle" || latest.location?.pathname !== base + target.pathname) return;
+              return router.navigate(current.pathname + current.search + current.hash, { replace: true });
+            }).catch((error) => console.error("[fulgurjs] \u53D6\u6D88\u5BBF\u4E3B\u5F85\u63D0\u4EA4\u5BFC\u822A\u5931\u8D25\uFF1A", error));
+          }
+        };
+        const check = () => {
+          if (finished) return;
+          if (context?.signal?.aborted) {
+            abort();
+            return;
+          }
+          const blockers = [...router.state.blockers?.values() ?? []];
+          if (blockers.some((b) => b.state === "blocked" || b.state === "proceeding")) {
+            blocked = true;
+            return;
+          }
+          if (router.state.navigation && router.state.navigation.state !== "idle") return;
+          const actual = router.state.location;
+          const committed = actual.key !== initial.key || !sameLocation(actual, initial);
+          if (committed) finish("committed");
+          else if (returned || blocked) finish("cancelled");
+        };
+        unwatch = router.subscribe(check);
+        context?.signal?.addEventListener("abort", abort, { once: true });
+        Promise.resolve().then(() => {
+          if (finished || context?.signal?.aborted) return;
+          return router.navigate(target.pathname + target.search + target.hash, { replace: action === "replace" });
+        }).then(() => {
+          returned = true;
+          check();
+        }, (error) => {
+          if (finished) return;
+          finished = true;
+          unwatch();
+          context?.signal?.removeEventListener("abort", abort);
+          reject(error);
+        });
+      });
+    },
+    go(delta) {
+      void Promise.resolve().then(() => router.navigate(delta)).catch((error) => console.error("[fulgurjs] \u5BBF\u4E3B\u5386\u53F2\u5BFC\u822A\u5931\u8D25\uFF1A", error));
+    }
+  };
+}
+function createReactBridgeRouter(routing, routes, options = {}) {
+  const init = routing.getLocation();
+  const router = createMemoryRouter(routes, { initialEntries: [init.pathname + init.search + init.hash] });
+  const navigate = router.navigate.bind(router);
+  let disposed = false;
+  const sync = connectChildNavigation(routing, async (loc) => {
+    const cur = router.state.location;
+    if (!sameLocation(cur, loc)) await navigate(loc.pathname + loc.search + loc.hash, { replace: true });
+  }, (error) => console.error("[fulgurjs] \u5B50\u5E94\u7528 React \u8DEF\u7531\u540C\u6B65\u5931\u8D25\uFF1A", error));
+  router.navigate = ((to, options2) => {
+    if (typeof to === "number") {
+      if (!disposed) routing.go(to);
+      return Promise.resolve();
+    }
+    const task = sync.enqueue(async () => {
+      await navigate(to, options2);
+      const l = router.state.location;
+      return { pathname: l.pathname, search: l.search, hash: l.hash };
+    }, options2?.replace ? "replace" : "push").then(() => {
+    });
+    void task.catch((error) => console.error("[fulgurjs] \u5B50\u5E94\u7528 React \u8DEF\u7531\u540C\u6B65\u5931\u8D25\uFF1A", error));
+    return task;
+  });
+  let unwatch = () => {
+  };
+  if (!router.state.initialized) unwatch = router.subscribe(() => {
+    if (!router.state.initialized) return;
+    unwatch();
+    const actual = router.state.location;
+    if (!sameLocation(actual, init)) void sync.enqueue(async () => actual, "replace").catch((error) => console.error("[fulgurjs] \u521D\u59CB React \u8DEF\u7531\u540C\u6B65\u5931\u8D25\uFF1A", error));
+  });
+  const connection = {
+    element: createElement(RouterProvider, { router }),
+    dispose() {
+      if (disposed) return;
+      options.signal?.removeEventListener("abort", connection.dispose);
+      disposed = true;
+      unwatch();
+      sync.dispose();
+      router.dispose();
+    }
+  };
+  options.signal?.addEventListener("abort", connection.dispose, { once: true });
+  if (options.signal?.aborted) connection.dispose();
+  return connection;
+}
+export {
+  createReactBridgeNavigation,
+  createReactBridgeRouter
+};

package/dist/bridge-router-vue.d.ts

@@ -0,0 +1,50 @@
+import { Router } from 'vue-router';
+
+/** 统一逻辑位置：pathname 以 / 开头；search 空串或 ? 开头；hash 空串或 # 开头 */
+interface BridgeLocation {
+    pathname: string;
+    search: string;
+    hash: string;
+}
+type BridgeNavigationResult = {
+    status: 'committed';
+    location: BridgeLocation;
+} | {
+    status: 'cancelled';
+    location: BridgeLocation;
+};
+/** 宿主导航端口（宿主适配器把 Router 包装成本接口；逻辑路径不含部署 base） */
+interface BridgeHostNavigation {
+    getLocation(): BridgeLocation;
+    subscribe(listener: (location: BridgeLocation) => void): () => void;
+    navigate(target: BridgeLocation, action: 'push' | 'replace', options?: {
+        signal?: AbortSignal;
+    }): Promise<BridgeNavigationResult>;
+    go(delta: number): void;
+}
+/** 子应用路由通道（桥接宿主按挂载代次创建，随 mount 第三参数交给子应用） */
+interface BridgeChildRoute {
+    getLocation(): BridgeLocation;
+    subscribe(listener: (location: BridgeLocation) => void): () => void;
+    navigate(target: BridgeLocation, action: 'push' | 'replace'): Promise<BridgeNavigationResult>;
+    go(delta: number): void;
+}
+
+/** Vue Router 4 的宿主导航端口与子应用 memory router 接线（按需入口）。 */
+
+interface VueBridgeNavigationOptions {
+    /** 保留配置兼容；Vue Router fullPath 已剥离 history base，不再二次剥离。 */
+    routerBase?: string;
+}
+declare function createVueBridgeNavigation(router: Router, _options?: VueBridgeNavigationOptions): BridgeHostNavigation;
+interface VueBridgeRouterConnection {
+    /** 必须 await ready 后再 app.use(router)，初始错误会拒绝此 Promise。 */
+    ready: Promise<void>;
+    dispose(): void;
+}
+/** 接线限子应用自己的 memory router；dispose 恢复原始导航方法。 */
+declare function connectVueBridgeRouter(routing: BridgeChildRoute, router: Router, options?: {
+    signal?: AbortSignal;
+}): VueBridgeRouterConnection;
+
+export { type VueBridgeNavigationOptions, type VueBridgeRouterConnection, connectVueBridgeRouter, createVueBridgeNavigation };

package/dist/bridge-router-vue.js

@@ -0,0 +1,217 @@
+// src/runtime/errors.ts
+var FgError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details, options) {
+    super(`[fulgurjs:${code}] ${message}`, options);
+    this.name = "FgError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// src/bridge-errors.ts
+var BridgeErrorCodes = {
+  /** 桥接契约非法（./bridge 默认导出缺 mount/unmount 或不是函数） */
+  BRIDGE_INVALID_CONTRACT: "MFU-015",
+  /** 桥接准备或生命周期失败（details.phase = getContext | mount | unmount） */
+  BRIDGE_LIFECYCLE_FAILED: "MFU-016",
+  /** 桥接会话参数与 AppContext 不一致（受控 sessionKey 与全局会话矛盾） */
+  BRIDGE_SESSION_MISMATCH: "MFU-017",
+  /** 路由同步配置/前缀冲突（basePath 非法、同页前缀冲突或重叠） */
+  ROUTING_CONFIG_INVALID: "MFU-030",
+  /** 路由协议缺失/通道失效（子应用未声明 routing 协议，或已销毁通道被再次使用） */
+  ROUTING_PROTOCOL_MISSING: "MFU-031",
+  /** 非法导航（目标越界前缀、非法 go 参数、失效实例的请求） */
+  ROUTING_NAVIGATION_INVALID: "MFU-032",
+  /** 路由准备/同步失败（重定向循环、子应用路由准备失败且已阻止错误页面显示） */
+  ROUTING_SYNC_FAILED: "MFU-033"
+};
+function routingSyncError(spec, reason, chain, cause) {
+  return new FgError(
+    BridgeErrorCodes.ROUTING_SYNC_FAILED,
+    `\u73B0\u8C61\uFF1A\u6865\u63A5\u5E94\u7528 "${spec}" \u7684 URL \u540C\u6B65\u5931\u8D25\u3002
+\u539F\u56E0\uFF1A${reason}
+\u4FEE\u6CD5\uFF1A\u68C0\u67E5\u8DEF\u7531\u5B88\u536B\u3001\u52A0\u8F7D\u5668\u4E0E\u5BFC\u822A\u5F02\u5E38\uFF1B\u91CD\u5B9A\u5411\u94FE\u4E0D\u5E94\u6210\u73AF\u3002\u76EE\u6807\u94FE\uFF1A${chain.join(" \u2192 ")}\u3002`,
+    { spec, chain: [...chain] },
+    { cause }
+  );
+}
+
+// src/bridge-router-core.ts
+function sameLocation(a, b) {
+  return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash;
+}
+
+// src/bridge-router-sync.ts
+function connectChildNavigation(routing, apply, onError) {
+  let disposed = false;
+  let generation = 0;
+  let tail = Promise.resolve();
+  let confirmed = routing.getLocation();
+  let pending;
+  const restore = () => apply(routing.getLocation());
+  const unsub = routing.subscribe((location) => {
+    if (disposed) return;
+    const changed = !sameLocation(location, confirmed);
+    confirmed = location;
+    if (pending && sameLocation(location, pending)) return;
+    if (changed) generation++;
+    tail = tail.then(() => disposed ? void 0 : restore()).catch(onError);
+  });
+  return {
+    enqueue(prepare, action) {
+      const version = generation;
+      const cancelled = () => ({ status: "cancelled", location: routing.getLocation() });
+      const task = tail.then(async () => {
+        if (disposed || version !== generation) return cancelled();
+        try {
+          const target = await prepare();
+          if (disposed) return cancelled();
+          if (version !== generation) {
+            await restore();
+            return cancelled();
+          }
+          if (!target) return cancelled();
+          pending = target;
+          const result = await routing.navigate(target, action);
+          if (!disposed) await restore();
+          return result;
+        } catch (cause) {
+          if (!disposed) {
+            try {
+              await restore();
+            } catch (restoreError) {
+              onError(restoreError);
+            }
+          }
+          throw routingSyncError("child-router", `\u5B50\u5E94\u7528\u8DEF\u7531\u51C6\u5907\u6216\u540C\u6B65\u5931\u8D25\uFF1A${cause instanceof Error ? cause.message : String(cause)}`, [], cause);
+        } finally {
+          pending = void 0;
+        }
+      });
+      tail = task.then(() => {
+      }, () => {
+      });
+      return task;
+    },
+    dispose() {
+      disposed = true;
+      generation++;
+      unsub();
+    }
+  };
+}
+
+// src/bridge-router-vue.ts
+var locationFromPath = (path) => {
+  const raw = new URL(path || "/", "http://f.invalid");
+  return { pathname: raw.pathname, search: raw.search, hash: raw.hash };
+};
+function createVueBridgeNavigation(router, _options = {}) {
+  const toLogic = () => locationFromPath(router.currentRoute.value.fullPath);
+  return {
+    getLocation: toLogic,
+    subscribe(listener) {
+      return router.afterEach((_to, _from, failure) => {
+        if (!failure) listener(toLogic());
+      });
+    },
+    async navigate(target, action, options) {
+      if (options?.signal?.aborted) return { status: "cancelled", location: toLogic() };
+      const removeGuard = router.beforeResolve(() => options?.signal?.aborted ? false : void 0);
+      try {
+        const to = target.pathname + target.search + target.hash;
+        const failure = action === "replace" ? await router.replace(to) : await router.push(to);
+        return { status: failure ? "cancelled" : "committed", location: toLogic() };
+      } finally {
+        removeGuard();
+      }
+    },
+    go(delta) {
+      router.go(delta);
+    }
+  };
+}
+function connectVueBridgeRouter(routing, router, options = {}) {
+  const push = router.push;
+  const replace = router.replace;
+  const go = router.go;
+  const back = router.back;
+  const forward = router.forward;
+  let disposed = false;
+  const report = (error) => console.error("[fulgurjs] \u5B50\u5E94\u7528 Vue \u8DEF\u7531\u540C\u6B65\u5931\u8D25\uFF1A", error);
+  const apply = async (loc) => {
+    const path = loc.pathname + loc.search + loc.hash;
+    if (router.currentRoute.value.fullPath !== path) {
+      const failure = await replace.call(router, path);
+      if (failure && router.currentRoute.value.fullPath !== path) throw routingSyncError("vue-router", "\u5B50\u5E94\u7528\u5B88\u536B\u62D2\u7EDD\u5E94\u7528\u5BBF\u4E3B\u786E\u8BA4\u7684\u4F4D\u7F6E\uFF1B\u8BF7\u5728\u5BBF\u4E3B\u4FA7\u8BBE\u7F6E\u53D6\u6D88\u5B88\u536B\u3002", []);
+    }
+  };
+  const sync = connectChildNavigation(routing, (loc) => ready.then(() => apply(loc)), report);
+  const init = routing.getLocation();
+  const ready = push.call(router, init.pathname + init.search + init.hash).then(async (failure) => {
+    if (disposed) return;
+    if (routing.getLocation().pathname + routing.getLocation().search + routing.getLocation().hash !== init.pathname + init.search + init.hash) {
+      await apply(routing.getLocation());
+      return;
+    }
+    if (failure) throw routingSyncError("vue-router", "\u5B50\u5E94\u7528\u521D\u59CB\u8DEF\u7531\u88AB\u5B88\u536B\u53D6\u6D88\u3002", []);
+    const target = locationFromPath(router.currentRoute.value.fullPath);
+    if (router.currentRoute.value.fullPath !== init.pathname + init.search + init.hash) {
+      await routing.navigate(target, "replace");
+      await apply(routing.getLocation());
+    }
+  }).catch((cause) => {
+    throw routingSyncError("vue-router", `\u521D\u59CB\u8DEF\u7531\u51C6\u5907\u5931\u8D25\uFF1A${cause instanceof Error ? cause.message : String(cause)}`, [], cause);
+  });
+  const intercept = (native, action) => (to) => {
+    const task = (async () => {
+      let failure;
+      const result = await sync.enqueue(async () => {
+        await ready;
+        failure = await native.call(router, to);
+        return failure ? void 0 : locationFromPath(router.currentRoute.value.fullPath);
+      }, typeof to === "object" && to.replace ? "replace" : action);
+      if (failure) return failure;
+      if (result.status === "cancelled") {
+        const remove = router.beforeEach(() => false);
+        try {
+          return await native.call(router, to);
+        } finally {
+          remove();
+        }
+      }
+    })();
+    void task.catch(report);
+    return task;
+  };
+  router.push = intercept(push, "push");
+  router.replace = intercept(replace, "replace");
+  router.go = (delta) => {
+    if (!disposed) routing.go(delta);
+  };
+  router.back = () => router.go(-1);
+  router.forward = () => router.go(1);
+  const connection = {
+    ready,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      options.signal?.removeEventListener("abort", connection.dispose);
+      sync.dispose();
+      router.push = push;
+      router.replace = replace;
+      router.go = go;
+      router.back = back;
+      router.forward = forward;
+    }
+  };
+  options.signal?.addEventListener("abort", connection.dispose, { once: true });
+  if (options.signal?.aborted) connection.dispose();
+  return connection;
+}
+export {
+  connectVueBridgeRouter,
+  createVueBridgeNavigation
+};

package/dist/bridge-vue.d.ts

@@ -1,6 +1,6 @@
 import * as vue from 'vue';
-import { V as VueBridgeAppOptions } from './bridge-host-vue-BAxDKqGH.js';
-export { A as AppContext, B as BridgeApp } from './bridge-core-6uLJiMVa.js';
+import { V as VueBridgeAppOptions } from './bridge-host-vue-Dd1kkwDb.js';
+export { A as AppContext, a as BridgeApp } from './bridge-core-ejlY9ddN.js';
 
 /** Vue 宿主桥接工厂：返回 `{ appProps: P; sessionKey?: string | null }` 形态的包装组件 */
 declare const createVueBridgeApp: <P = Record<string, unknown>>(spec: string, options?: VueBridgeAppOptions) => vue.Component;

package/dist/bridge.d.ts

@@ -1,9 +1,10 @@
 import * as react from 'react';
-import { R as ReactBridgeAppOptions } from './bridge-host-react-C55RmGll.js';
-export { B as BridgeErrorFallback } from './bridge-host-react-C55RmGll.js';
+import { B as BridgeHostRouting } from './bridge-core-ejlY9ddN.js';
+export { A as AppContext, a as BridgeApp } from './bridge-core-ejlY9ddN.js';
+import { R as ReactBridgeAppOptions } from './bridge-host-react-Bua1TCVh.js';
+export { B as BridgeErrorFallback } from './bridge-host-react-Bua1TCVh.js';
 import * as vue from 'vue';
-import { V as VueBridgeAppOptions } from './bridge-host-vue-BAxDKqGH.js';
-export { A as AppContext, B as BridgeApp } from './bridge-core-6uLJiMVa.js';
+import { V as VueBridgeAppOptions } from './bridge-host-vue-Dd1kkwDb.js';
 
 /** Vue 宿主桥接工厂：返回 `{ appProps: P; sessionKey?: string | null }` 形态的包装组件 */
 declare const createVueBridgeApp: <P = Record<string, unknown>>(spec: string, options?: VueBridgeAppOptions) => vue.Component;
@@ -11,6 +12,7 @@ declare const createVueBridgeApp: <P = Record<string, unknown>>(spec: string, op
 declare const createReactBridgeApp: <P = Record<string, unknown>>(spec: string, options?: ReactBridgeAppOptions) => react.ComponentType<{
     appProps?: P;
     sessionKey?: string | null;
+    routing?: BridgeHostRouting;
 }>;
 
 export { ReactBridgeAppOptions, VueBridgeAppOptions, createReactBridgeApp, createVueBridgeApp };