@4399ywkf/core 5.1.5 → 5.1.6

package/dist/runtime/index.js

@@ -1,3 +1,367 @@
+// src/runtime/chunk-recovery.ts
+var DEFAULT_CHUNK_RECOVERY_COOLDOWN_MS = 3e4;
+var CHUNK_RECOVERY_STORAGE_KEY = "@4399ywkf/core:chunk-recovery-attempt";
+var CHUNK_RECOVERY_CACHE_BUST_PARAM = "__ywkf_chunk_retry";
+var CHUNK_RECOVERY_ACTIVE_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "@4399ywkf/core/chunk-recovery-active"
+);
+var CHUNK_RECOVERY_REGISTRY_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "@4399ywkf/core/chunk-recovery-registry"
+);
+var CHUNK_LOAD_ERROR_PATTERNS = [
+  /\bChunkLoadError\b/i,
+  /\bLoading (?:CSS )?chunk\s+\S+\s+failed\b/i,
+  /\bFailed to fetch dynamically imported module\b/i,
+  /\bImporting a module script failed\b/i,
+  /\berror loading dynamically imported module\b/i,
+  /\bUnable to preload CSS for\b/i,
+  /\bFailed to load module script\b/i
+];
+function getErrorLikeValue(error, key) {
+  if ((typeof error !== "object" || error === null) && typeof error !== "function") {
+    return void 0;
+  }
+  try {
+    return error[key];
+  } catch {
+    return void 0;
+  }
+}
+function matchesChunkLoadError(error, depth) {
+  if (depth > 3) {
+    return false;
+  }
+  if (typeof error === "string") {
+    return CHUNK_LOAD_ERROR_PATTERNS.some((pattern) => pattern.test(error));
+  }
+  const name = getErrorLikeValue(error, "name");
+  const message = getErrorLikeValue(error, "message");
+  const code = getErrorLikeValue(error, "code");
+  const signature = [name, message].filter((value) => typeof value === "string").join(": ");
+  if (code === "CSS_CHUNK_LOAD_FAILED" || CHUNK_LOAD_ERROR_PATTERNS.some((pattern) => pattern.test(signature))) {
+    return true;
+  }
+  const cause = getErrorLikeValue(error, "cause");
+  return cause !== void 0 && cause !== error && matchesChunkLoadError(cause, depth + 1);
+}
+function isChunkLoadError(error) {
+  return matchesChunkLoadError(error, 0);
+}
+function hashRecoveryIdentity(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function getFrameworkBuildId() {
+  const buildId = globalThis.__YWKF_BUILD_ID__;
+  return typeof buildId === "string" ? buildId.trim() : "";
+}
+function resolveRecoveryId(error, config) {
+  const configuredBuildId = typeof config === "object" && typeof config.buildId === "string" ? config.buildId.trim() : "";
+  const buildId = configuredBuildId || getFrameworkBuildId();
+  if (buildId) {
+    return `build-${hashRecoveryIdentity(buildId)}`;
+  }
+  const request = getErrorLikeValue(error, "request");
+  const name = getErrorLikeValue(error, "name");
+  const message = getErrorLikeValue(error, "message");
+  const signature = [request, name, message].filter((value) => typeof value === "string").join(": ");
+  return `error-${hashRecoveryIdentity(signature || String(error))}`;
+}
+function toError(error, fallbackMessage = "Chunk loading failed") {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  const message = getErrorLikeValue(error, "message");
+  const name = getErrorLikeValue(error, "name");
+  const normalizedError = new Error(typeof message === "string" ? message : fallbackMessage);
+  if (typeof name === "string") {
+    normalizedError.name = name;
+  }
+  return normalizedError;
+}
+function normalizeCooldownMs(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 1e3) {
+    return DEFAULT_CHUNK_RECOVERY_COOLDOWN_MS;
+  }
+  return value;
+}
+function resolveChunkRecoveryPolicy(config, context) {
+  const options = typeof config === "object" ? config : void 0;
+  const configuredEnabled = typeof config === "boolean" ? config : options?.enabled;
+  const enabledForEnvironment = configuredEnabled ?? context.isProduction;
+  if (!enabledForEnvironment) {
+    return {
+      enabled: false,
+      disabledReason: configuredEnabled === false ? "configuration" : "environment",
+      cooldownMs: normalizeCooldownMs(options?.cooldownMs),
+      globalHandlers: options?.globalHandlers === true
+    };
+  }
+  if (context.isMicroApp && options?.allowInMicroApp !== true) {
+    return {
+      enabled: false,
+      disabledReason: "micro-app",
+      cooldownMs: normalizeCooldownMs(options?.cooldownMs),
+      globalHandlers: options?.globalHandlers === true
+    };
+  }
+  return {
+    enabled: true,
+    cooldownMs: normalizeCooldownMs(options?.cooldownMs),
+    globalHandlers: options?.globalHandlers === true
+  };
+}
+function parseStoredChunkRecoveryState(value) {
+  if (value === null) {
+    return { attempts: [] };
+  }
+  const parsed = JSON.parse(value);
+  if (!Array.isArray(parsed.attempts)) {
+    throw new Error("Invalid chunk recovery state");
+  }
+  const attempts = parsed.attempts.map((attempt) => {
+    if (typeof attempt !== "object" || attempt === null || typeof attempt.recoveryId !== "string" || typeof attempt.attemptedAt !== "number" || !Number.isFinite(attempt.attemptedAt)) {
+      throw new Error("Invalid chunk recovery attempt");
+    }
+    return attempt;
+  });
+  if (parsed.lastAttemptAt !== void 0 && (typeof parsed.lastAttemptAt !== "number" || !Number.isFinite(parsed.lastAttemptAt))) {
+    throw new Error("Invalid chunk recovery timestamp");
+  }
+  return { attempts, lastAttemptAt: parsed.lastAttemptAt };
+}
+function claimChunkRecoveryAttempt(storage, options) {
+  const {
+    cooldownMs = DEFAULT_CHUNK_RECOVERY_COOLDOWN_MS,
+    now,
+    recoveryId,
+    storageKey = CHUNK_RECOVERY_STORAGE_KEY
+  } = options;
+  let state;
+  try {
+    state = parseStoredChunkRecoveryState(storage.getItem(storageKey));
+  } catch {
+    return { claimed: false, reason: "storage-unavailable" };
+  }
+  const existingAttempt = state.attempts.find((attempt) => attempt.recoveryId === recoveryId);
+  if (existingAttempt) {
+    return {
+      claimed: false,
+      reason: "already-attempted",
+      attemptedAt: existingAttempt.attemptedAt
+    };
+  }
+  const inCooldown = state.lastAttemptAt !== void 0 && (state.lastAttemptAt > now || now - state.lastAttemptAt < cooldownMs);
+  if (inCooldown) {
+    return { claimed: false, reason: "cooldown", attemptedAt: state.lastAttemptAt };
+  }
+  try {
+    storage.setItem(
+      storageKey,
+      JSON.stringify({
+        attempts: [...state.attempts, { attemptedAt: now, recoveryId }],
+        lastAttemptAt: now
+      })
+    );
+  } catch {
+    return { claimed: false, reason: "storage-unavailable" };
+  }
+  return { claimed: true, attemptedAt: now };
+}
+function isMicroAppRuntime() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  const runtimeWindow = window;
+  return Boolean(runtimeWindow.__POWERED_BY_QIANKUN__ || runtimeWindow.__GARFISH__);
+}
+function getSessionStorage() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  try {
+    return window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+function invokeSafely(callback, label) {
+  if (!callback) {
+    return;
+  }
+  try {
+    callback();
+  } catch (error) {
+    console.error(`[ywkf] ${label} \u6267\u884C\u5931\u8D25:`, error);
+  }
+}
+function schedulePageReplace(timestamp) {
+  setTimeout(() => {
+    try {
+      const reloadUrl = new URL(window.location.href);
+      reloadUrl.searchParams.set(CHUNK_RECOVERY_CACHE_BUST_PARAM, String(timestamp));
+      window.location.replace(reloadUrl.toString());
+    } catch (error) {
+      console.error("[ywkf] chunk \u6062\u590D\u5237\u65B0\u5931\u8D25:", error);
+    }
+  }, 0);
+}
+function clearChunkRecoveryCacheBustParam() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  try {
+    const currentUrl = new URL(window.location.href);
+    if (!currentUrl.searchParams.has(CHUNK_RECOVERY_CACHE_BUST_PARAM)) {
+      return;
+    }
+    currentUrl.searchParams.delete(CHUNK_RECOVERY_CACHE_BUST_PARAM);
+    window.history.replaceState(window.history.state, "", currentUrl.toString());
+  } catch (error) {
+    console.error("[ywkf] \u6E05\u7406 chunk \u6062\u590D\u53C2\u6570\u5931\u8D25:", error);
+  }
+}
+function handleChunkLoadErrorInternal(reason, options, trustedChunkEvent) {
+  if (!trustedChunkEvent && !isChunkLoadError(reason)) {
+    return null;
+  }
+  const error = toError(reason);
+  const timestamp = Date.now();
+  const recoveryId = resolveRecoveryId(reason, options.config);
+  const isMicroApp = options.isMicroApp ?? isMicroAppRuntime();
+  const policy = resolveChunkRecoveryPolicy(options.config, {
+    isProduction: process.env.NODE_ENV === "production",
+    isMicroApp
+  });
+  let outcome;
+  if (!policy.enabled) {
+    outcome = policy.disabledReason === "micro-app" ? "reload-skipped-micro-app" : "reload-skipped-disabled";
+  } else {
+    const storage = getSessionStorage();
+    const claim = storage ? claimChunkRecoveryAttempt(storage, {
+      cooldownMs: policy.cooldownMs,
+      now: timestamp,
+      recoveryId
+    }) : { claimed: false, reason: "storage-unavailable" };
+    if (claim.claimed) {
+      outcome = "reload-scheduled";
+    } else if (claim.reason === "already-attempted") {
+      outcome = "reload-skipped-already-attempted";
+    } else if (claim.reason === "cooldown") {
+      outcome = "reload-skipped-cooldown";
+    } else {
+      outcome = "reload-skipped-storage-unavailable";
+    }
+  }
+  const event = {
+    error,
+    source: options.source,
+    outcome,
+    timestamp,
+    cooldownMs: policy.cooldownMs,
+    recoveryId
+  };
+  invokeSafely(() => options.onError?.(error), "onError");
+  invokeSafely(() => options.onRecoveryEvent?.(event), "onRecoveryEvent");
+  if (outcome === "reload-scheduled") {
+    schedulePageReplace(timestamp);
+  }
+  return event;
+}
+function handleChunkLoadError(reason, options) {
+  return handleChunkLoadErrorInternal(reason, options, false);
+}
+function getLatestSubscriber(registry) {
+  let latest;
+  for (const subscriber of registry.subscribers.values()) {
+    latest = subscriber;
+  }
+  return latest;
+}
+function createGlobalChunkRecoveryRegistry() {
+  const registry = {
+    subscribers: /* @__PURE__ */ new Map()
+  };
+  registry.handleUnhandledRejection = (event) => {
+    const subscriber = getLatestSubscriber(registry);
+    if (!subscriber) return;
+    const recoveryEvent = handleChunkLoadError(event.reason, {
+      ...subscriber,
+      source: "unhandled-rejection"
+    });
+    if (recoveryEvent?.outcome === "reload-scheduled") {
+      event.preventDefault();
+    }
+  };
+  registry.handleVitePreloadError = (event) => {
+    const subscriber = getLatestSubscriber(registry);
+    if (!subscriber) return;
+    const payload = event.payload;
+    const recoveryEvent = handleChunkLoadErrorInternal(
+      payload,
+      {
+        ...subscriber,
+        source: "vite-preload-error"
+      },
+      true
+    );
+    if (recoveryEvent?.outcome === "reload-scheduled") {
+      event.preventDefault();
+    }
+  };
+  return registry;
+}
+function installGlobalChunkRecoveryHandlers(options) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const isMicroApp = options.isMicroApp ?? isMicroAppRuntime();
+  const policy = resolveChunkRecoveryPolicy(options.config, {
+    isProduction: process.env.NODE_ENV === "production",
+    isMicroApp
+  });
+  if (!policy.enabled || !policy.globalHandlers) {
+    return () => {
+    };
+  }
+  const runtimeWindow = window;
+  let registry = runtimeWindow[CHUNK_RECOVERY_REGISTRY_SYMBOL];
+  if (!registry && runtimeWindow[CHUNK_RECOVERY_ACTIVE_SYMBOL] === true) {
+    return () => {
+    };
+  }
+  if (!registry) {
+    registry = createGlobalChunkRecoveryRegistry();
+    runtimeWindow[CHUNK_RECOVERY_REGISTRY_SYMBOL] = registry;
+    runtimeWindow[CHUNK_RECOVERY_ACTIVE_SYMBOL] = true;
+    window.addEventListener("unhandledrejection", registry.handleUnhandledRejection);
+    window.addEventListener("vite:preloadError", registry.handleVitePreloadError);
+  }
+  const subscriberId = /* @__PURE__ */ Symbol("chunk-recovery-subscriber");
+  registry.subscribers.set(subscriberId, { ...options, isMicroApp });
+  let disposed = false;
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    registry.subscribers.delete(subscriberId);
+    if (registry.subscribers.size > 0) return;
+    window.removeEventListener("unhandledrejection", registry.handleUnhandledRejection);
+    window.removeEventListener("vite:preloadError", registry.handleVitePreloadError);
+    if (runtimeWindow[CHUNK_RECOVERY_REGISTRY_SYMBOL] === registry) {
+      delete runtimeWindow[CHUNK_RECOVERY_REGISTRY_SYMBOL];
+      delete runtimeWindow[CHUNK_RECOVERY_ACTIVE_SYMBOL];
+    }
+  };
+}
+
 // src/runtime/bootstrap.tsx
 import { createRoot } from "react-dom/client";
 
@@ -49,8 +413,23 @@ function useIsDev() {
 }
 
 // src/runtime/error-boundary.tsx
-import { Component } from "react";
+import {
+  Component,
+  createContext as createContext2,
+  useContext as useContext2,
+  useEffect,
+  useMemo,
+  useRef
+} from "react";
+import { isRouteErrorResponse, useRouteError } from "react-router";
 import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var ChunkRecoveryRuntimeContext = createContext2(null);
+function ChunkRecoveryRuntimeProvider({
+  children,
+  ...value
+}) {
+  return /* @__PURE__ */ jsx2(ChunkRecoveryRuntimeContext.Provider, { value, children });
+}
 var ErrorBoundary = class extends Component {
   constructor(props) {
     super(props);
@@ -60,15 +439,31 @@ var ErrorBoundary = class extends Component {
     return { hasError: true, error };
   }
   componentDidCatch(error, errorInfo) {
-    console.error("[ErrorBoundary] Caught error:", error, errorInfo);
-    this.props.onError?.(error, errorInfo);
+    const reportError = () => {
+      console.error("[ErrorBoundary] Caught error:", error, errorInfo);
+      this.props.onError?.(error, errorInfo);
+    };
+    if (this.props.chunkRecovery === void 0) {
+      reportError();
+      return;
+    }
+    const recoveryEvent = handleChunkLoadError(error, {
+      source: "error-boundary",
+      config: this.props.chunkRecovery,
+      isMicroApp: this.props.isMicroApp,
+      onError: reportError,
+      onRecoveryEvent: this.props.onRecoveryEvent
+    });
+    if (!recoveryEvent) {
+      reportError();
+    }
   }
   reset = () => {
     this.setState({ hasError: false, error: null });
   };
   render() {
     const { hasError, error } = this.state;
-    const { children, fallback } = this.props;
+    const { children, chunkRecovery, fallback, isMicroApp } = this.props;
     if (hasError && error) {
       if (typeof fallback === "function") {
         return fallback(error, this.reset);
@@ -76,12 +471,86 @@ var ErrorBoundary = class extends Component {
       if (fallback) {
         return fallback;
       }
-      return /* @__PURE__ */ jsx2(DefaultErrorFallback, { error, onReset: this.reset });
+      const resolvedIsMicroApp = isMicroApp ?? isMicroAppRuntime();
+      const chunkRecoveryEnabled = chunkRecovery !== void 0 && resolveChunkRecoveryPolicy(chunkRecovery, {
+        isProduction: process.env.NODE_ENV === "production",
+        isMicroApp: resolvedIsMicroApp
+      }).enabled;
+      const canReloadPage = !resolvedIsMicroApp || typeof chunkRecovery === "object" && chunkRecovery.allowInMicroApp === true;
+      return /* @__PURE__ */ jsx2(
+        DefaultErrorFallback,
+        {
+          canReloadPage,
+          error,
+          isChunkError: chunkRecoveryEnabled && isChunkLoadError(error),
+          onReset: this.reset
+        }
+      );
     }
     return children;
   }
 };
-function DefaultErrorFallback({ error, onReset }) {
+var UNHANDLED_ROUTE_ERROR = /* @__PURE__ */ Symbol("unhandled-route-error");
+function normalizeRouteError(reason) {
+  if (reason instanceof Error) return reason;
+  if (typeof reason === "string") return new Error(reason);
+  if (isRouteErrorResponse(reason)) {
+    const message = [reason.status, reason.statusText].filter(Boolean).join(" ");
+    const error = new Error(message || "Route request failed");
+    error.name = "RouteErrorResponse";
+    return error;
+  }
+  return new Error("Route rendering failed");
+}
+function RouteErrorBoundary({ fallback }) {
+  const reason = useRouteError();
+  const error = useMemo(() => normalizeRouteError(reason), [reason]);
+  const recoveryRuntime = useContext2(ChunkRecoveryRuntimeContext);
+  const handledReasonRef = useRef(UNHANDLED_ROUTE_ERROR);
+  useEffect(() => {
+    if (Object.is(handledReasonRef.current, reason)) return;
+    handledReasonRef.current = reason;
+    const reportError = () => {
+      console.error("[RouteErrorBoundary] Caught error:", error);
+      recoveryRuntime?.onError?.(error);
+    };
+    if (!recoveryRuntime) {
+      reportError();
+      return;
+    }
+    const recoveryEvent = handleChunkLoadError(reason, {
+      source: "route-error-boundary",
+      config: recoveryRuntime.chunkRecovery,
+      isMicroApp: recoveryRuntime.isMicroApp,
+      onError: reportError,
+      onRecoveryEvent: recoveryRuntime.onRecoveryEvent
+    });
+    if (!recoveryEvent) reportError();
+  }, [error, reason, recoveryRuntime]);
+  if (typeof fallback === "function") return fallback(error);
+  if (fallback) return fallback;
+  const chunkRecovery = recoveryRuntime?.chunkRecovery;
+  const resolvedIsMicroApp = recoveryRuntime?.isMicroApp ?? isMicroAppRuntime();
+  const chunkRecoveryEnabled = chunkRecovery !== void 0 && resolveChunkRecoveryPolicy(chunkRecovery, {
+    isProduction: process.env.NODE_ENV === "production",
+    isMicroApp: resolvedIsMicroApp
+  }).enabled;
+  const canReloadPage = !resolvedIsMicroApp || typeof chunkRecovery === "object" && chunkRecovery.allowInMicroApp === true;
+  return /* @__PURE__ */ jsx2(
+    DefaultErrorFallback,
+    {
+      canReloadPage,
+      error,
+      isChunkError: chunkRecoveryEnabled && isChunkLoadError(reason)
+    }
+  );
+}
+function DefaultErrorFallback({
+  canReloadPage,
+  error,
+  isChunkError,
+  onReset
+}) {
   const isDev = process.env.NODE_ENV === "development";
   return /* @__PURE__ */ jsx2(
     "div",
@@ -107,7 +576,7 @@ function DefaultErrorFallback({ error, onReset }) {
           },
           children: [
             /* @__PURE__ */ jsx2("h1", { style: { color: "#ff4d4f", marginBottom: 16 }, children: "\u9875\u9762\u51FA\u9519\u4E86" }),
-            /* @__PURE__ */ jsx2("p", { style: { color: "#666", marginBottom: 16 }, children: "\u62B1\u6B49\uFF0C\u9875\u9762\u9047\u5230\u4E86\u4E00\u4E9B\u95EE\u9898\u3002\u8BF7\u5C1D\u8BD5\u5237\u65B0\u9875\u9762\u6216\u8054\u7CFB\u7BA1\u7406\u5458\u3002" }),
+            /* @__PURE__ */ jsx2("p", { style: { color: "#666", marginBottom: 16 }, children: canReloadPage ? "\u62B1\u6B49\uFF0C\u9875\u9762\u9047\u5230\u4E86\u4E00\u4E9B\u95EE\u9898\u3002\u8BF7\u5C1D\u8BD5\u5237\u65B0\u9875\u9762\u6216\u8054\u7CFB\u7BA1\u7406\u5458\u3002" : "\u62B1\u6B49\uFF0C\u9875\u9762\u9047\u5230\u4E86\u4E00\u4E9B\u95EE\u9898\u3002\u8BF7\u5173\u95ED\u5F53\u524D\u9875\u9762\u540E\u91CD\u65B0\u6253\u5F00\uFF0C\u6216\u8054\u7CFB\u7BA1\u7406\u5458\u3002" }),
             isDev && /* @__PURE__ */ jsxs(
               "details",
               {
@@ -141,8 +610,8 @@ function DefaultErrorFallback({ error, onReset }) {
                 ]
               }
             ),
-            /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: 8 }, children: [
-              /* @__PURE__ */ jsx2(
+            (canReloadPage || !isChunkError && onReset) && /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: 8 }, children: [
+              !isChunkError && onReset && /* @__PURE__ */ jsx2(
                 "button",
                 {
                   onClick: onReset,
@@ -157,7 +626,7 @@ function DefaultErrorFallback({ error, onReset }) {
                   children: "\u91CD\u8BD5"
                 }
               ),
-              /* @__PURE__ */ jsx2(
+              canReloadPage && /* @__PURE__ */ jsx2(
                 "button",
                 {
                   onClick: () => window.location.reload(),
@@ -206,7 +675,7 @@ function composeProviders(providers) {
     }, children);
   };
 }
-function RootProvider({ config, children }) {
+function RootProvider({ config, children, isMicroApp }) {
   const {
     appName = "app",
     router,
@@ -214,7 +683,8 @@ function RootProvider({ config, children }) {
     strictMode = true,
     antd = { enabled: true },
     providers = [],
-    lifecycle
+    lifecycle,
+    chunkRecovery
   } = config;
   const appContextValue = {
     appName,
@@ -245,8 +715,30 @@ function RootProvider({ config, children }) {
     ...providers.map((p) => ({ ...p, order: p.order ?? 50 }))
   ];
   const ComposedProviders = composeProviders(allProviders);
+  const rootChunkRecovery = chunkRecovery ?? {
+    enabled: process.env.NODE_ENV === "production"
+  };
+  const resolvedIsMicroApp = isMicroApp ?? isMicroAppRuntime();
   const content = router ? /* @__PURE__ */ jsx3(Suspense, { fallback: /* @__PURE__ */ jsx3(DefaultLoading, {}), children: /* @__PURE__ */ jsx3(RouterProvider, { router }) }) : children;
-  const app = /* @__PURE__ */ jsx3(ErrorBoundary, { onError: lifecycle?.onError, children: /* @__PURE__ */ jsx3(ComposedProviders, { children: content }) });
+  const app = /* @__PURE__ */ jsx3(
+    ErrorBoundary,
+    {
+      chunkRecovery: rootChunkRecovery,
+      isMicroApp: resolvedIsMicroApp,
+      onError: lifecycle?.onError,
+      onRecoveryEvent: lifecycle?.onRecoveryEvent,
+      children: /* @__PURE__ */ jsx3(
+        ChunkRecoveryRuntimeProvider,
+        {
+          chunkRecovery: rootChunkRecovery,
+          isMicroApp: resolvedIsMicroApp,
+          onError: lifecycle?.onError,
+          onRecoveryEvent: lifecycle?.onRecoveryEvent,
+          children: /* @__PURE__ */ jsx3(ComposedProviders, { children: content })
+        }
+      )
+    }
+  );
   if (strictMode) {
     return /* @__PURE__ */ jsx3(StrictMode, { children: app });
   }
@@ -263,6 +755,7 @@ function createProvider(component, props, order) {
 // src/runtime/bootstrap.tsx
 import { jsx as jsx4 } from "react/jsx-runtime";
 var root = null;
+var disposeChunkRecoveryHandlers = null;
 async function resolveAppConfig(config) {
   if (config.router || !config.conventionalRoutes) {
     return config;
@@ -285,6 +778,10 @@ async function resolveAppConfig(config) {
 }
 async function bootstrap(config) {
   const { rootId = "root", lifecycle } = config;
+  const isMicroApp = isMicroAppEnv();
+  if (!isMicroApp) {
+    clearChunkRecoveryCacheBustParam();
+  }
   const resolvedConfig = await resolveAppConfig(config);
   if (lifecycle?.onBeforeMount) {
     await lifecycle.onBeforeMount();
@@ -293,8 +790,22 @@ async function bootstrap(config) {
   if (!rootElement) {
     throw new Error(`\u627E\u4E0D\u5230\u6839\u5143\u7D20 #${rootId}`);
   }
-  root = createRoot(rootElement);
-  root.render(/* @__PURE__ */ jsx4(RootProvider, { config: resolvedConfig }));
+  disposeChunkRecoveryHandlers?.();
+  const nextDisposeChunkRecoveryHandlers = installGlobalChunkRecoveryHandlers({
+    config: resolvedConfig.chunkRecovery,
+    isMicroApp,
+    onError: (error) => resolvedConfig.lifecycle?.onError?.(error),
+    onRecoveryEvent: resolvedConfig.lifecycle?.onRecoveryEvent
+  });
+  try {
+    root = createRoot(rootElement);
+    root.render(/* @__PURE__ */ jsx4(RootProvider, { config: resolvedConfig, isMicroApp }));
+    disposeChunkRecoveryHandlers = nextDisposeChunkRecoveryHandlers;
+  } catch (error) {
+    nextDisposeChunkRecoveryHandlers();
+    root = null;
+    throw error;
+  }
   if (lifecycle?.onMounted) {
     setTimeout(() => {
       lifecycle.onMounted?.();
@@ -307,6 +818,8 @@ async function bootstrap(config) {
   }
 }
 function unmount() {
+  disposeChunkRecoveryHandlers?.();
+  disposeChunkRecoveryHandlers = null;
   if (root) {
     root.unmount();
     root = null;
@@ -314,6 +827,7 @@ function unmount() {
 }
 function createMicroApp(getConfig) {
   let microRoot = null;
+  let disposeMicroChunkRecoveryHandlers = null;
   return {
     /**
      * 微前端 bootstrap 生命周期
@@ -337,8 +851,22 @@ function createMicroApp(getConfig) {
       if (resolvedConfig.lifecycle?.onBeforeMount) {
         await resolvedConfig.lifecycle.onBeforeMount();
       }
-      microRoot = createRoot(rootElement);
-      microRoot.render(/* @__PURE__ */ jsx4(RootProvider, { config: resolvedConfig }));
+      disposeMicroChunkRecoveryHandlers?.();
+      const nextDisposeMicroChunkRecoveryHandlers = installGlobalChunkRecoveryHandlers({
+        config: resolvedConfig.chunkRecovery,
+        isMicroApp: true,
+        onError: (error) => resolvedConfig.lifecycle?.onError?.(error),
+        onRecoveryEvent: resolvedConfig.lifecycle?.onRecoveryEvent
+      });
+      try {
+        microRoot = createRoot(rootElement);
+        microRoot.render(/* @__PURE__ */ jsx4(RootProvider, { config: resolvedConfig, isMicroApp: true }));
+        disposeMicroChunkRecoveryHandlers = nextDisposeMicroChunkRecoveryHandlers;
+      } catch (error) {
+        nextDisposeMicroChunkRecoveryHandlers();
+        microRoot = null;
+        throw error;
+      }
       if (resolvedConfig.lifecycle?.onMounted) {
         setTimeout(() => {
           resolvedConfig.lifecycle?.onMounted?.();
@@ -358,6 +886,8 @@ function createMicroApp(getConfig) {
         microRoot.unmount();
         microRoot = null;
       }
+      disposeMicroChunkRecoveryHandlers?.();
+      disposeMicroChunkRecoveryHandlers = null;
     },
     /**
      * 微前端 update 生命周期（可选）
@@ -369,6 +899,7 @@ function createMicroApp(getConfig) {
 }
 function createGarfishProvider(getConfig) {
   let garfishRoot = null;
+  let disposeGarfishChunkRecoveryHandlers = null;
   return function provider(providerContext) {
     const { dom, basename } = providerContext;
     return {
@@ -382,8 +913,22 @@ function createGarfishProvider(getConfig) {
           rootElement.id = rootId;
           dom.appendChild(rootElement);
         }
-        garfishRoot = createRoot(rootElement);
-        garfishRoot.render(/* @__PURE__ */ jsx4(RootProvider, { config: resolvedConfig }));
+        disposeGarfishChunkRecoveryHandlers?.();
+        const nextDisposeGarfishChunkRecoveryHandlers = installGlobalChunkRecoveryHandlers({
+          config: resolvedConfig.chunkRecovery,
+          isMicroApp: true,
+          onError: (error) => resolvedConfig.lifecycle?.onError?.(error),
+          onRecoveryEvent: resolvedConfig.lifecycle?.onRecoveryEvent
+        });
+        try {
+          garfishRoot = createRoot(rootElement);
+          garfishRoot.render(/* @__PURE__ */ jsx4(RootProvider, { config: resolvedConfig, isMicroApp: true }));
+          disposeGarfishChunkRecoveryHandlers = nextDisposeGarfishChunkRecoveryHandlers;
+        } catch (error) {
+          nextDisposeGarfishChunkRecoveryHandlers();
+          garfishRoot = null;
+          throw error;
+        }
         if (resolvedConfig.lifecycle?.onMounted) {
           setTimeout(() => resolvedConfig.lifecycle?.onMounted?.(), 0);
         }
@@ -393,6 +938,8 @@ function createGarfishProvider(getConfig) {
           garfishRoot.unmount();
           garfishRoot = null;
         }
+        disposeGarfishChunkRecoveryHandlers?.();
+        disposeGarfishChunkRecoveryHandlers = null;
       }
     };
   };
@@ -415,14 +962,26 @@ function getMicroAppPublicPath() {
 export {
   AppContext,
   AppContextProvider,
+  CHUNK_RECOVERY_ACTIVE_SYMBOL,
+  CHUNK_RECOVERY_CACHE_BUST_PARAM,
+  CHUNK_RECOVERY_STORAGE_KEY,
+  DEFAULT_CHUNK_RECOVERY_COOLDOWN_MS,
   ErrorBoundary,
   RootProvider,
+  RouteErrorBoundary,
   bootstrap,
+  claimChunkRecoveryAttempt,
+  clearChunkRecoveryCacheBustParam,
   createGarfishProvider,
   createMicroApp,
   createProvider,
   getMicroAppPublicPath,
+  handleChunkLoadError,
+  installGlobalChunkRecoveryHandlers,
+  isChunkLoadError,
   isMicroAppEnv,
+  isMicroAppRuntime,
+  resolveChunkRecoveryPolicy,
   unmount,
   useApp,
   useAppName,